Browse Source

Prefix all CMake options with MAGNUM_*.

Similar to the change done in Corrade, see the commit for details:
878624ac36

Wow, this is probably the most backwards-compatibility code I've ever
written. Can't wait until I can drop all that.
pull/570/head
Vladimír Vondruš 4 years ago
parent
commit
b983781505
  1. 469
      CMakeLists.txt
  2. 370
      doc/building.dox
  3. 7
      doc/changelog.dox
  4. 6
      doc/cmake.dox
  5. 41
      doc/developers.dox
  6. 19
      doc/getting-started.dox
  7. 86
      doc/namespaces.dox
  8. 4
      doc/platforms-android.dox
  9. 10
      doc/plugins.dox
  10. 38
      doc/snippets/CMakeLists.txt
  11. 9
      doc/troubleshooting.dox
  12. 2
      modules/FindMagnum.cmake
  13. 2
      src/CMakeLists.txt
  14. 2
      src/Magnum/Animation/CMakeLists.txt
  15. 20
      src/Magnum/Audio/CMakeLists.txt
  16. 6
      src/Magnum/Audio/Extensions.h
  17. 4
      src/Magnum/Audio/Test/CMakeLists.txt
  18. 8
      src/Magnum/Audio/al-info.cpp
  19. 42
      src/Magnum/CMakeLists.txt
  20. 34
      src/Magnum/DebugTools/CMakeLists.txt
  21. 6
      src/Magnum/DebugTools/ColorMap.h
  22. 8
      src/Magnum/DebugTools/ForceRenderer.h
  23. 8
      src/Magnum/DebugTools/ObjectRenderer.h
  24. 70
      src/Magnum/DebugTools/Test/CMakeLists.txt
  25. 38
      src/Magnum/GL/CMakeLists.txt
  26. 6
      src/Magnum/GL/Extensions.h
  27. 6
      src/Magnum/GL/OpenGLTester.h
  28. 18
      src/Magnum/GL/Test/CMakeLists.txt
  29. 2
      src/Magnum/Math/Algorithms/CMakeLists.txt
  30. 2
      src/Magnum/Math/CMakeLists.txt
  31. 22
      src/Magnum/MeshTools/CMakeLists.txt
  32. 20
      src/Magnum/MeshTools/Test/CMakeLists.txt
  33. 7
      src/Magnum/Platform/AndroidApplication.h
  34. 174
      src/Magnum/Platform/CMakeLists.txt
  35. 6
      src/Magnum/Platform/EmscriptenApplication.h
  36. 6
      src/Magnum/Platform/GlfwApplication.h
  37. 8
      src/Magnum/Platform/GlxApplication.h
  38. 6
      src/Magnum/Platform/Sdl2Application.h
  39. 26
      src/Magnum/Platform/Test/CMakeLists.txt
  40. 6
      src/Magnum/Platform/WindowlessCglApplication.h
  41. 7
      src/Magnum/Platform/WindowlessEglApplication.h
  42. 6
      src/Magnum/Platform/WindowlessGlxApplication.h
  43. 4
      src/Magnum/Platform/WindowlessIosApplication.h
  44. 6
      src/Magnum/Platform/WindowlessWglApplication.h
  45. 7
      src/Magnum/Platform/WindowlessWindowsEglApplication.h
  46. 6
      src/Magnum/Platform/XEglApplication.h
  47. 8
      src/Magnum/Platform/gl-info.cpp
  48. 6
      src/Magnum/Primitives/CMakeLists.txt
  49. 10
      src/Magnum/SceneGraph/CMakeLists.txt
  50. 14
      src/Magnum/SceneTools/CMakeLists.txt
  51. 8
      src/Magnum/SceneTools/sceneconverter.cpp
  52. 14
      src/Magnum/ShaderTools/CMakeLists.txt
  53. 4
      src/Magnum/ShaderTools/shaderconverter.cpp
  54. 18
      src/Magnum/Shaders/CMakeLists.txt
  55. 74
      src/Magnum/Shaders/Test/CMakeLists.txt
  56. 28
      src/Magnum/Text/CMakeLists.txt
  57. 2
      src/Magnum/Text/Test/CMakeLists.txt
  58. 4
      src/Magnum/Text/fontconverter.cpp
  59. 20
      src/Magnum/TextureTools/CMakeLists.txt
  60. 18
      src/Magnum/TextureTools/Test/CMakeLists.txt
  61. 4
      src/Magnum/TextureTools/distancefieldconverter.cpp
  62. 14
      src/Magnum/Trade/CMakeLists.txt
  63. 8
      src/Magnum/Trade/imageconverter.cpp
  64. 20
      src/Magnum/Vk/CMakeLists.txt
  65. 6
      src/Magnum/Vk/Extensions.h
  66. 22
      src/Magnum/Vk/Test/CMakeLists.txt
  67. 6
      src/Magnum/Vk/VulkanTester.h
  68. 8
      src/Magnum/Vk/vk-info.cpp
  69. 6
      src/MagnumExternal/CMakeLists.txt
  70. 4
      src/MagnumExternal/OpenGL/CMakeLists.txt
  71. 4
      src/MagnumExternal/OpenGL/GL/CMakeLists.txt
  72. 4
      src/MagnumExternal/OpenGL/GLES2/CMakeLists.txt
  73. 4
      src/MagnumExternal/OpenGL/GLES3/CMakeLists.txt
  74. 4
      src/MagnumExternal/Vulkan/CMakeLists.txt
  75. 6
      src/MagnumPlugins/AnyAudioImporter/AnyImporter.h
  76. 6
      src/MagnumPlugins/AnyAudioImporter/CMakeLists.txt
  77. 6
      src/MagnumPlugins/AnyAudioImporter/Test/CMakeLists.txt
  78. 6
      src/MagnumPlugins/AnyImageConverter/AnyImageConverter.h
  79. 6
      src/MagnumPlugins/AnyImageConverter/CMakeLists.txt
  80. 6
      src/MagnumPlugins/AnyImageConverter/Test/CMakeLists.txt
  81. 6
      src/MagnumPlugins/AnyImageImporter/AnyImageImporter.h
  82. 6
      src/MagnumPlugins/AnyImageImporter/CMakeLists.txt
  83. 6
      src/MagnumPlugins/AnyImageImporter/Test/CMakeLists.txt
  84. 6
      src/MagnumPlugins/AnySceneConverter/AnySceneConverter.h
  85. 6
      src/MagnumPlugins/AnySceneConverter/CMakeLists.txt
  86. 6
      src/MagnumPlugins/AnySceneConverter/Test/CMakeLists.txt
  87. 6
      src/MagnumPlugins/AnySceneImporter/AnySceneImporter.h
  88. 6
      src/MagnumPlugins/AnySceneImporter/CMakeLists.txt
  89. 6
      src/MagnumPlugins/AnySceneImporter/Test/CMakeLists.txt
  90. 6
      src/MagnumPlugins/AnyShaderConverter/AnyConverter.h
  91. 6
      src/MagnumPlugins/AnyShaderConverter/CMakeLists.txt
  92. 24
      src/MagnumPlugins/CMakeLists.txt
  93. 10
      src/MagnumPlugins/MagnumFont/CMakeLists.txt
  94. 8
      src/MagnumPlugins/MagnumFont/MagnumFont.h
  95. 2
      src/MagnumPlugins/MagnumFont/Test/CMakeLists.txt
  96. 6
      src/MagnumPlugins/MagnumFontConverter/CMakeLists.txt
  97. 4
      src/MagnumPlugins/MagnumFontConverter/MagnumFontConverter.h
  98. 6
      src/MagnumPlugins/MagnumFontConverter/Test/CMakeLists.txt
  99. 6
      src/MagnumPlugins/ObjImporter/CMakeLists.txt
  100. 8
      src/MagnumPlugins/ObjImporter/ObjImporter.h
  101. Some files were not shown because too many files have changed in this diff Show More

469
CMakeLists.txt

@ -39,7 +39,8 @@ endif()
if(POLICY CMP0071)
cmake_policy(SET CMP0071 NEW)
endif()
# Superprojects can use just set(WITH_BLAH ON) without FORCE CACHE on 3.13+
# Superprojects can use just set(MAGNUM_WITH_BLAH ON) without FORCE CACHE on
# 3.13+
if(POLICY CMP0077)
cmake_policy(SET CMP0077 NEW)
endif()
@ -60,129 +61,212 @@ find_package(Corrade REQUIRED Utility)
include(CMakeDependentOption)
# Options that used to be unprefixed. 66 values for 67 option() and
# cmake_dependent_option() calls, one of which is HUNTER_ENABLED that we don't
# prefix. New options shouldn't be added to this list.
set(_MAGNUM_DEPRECATED_UNPREFIXED_OPTIONS
WITH_AUDIO
WITH_DEBUGTOOLS
WITH_GL
WITH_MESHTOOLS
WITH_PRIMITIVES
WITH_SCENEGRAPH
WITH_SCENETOOLS
WITH_SHADERS
WITH_SHADERTOOLS
WITH_TEXT
WITH_TEXTURETOOLS
WITH_TRADE
WITH_VK
WITH_OPENGLTESTER
WITH_VULKANTESTER
WITH_ANDROIDAPPLICATION
WITH_EMSCRIPTENAPPLICATION
WITH_GLXAPPLICATION
WITH_GLFWAPPLICATION
WITH_SDL2APPLICATION
WITH_XEGLAPPLICATION
WITH_WINDOWLESSCGLAPPLICATION
WITH_WINDOWLESSEGLAPPLICATION
WITH_WINDOWLESSGLXAPPLICATION
WITH_WINDOWLESSIOSAPPLICATION
WITH_WINDOWLESSWGLAPPLICATION
WITH_WINDOWLESSWINDOWSEGLAPPLICATION
WITH_CGLCONTEXT
WITH_EGLCONTEXT
WITH_GLXCONTEXT
WITH_WGLCONTEXT
WITH_GL_INFO
WITH_AL_INFO
WITH_VK_INFO
WITH_FONTCONVERTER
WITH_DISTANCEFIELDCONVERTER
WITH_IMAGECONVERTER
WITH_SCENECONVERTER
WITH_SHADERCONVERTER
WITH_ANYAUDIOIMPORTER
WITH_ANYIMAGECONVERTER
WITH_ANYIMAGEIMPORTER
WITH_ANYSCENECONVERTER
WITH_ANYSCENEIMPORTER
WITH_ANYSHADERCONVERTER
WITH_MAGNUMFONT
WITH_MAGNUMFONTCONVERTER
WITH_OBJIMPORTER
WITH_TGAIMPORTER
WITH_TGAIMAGECONVERTER
WITH_WAVAUDIOIMPORTER
BUILD_DEPRECATED
BUILD_STATIC
BUILD_STATIC_PIC
BUILD_STATIC_UNIQUE_GLOBALS
BUILD_PLUGINS_STATIC
BUILD_TESTS
BUILD_GL_TESTS
BUILD_AL_TESTS
BUILD_VK_TESTS
TARGET_GL
TARGET_GLES
TARGET_GLES2
TARGET_DESKTOP_GLES
TARGET_HEADLESS
TARGET_VK)
# If during the first run (i.e., when the variable isn't in cache yet), check
# if any of the prefixed options are already set. If so, we assume the user is
# already switched to the prefixed options and won't accept the deprecated
# unprefixed options for backwards compatibility. This way it's possible for
# projects to reuse these variables for other purposes without affecting
# Magnum in any way.
if(NOT DEFINED _MAGNUM_ACCEPT_DEPRECATED_UNPREFIXED_OPTIONS)
set(_MAGNUM_ACCEPT_DEPRECATED_UNPREFIXED_OPTIONS ON CACHE INTERNAL "")
foreach(option ${_MAGNUM_DEPRECATED_UNPREFIXED_OPTIONS})
if(DEFINED MAGNUM_${option})
set(_MAGNUM_ACCEPT_DEPRECATED_UNPREFIXED_OPTIONS OFF CACHE INTERNAL "")
break()
endif()
endforeach()
endif()
# If targeting iOS, Android, Emscripten or Windows RT, set explicit OpenGL ES
# support
if(NOT CORRADE_TARGET_IOS AND NOT CORRADE_TARGET_ANDROID AND NOT CORRADE_TARGET_EMSCRIPTEN AND NOT CORRADE_TARGET_WINDOWS_RT)
option(TARGET_GLES "Build for OpenGL ES / WebGL" OFF)
option(MAGNUM_TARGET_GLES "Build for OpenGL ES / WebGL" OFF)
else()
set(TARGET_GLES ON)
set(MAGNUM_TARGET_GLES ON)
endif()
cmake_dependent_option(TARGET_GLES2 "Build for OpenGL ES 2 / WebGL 1.0" ON "TARGET_GLES" OFF)
cmake_dependent_option(TARGET_DESKTOP_GLES "Build for OpenGL ES on desktop" OFF "TARGET_GLES" OFF)
cmake_dependent_option(MAGNUM_TARGET_GLES2 "Build for OpenGL ES 2 / WebGL 1.0" ON "MAGNUM_TARGET_GLES" OFF)
cmake_dependent_option(MAGNUM_TARGET_DESKTOP_GLES "Build for OpenGL ES on desktop" OFF "MAGNUM_TARGET_GLES" OFF)
# Magnum GL Info (currently only using GLX/CGL/EGL on *nix, WGL/EGL on Windows
# and EGL on Emscripten)
if(CORRADE_TARGET_UNIX OR CORRADE_TARGET_WINDOWS OR CORRADE_TARGET_EMSCRIPTEN)
option(WITH_GL_INFO "Build magnum-gl-info utility" OFF)
option(MAGNUM_WITH_GL_INFO "Build magnum-gl-info utility" OFF)
endif()
# Desktop-only utilities
if(CORRADE_TARGET_UNIX OR CORRADE_TARGET_WINDOWS)
cmake_dependent_option(WITH_FONTCONVERTER "Build magnum-fontconverter utility" OFF "NOT TARGET_GLES" OFF)
cmake_dependent_option(WITH_DISTANCEFIELDCONVERTER "Build magnum-distancefieldconverter utility" OFF "NOT TARGET_GLES" OFF)
cmake_dependent_option(MAGNUM_WITH_FONTCONVERTER "Build magnum-fontconverter utility" OFF "NOT MAGNUM_TARGET_GLES" OFF)
cmake_dependent_option(MAGNUM_WITH_DISTANCEFIELDCONVERTER "Build magnum-distancefieldconverter utility" OFF "NOT MAGNUM_TARGET_GLES" OFF)
endif()
# API-independent utilities
option(WITH_IMAGECONVERTER "Build magnum-imageconverter utility" OFF)
option(WITH_SCENECONVERTER "Build magnum-sceneconverter utility" OFF)
option(WITH_SHADERCONVERTER "Build magnum-shaderconverter utility" OFF)
option(MAGNUM_WITH_IMAGECONVERTER "Build magnum-imageconverter utility" OFF)
option(MAGNUM_WITH_SCENECONVERTER "Build magnum-sceneconverter utility" OFF)
option(MAGNUM_WITH_SHADERCONVERTER "Build magnum-shaderconverter utility" OFF)
# Magnum AL Info
option(WITH_AL_INFO "Build magnum-al-info utility" OFF)
option(MAGNUM_WITH_AL_INFO "Build magnum-al-info utility" OFF)
# Magnum Vk Info
option(WITH_VK_INFO "Build magnum-vk-info utility" OFF)
option(MAGNUM_WITH_VK_INFO "Build magnum-vk-info utility" OFF)
# Plugins
option(WITH_ANYIMAGEIMPORTER "Build AnyImageImporter plugin" OFF)
option(WITH_ANYAUDIOIMPORTER "Build AnyAudioImporter plugin" OFF)
option(WITH_ANYIMAGECONVERTER "Build AnyImageConverter plugin" OFF)
option(WITH_ANYSCENECONVERTER "Build AnySceneConverter plugin" OFF)
option(WITH_ANYSCENEIMPORTER "Build AnySceneImporter plugin" OFF)
option(WITH_ANYSHADERCONVERTER "Build AnyShaderConverter plugin" OFF)
option(WITH_WAVAUDIOIMPORTER "Build WavAudioImporter plugin" OFF)
option(WITH_MAGNUMFONT "Build MagnumFont plugin" OFF)
option(WITH_MAGNUMFONTCONVERTER "Build MagnumFontConverter plugin" OFF)
option(WITH_OBJIMPORTER "Build ObjImporter plugin" OFF)
cmake_dependent_option(WITH_TGAIMAGECONVERTER "Build TgaImageConverter plugin" OFF "NOT WITH_MAGNUMFONTCONVERTER" ON)
cmake_dependent_option(WITH_TGAIMPORTER "Build TgaImporter plugin" OFF "NOT WITH_MAGNUMFONT" ON)
option(MAGNUM_WITH_ANYIMAGEIMPORTER "Build AnyImageImporter plugin" OFF)
option(MAGNUM_WITH_ANYAUDIOIMPORTER "Build AnyAudioImporter plugin" OFF)
option(MAGNUM_WITH_ANYIMAGECONVERTER "Build AnyImageConverter plugin" OFF)
option(MAGNUM_WITH_ANYSCENECONVERTER "Build AnySceneConverter plugin" OFF)
option(MAGNUM_WITH_ANYSCENEIMPORTER "Build AnySceneImporter plugin" OFF)
option(MAGNUM_WITH_ANYSHADERCONVERTER "Build AnyShaderConverter plugin" OFF)
option(MAGNUM_WITH_WAVAUDIOIMPORTER "Build WavAudioImporter plugin" OFF)
option(MAGNUM_WITH_MAGNUMFONT "Build MagnumFont plugin" OFF)
option(MAGNUM_WITH_MAGNUMFONTCONVERTER "Build MagnumFontConverter plugin" OFF)
option(MAGNUM_WITH_OBJIMPORTER "Build ObjImporter plugin" OFF)
cmake_dependent_option(MAGNUM_WITH_TGAIMAGECONVERTER "Build TgaImageConverter plugin" OFF "NOT MAGNUM_WITH_MAGNUMFONTCONVERTER" ON)
cmake_dependent_option(MAGNUM_WITH_TGAIMPORTER "Build TgaImporter plugin" OFF "NOT MAGNUM_WITH_MAGNUMFONT" ON)
# Parts of the library
cmake_dependent_option(WITH_AUDIO "Build Audio library" OFF "NOT WITH_AL_INFO;NOT WITH_ANYAUDIOIMPORTER;NOT WITH_WAVAUDIOIMPORTER" ON)
option(WITH_DEBUGTOOLS "Build DebugTools library" ON)
cmake_dependent_option(WITH_MESHTOOLS "Build MeshTools library" ON "NOT WITH_OBJIMPORTER;NOT WITH_SCENECONVERTER" ON)
option(WITH_SCENEGRAPH "Build SceneGraph library" ON)
cmake_dependent_option(WITH_SCENETOOLS "Build SceneTools library" ON "NOT WITH_SCENECONVERTER" ON)
option(WITH_SHADERS "Build Shaders library" ON)
cmake_dependent_option(WITH_SHADERTOOLS "Build ShaderTools library" ON "NOT WITH_SHADERCONVERTER" ON)
cmake_dependent_option(WITH_TEXT "Build Text library" ON "NOT WITH_FONTCONVERTER;NOT WITH_MAGNUMFONT;NOT WITH_MAGNUMFONTCONVERTER" ON)
cmake_dependent_option(WITH_TEXTURETOOLS "Build TextureTools library" ON "NOT WITH_TEXT;NOT WITH_DISTANCEFIELDCONVERTER" ON)
cmake_dependent_option(WITH_TRADE "Build Trade library" ON "NOT WITH_MESHTOOLS;NOT WITH_PRIMITIVES;NOT WITH_SCENETOOLS;NOT WITH_IMAGECONVERTER;NOT WITH_ANYIMAGEIMPORTER;NOT WITH_ANYIMAGECONVERTER;NOT WITH_ANYSCENEIMPORTER;NOT WITH_OBJIMPORTER;NOT WITH_TGAIMAGECONVERTER;NOT WITH_TGAIMPORTER" ON)
cmake_dependent_option(WITH_GL "Build GL library" ON "NOT WITH_SHADERS;NOT WITH_GL_INFO;NOT WITH_ANDROIDAPPLICATION;NOT WITH_WINDOWLESSIOSAPPLICATION;NOT WITH_CGLCONTEXT;NOT WITH_GLXAPPLICATION;NOT WITH_GLXCONTEXT;NOT WITH_XEGLAPPLICATION;NOT WITH_WINDOWLESSWGLAPPLICATION;NOT WITH_WGLCONTEXT;NOT WITH_WINDOWLESSWINDOWSEGLAPPLICATION;NOT WITH_DISTANCEFIELDCONVERTER" ON)
option(WITH_PRIMITIVES "Build Primitives library" ON)
cmake_dependent_option(TARGET_HEADLESS "Build command-line utilities for use on a headless machines" OFF "WITH_GL" OFF)
cmake_dependent_option(TARGET_GL "Build libraries with OpenGL interoperability" ON "WITH_GL" OFF)
cmake_dependent_option(MAGNUM_WITH_AUDIO "Build Audio library" OFF "NOT MAGNUM_WITH_AL_INFO;NOT MAGNUM_WITH_ANYAUDIOIMPORTER;NOT MAGNUM_WITH_WAVAUDIOIMPORTER" ON)
option(MAGNUM_WITH_DEBUGTOOLS "Build DebugTools library" ON)
cmake_dependent_option(MAGNUM_WITH_MESHTOOLS "Build MeshTools library" ON "NOT MAGNUM_WITH_OBJIMPORTER;NOT MAGNUM_WITH_SCENECONVERTER" ON)
option(MAGNUM_WITH_SCENEGRAPH "Build SceneGraph library" ON)
cmake_dependent_option(MAGNUM_WITH_SCENETOOLS "Build SceneTools library" ON "NOT WITH_SCENECONVERTER" ON)
option(MAGNUM_WITH_SHADERS "Build Shaders library" ON)
cmake_dependent_option(MAGNUM_WITH_SHADERTOOLS "Build ShaderTools library" ON "NOT MAGNUM_WITH_SHADERCONVERTER" ON)
cmake_dependent_option(MAGNUM_WITH_TEXT "Build Text library" ON "NOT MAGNUM_WITH_FONTCONVERTER;NOT MAGNUM_WITH_MAGNUMFONT;NOT MAGNUM_WITH_MAGNUMFONTCONVERTER" ON)
cmake_dependent_option(MAGNUM_WITH_TEXTURETOOLS "Build TextureTools library" ON "NOT MAGNUM_WITH_TEXT;NOT MAGNUM_WITH_DISTANCEFIELDCONVERTER" ON)
cmake_dependent_option(MAGNUM_WITH_TRADE "Build Trade library" ON "NOT MAGNUM_WITH_MESHTOOLS;NOT MAGNUM_WITH_PRIMITIVES;NOT MAGNUM_WITH_SCENETOOLS;NOT MAGNUM_WITH_IMAGECONVERTER;NOT MAGNUM_WITH_ANYIMAGEIMPORTER;NOT MAGNUM_WITH_ANYIMAGECONVERTER;NOT MAGNUM_WITH_ANYSCENEIMPORTER;NOT MAGNUM_WITH_OBJIMPORTER;NOT MAGNUM_WITH_TGAIMAGECONVERTER;NOT MAGNUM_WITH_TGAIMPORTER" ON)
cmake_dependent_option(MAGNUM_WITH_GL "Build GL library" ON "NOT MAGNUM_WITH_SHADERS;NOT MAGNUM_WITH_GL_INFO;NOT MAGNUM_WITH_ANDROIDAPPLICATION;NOT MAGNUM_WITH_WINDOWLESSIOSAPPLICATION;NOT MAGNUM_WITH_CGLCONTEXT;NOT MAGNUM_WITH_GLXAPPLICATION;NOT MAGNUM_WITH_GLXCONTEXT;NOT MAGNUM_WITH_XEGLAPPLICATION;NOT MAGNUM_WITH_WINDOWLESSWGLAPPLICATION;NOT MAGNUM_WITH_WGLCONTEXT;NOT MAGNUM_WITH_WINDOWLESSWINDOWSEGLAPPLICATION;NOT MAGNUM_WITH_DISTANCEFIELDCONVERTER" ON)
option(MAGNUM_WITH_PRIMITIVES "Build Primitives library" ON)
cmake_dependent_option(MAGNUM_TARGET_HEADLESS "Build command-line utilities for use on a headless machines" OFF "MAGNUM_WITH_GL" OFF)
cmake_dependent_option(MAGNUM_TARGET_GL "Build libraries with OpenGL interoperability" ON "MAGNUM_WITH_GL" OFF)
# EGL context and windowless EGL application, available everywhere
cmake_dependent_option(WITH_WINDOWLESSEGLAPPLICATION "Build WindowlessEglApplication library" OFF "NOT TARGET_GLES OR TARGET_DESKTOP_GLES OR NOT WITH_GL_INFO;NOT TARGET_HEADLESS" ON)
option(WITH_EGLCONTEXT "Build EglContext library" OFF)
cmake_dependent_option(MAGNUM_WITH_WINDOWLESSEGLAPPLICATION "Build WindowlessEglApplication library" OFF "NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES OR NOT MAGNUM_WITH_GL_INFO;NOT TARGET_HEADLESS" ON)
option(MAGNUM_WITH_EGLCONTEXT "Build EglContext library" OFF)
# Vulkan, everywhere except Emscripten
if(NOT CORRADE_TARGET_EMSCRIPTEN)
cmake_dependent_option(WITH_VK "Build Vk library" OFF "NOT WITH_VK_INFO" ON)
cmake_dependent_option(TARGET_VK "Build libraries with Vulkan interoperability" ON "WITH_VK" OFF)
cmake_dependent_option(MAGNUM_WITH_VK "Build Vk library" OFF "NOT MAGNUM_WITH_VK_INFO" ON)
cmake_dependent_option(MAGNUM_TARGET_VK "Build libraries with Vulkan interoperability" ON "MAGNUM_WITH_VK" OFF)
endif()
# Android-specific application libraries
if(CORRADE_TARGET_ANDROID)
option(WITH_ANDROIDAPPLICATION "Build AndroidApplication library" OFF)
option(MAGNUM_WITH_ANDROIDAPPLICATION "Build AndroidApplication library" OFF)
# Emscripten-specific application libraries
elseif(CORRADE_TARGET_EMSCRIPTEN)
option(WITH_EMSCRIPTENAPPLICATION "Build EmscriptenApplication library" OFF)
option(MAGNUM_WITH_EMSCRIPTENAPPLICATION "Build EmscriptenApplication library" OFF)
# iOS-specific application libraries
elseif(CORRADE_TARGET_IOS)
option(WITH_WINDOWLESSIOSAPPLICATION "Build WindowlessIosApplication library" OFF)
option(MAGNUM_WITH_WINDOWLESSIOSAPPLICATION "Build WindowlessIosApplication library" OFF)
# macOS-specific application libraries
elseif(CORRADE_TARGET_APPLE AND NOT TARGET_GLES)
cmake_dependent_option(WITH_WINDOWLESSCGLAPPLICATION "Build WindowlessCglApplication library" OFF "NOT WITH_GL_INFO;NOT WITH_FONTCONVERTER;NOT WITH_DISTANCEFIELDCONVERTER" ON)
option(WITH_CGLCONTEXT "Build CglContext library" OFF)
elseif(CORRADE_TARGET_APPLE AND NOT MAGNUM_TARGET_GLES)
cmake_dependent_option(MAGNUM_WITH_WINDOWLESSCGLAPPLICATION "Build WindowlessCglApplication library" OFF "NOT MAGNUM_WITH_GL_INFO;NOT MAGNUM_WITH_FONTCONVERTER;NOT MAGNUM_WITH_DISTANCEFIELDCONVERTER" ON)
option(MAGNUM_WITH_CGLCONTEXT "Build CglContext library" OFF)
# X11 + GLX/EGL-specific application libraries
elseif(CORRADE_TARGET_UNIX)
option(WITH_GLXAPPLICATION "Build GlxApplication library" OFF)
if(NOT TARGET_GLES OR TARGET_DESKTOP_GLES)
cmake_dependent_option(WITH_WINDOWLESSGLXAPPLICATION "Build WindowlessGlxApplication library" OFF "NOT WITH_GL_INFO;NOT WITH_FONTCONVERTER;NOT WITH_DISTANCEFIELDCONVERTER" ON)
option(WITH_GLXCONTEXT "Build GlxContext library" OFF)
option(MAGNUM_WITH_GLXAPPLICATION "Build GlxApplication library" OFF)
if(NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES)
cmake_dependent_option(MAGNUM_WITH_WINDOWLESSGLXAPPLICATION "Build WindowlessGlxApplication library" OFF "NOT MAGNUM_WITH_GL_INFO;NOT MAGNUM_WITH_FONTCONVERTER;NOT MAGNUM_WITH_DISTANCEFIELDCONVERTER" ON)
option(MAGNUM_WITH_GLXCONTEXT "Build GlxContext library" OFF)
endif()
option(WITH_XEGLAPPLICATION "Build XEglApplication library" OFF)
option(MAGNUM_WITH_XEGLAPPLICATION "Build XEglApplication library" OFF)
# Windows-specific application libraries
elseif(CORRADE_TARGET_WINDOWS)
if(NOT TARGET_GLES OR TARGET_DESKTOP_GLES)
cmake_dependent_option(WITH_WINDOWLESSWGLAPPLICATION "Build WindowlessWglApplication library" OFF "NOT WITH_GL_INFO;NOT WITH_FONTCONVERTER;NOT WITH_DISTANCEFIELDCONVERTER" ON)
option(WITH_WGLCONTEXT "Build WglContext library" OFF)
if(NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES)
cmake_dependent_option(MAGNUM_WITH_WINDOWLESSWGLAPPLICATION "Build WindowlessWglApplication library" OFF "NOT MAGNUM_WITH_GL_INFO;NOT MAGNUM_WITH_FONTCONVERTER;NOT MAGNUM_WITH_DISTANCEFIELDCONVERTER" ON)
option(MAGNUM_WITH_WGLCONTEXT "Build WglContext library" OFF)
else()
cmake_dependent_option(WITH_WINDOWLESSWINDOWSEGLAPPLICATION "Build WindowlessWindowsEglApplication library" OFF "NOT WITH_GL_INFO;NOT WITH_FONTCONVERTER;NOT WITH_DISTANCEFIELDCONVERTER" ON)
cmake_dependent_option(MAGNUM_WITH_WINDOWLESSWINDOWSEGLAPPLICATION "Build WindowlessWindowsEglApplication library" OFF "NOT MAGNUM_WITH_GL_INFO;NOT MAGNUM_WITH_FONTCONVERTER;NOT MAGNUM_WITH_DISTANCEFIELDCONVERTER" ON)
endif()
endif()
# Platform-independent (almost) application libraries
if(NOT CORRADE_TARGET_ANDROID)
option(WITH_SDL2APPLICATION "Build Sdl2Application library" OFF)
option(MAGNUM_WITH_SDL2APPLICATION "Build Sdl2Application library" OFF)
endif()
if(NOT CORRADE_TARGET_ANDROID AND NOT CORRADE_TARGET_IOS AND NOT CORRADE_TARGET_EMSCRIPTEN)
option(WITH_GLFWAPPLICATION "Build GlfwApplication library" OFF)
option(MAGNUM_WITH_GLFWAPPLICATION "Build GlfwApplication library" OFF)
endif()
option(BUILD_DEPRECATED "Include deprecated API in the build" ON)
if(BUILD_DEPRECATED)
set(MAGNUM_BUILD_DEPRECATED 1)
endif()
option(MAGNUM_BUILD_DEPRECATED "Include deprecated API in the build" ON)
# BUILD_MULTITHREADED got moved to Corrade itself. In case we're building with
# deprecated features enabled, print a warning in case it's set but Corrade
@ -199,7 +283,7 @@ endif()
set(MAGNUM_DEPLOY_PREFIX "."
CACHE STRING "Prefix where to put final application executables")
option(BUILD_STATIC "Build static libraries (default are shared)" OFF)
option(MAGNUM_BUILD_STATIC "Build static libraries (default are shared)" OFF)
# Disable PIC on Emscripten by default (but still allow it to be enabled
# explicitly if one so desires). Currently causes linker errors related to
# __memory_base etc.: https://github.com/emscripten-core/emscripten/issues/8761
@ -208,38 +292,183 @@ if(CORRADE_TARGET_EMSCRIPTEN)
else()
set(ON_EXCEPT_EMSCRIPTEN ON)
endif()
option(BUILD_STATIC_PIC "Build static libraries and plugins with position-independent code" ${ON_EXCEPT_EMSCRIPTEN})
cmake_dependent_option(BUILD_STATIC_UNIQUE_GLOBALS "Build static libraries with globals unique across shared libraries" ${ON_EXCEPT_EMSCRIPTEN} "BUILD_STATIC" OFF)
option(BUILD_PLUGINS_STATIC "Build static plugins (default are dynamic)" OFF)
option(BUILD_TESTS "Build unit tests" OFF)
cmake_dependent_option(BUILD_GL_TESTS "Build unit tests for OpenGL code" OFF "BUILD_TESTS;TARGET_GL" OFF)
cmake_dependent_option(BUILD_AL_TESTS "Build unit tests for OpenAL code" ON "BUILD_TESTS;WITH_AUDIO" OFF)
cmake_dependent_option(BUILD_VK_TESTS "Build unit tests for Vulkan code" OFF "BUILD_TESTS;TARGET_VK" OFF)
option(MAGNUM_BUILD_STATIC_PIC "Build static libraries and plugins with position-independent code" ${ON_EXCEPT_EMSCRIPTEN})
cmake_dependent_option(MAGNUM_BUILD_STATIC_UNIQUE_GLOBALS "Build static libraries with globals unique across shared libraries" ${ON_EXCEPT_EMSCRIPTEN} "MAGNUM_BUILD_STATIC" OFF)
option(MAGNUM_BUILD_PLUGINS_STATIC "Build static plugins (default are dynamic)" OFF)
option(MAGNUM_BUILD_TESTS "Build unit tests" OFF)
cmake_dependent_option(MAGNUM_BUILD_GL_TESTS "Build unit tests for OpenGL code" OFF "MAGNUM_BUILD_TESTS;MAGNUM_TARGET_GL" OFF)
cmake_dependent_option(MAGNUM_BUILD_AL_TESTS "Build unit tests for OpenAL code" ON "MAGNUM_BUILD_TESTS;MAGNUM_WITH_AUDIO" OFF)
cmake_dependent_option(MAGNUM_BUILD_VK_TESTS "Build unit tests for Vulkan code" OFF "MAGNUM_BUILD_TESTS;MAGNUM_TARGET_VK" OFF)
# OpenGLTester / VulkanTester libraries, built by default only if GL / VK tests
# are enabled
cmake_dependent_option(WITH_OPENGLTESTER "Build OpenGLTester library" OFF "NOT BUILD_GL_TESTS" ON)
cmake_dependent_option(WITH_VULKANTESTER "Build VulkanTester library" OFF "NOT BUILD_VK_TESTS" ON)
cmake_dependent_option(MAGNUM_WITH_OPENGLTESTER "Build OpenGLTester library" OFF "NOT MAGNUM_BUILD_GL_TESTS" ON)
cmake_dependent_option(MAGNUM_WITH_VULKANTESTER "Build VulkanTester library" OFF "NOT MAGNUM_BUILD_VK_TESTS" ON)
# Backwards compatibility for unprefixed CMake options. If the user isn't
# explicitly using prefixed options in the first run already, accept the
# unprefixed options, and remember this decision for subsequent runs
if(NOT DEFINED _MAGNUM_ACCEPT_DEPRECATED_UNPREFIXED_OPTIONS)
set(_MAGNUM_ACCEPT_DEPRECATED_UNPREFIXED_OPTIONS ON CACHE INTERNAL "")
endif()
# If the user wasn't explicitly using prefixed options in the first run and the
# MAGNUM_BUILD_DEPRECATED option is not currently disabled (which can get
# changed subsequently), accept the unprefixed options and print a warning if
# they're different from the prefixed ones.
if(_MAGNUM_ACCEPT_DEPRECATED_UNPREFIXED_OPTIONS AND MAGNUM_BUILD_DEPRECATED)
# The following variables need extra care -- mirroring what's done in
# cmake_dependent_option(), but only the cases that enable a dependency
# that is off by default, not cases that hide an option from the GUI when
# it's needed by something else or cases that disable and hide the option
# from the GUI on unsupported platforms. In other words, if the original
# user flag setup didn't make sense before but the option dependency fixed
# it, it'll be broken now, but if it made sense, it should keep working.
#
# Doing this before propagating the unprefixed options to avoid a
# false-positive warning when e.g. MAGNUM_BUILD_STATIC_PIC is implicitly ON
# but BUILD_STATIC_PIC not yet.
if(CORRADE_TARGET_IOS OR CORRADE_TARGET_ANDROID OR CORRADE_TARGET_EMSCRIPTEN OR CORRADE_TARGET_WINDOWS_RT)
if(NOT DEFINED TARGET_GLES)
set(TARGET_GLES ON)
endif()
endif()
if(TARGET_GLES)
if(NOT DEFINED TARGET_GLES2)
set(TARGET_GLES2 ON)
endif()
endif()
if(BUILD_STATIC)
if(NOT CORRADE_TARGET_EMSCRIPTEN AND NOT DEFINED BUILD_STATIC_PIC)
set(BUILD_STATIC_PIC ON)
endif()
if(NOT CORRADE_TARGET_EMSCRIPTEN AND NOT DEFINED BUILD_STATIC_UNIQUE_GLOBALS)
set(BUILD_STATIC_UNIQUE_GLOBALS ON)
endif()
endif()
if(BUILD_TESTS)
if(NOT DEFINED BUILD_AL_TESTS)
set(BUILD_AL_TESTS ON)
endif()
endif()
if(BUILD_GL_TESTS)
if(NOT DEFINED WITH_OPENGLTESTER)
set(WITH_OPENGLTESTER ON)
endif()
endif()
if(BUILD_VK_TESTS)
if(NOT DEFINED WITH_VULKANTESTER)
set(WITH_VULKANTESTER ON)
endif()
endif()
if(WITH_MAGNUMFONTCONVERTER)
if(NOT DEFINED WITH_TGAIMAGECONVERTER)
set(WITH_TGAIMAGECONVERTER ON)
endif()
endif()
if(WITH_MAGNUMFONT)
if(NOT DEFINED WITH_TGAIMPORTER)
set(WITH_TGAIMPORTER ON)
endif()
endif()
if(WITH_AL_INFO OR WITH_ANYAUDIOIMPORTER OR WITH_WAVAUDIOIMPORTER)
if(NOT DEFINED WITH_AUDIO)
set(WITH_AUDIO ON)
endif()
endif()
if(WITH_GL_INFO OR WITH_OPENGLTESTER OR WITH_DISTANCEFIELDCONVERTER)
if(CORRADE_TARGET_ANDROID OR CORRADE_TARGET_EMSCRIPTEN)
if(NOT DEFINED WITH_WINDOWLESSEGLAPPLICATION)
set(WITH_WINDOWLESSEGLAPPLICATION ON)
endif()
elseif(CORRADE_TARGET_IOS)
if(NOT DEFINED WITH_WINDOWLESSIOSAPPLICATION)
set(WITH_WINDOWLESSIOSAPPLICATION ON)
endif()
elseif(CORRADE_TARGET_APPLE AND NOT TARGET_GLES)
if(NOT DEFINED WITH_WINDOWLESSCGLAPPLICATION)
set(WITH_WINDOWLESSCGLAPPLICATION ON)
endif()
elseif(CORRADE_TARGET_UNIX)
if((NOT TARGET_GLES AND NOT TARGET_HEADLESS) OR TARGET_DESKTOP_GLES)
if(NOT DEFINED WITH_WINDOWLESSGLXAPPLICATION)
set(WITH_WINDOWLESSGLXAPPLICATION ON)
endif()
else()
if(NOT DEFINED WITH_WINDOWLESSEGLAPPLICATION)
set(WITH_WINDOWLESSEGLAPPLICATION ON)
endif()
endif()
elseif(CORRADE_TARGET_WINDOWS)
if(NOT TARGET_GLES OR TARGET_DESKTOP_GLES)
if(NOT DEFINED WITH_WINDOWLESSWGLAPPLICATION)
set(WITH_WINDOWLESSWGLAPPLICATION ON)
endif()
else()
if(NOT DEFINED WITH_WINDOWLESSWINDOWSEGLAPPLICATION)
set(WITH_WINDOWLESSWINDOWSEGLAPPLICATION ON)
endif()
endif()
endif()
endif()
if(WITH_VK_INFO OR WITH_VULKANTESTER)
if(NOT DEFINED WITH_VK)
set(WITH_VK ON)
endif()
endif()
if(WITH_VK)
if(NOT DEFINED TARGET_VK)
set(TARGET_VK ON)
endif()
endif()
set(_MAGNUM_WARN_DEPRECATED_UNPREFIXED_OPTION )
foreach(option ${_MAGNUM_DEPRECATED_UNPREFIXED_OPTIONS})
if(DEFINED ${option})
# CMake has no comparison of boolean values (EQUAL returns false if
# comparing ON and 1 or OFF and FALSE, STREQUAL also), so we have
# to do it this way. Also warn only on the first encountered
# variable so people can fix it, reconfigure and go to the next one
# that warns.
if((${option} AND NOT MAGNUM_${option}) OR
(NOT ${option} AND MAGNUM_${option}) AND NOT _MAGNUM_WARN_DEPRECATED_UNPREFIXED_OPTION)
set(_MAGNUM_WARN_DEPRECATED_UNPREFIXED_OPTION ${option})
endif()
set(MAGNUM_${option} ${${option}})
# If variables specified on the command line don't match any
# options, they're kept in cache but set as UNINITIALIZED, meaning
# they don't appear in cmake-gui or ccmake, so there's no way to
# fix the warning apart from hand-enditing the CMakeCache.txt or
# recreating the build dir. Update their cached type to be BOOL to
# make them appear.
set(${option} ${${option}} CACHE BOOL "Deprecated, use MAGNUM_${option} instead" FORCE)
endif()
endforeach()
if(_MAGNUM_WARN_DEPRECATED_UNPREFIXED_OPTION)
# CMake 3.5+ has deprecation warnings enabled by default (which makes
# sense), 3.4 not. Use a warning there instead.
# TODO: drop when 3.4 is not supported anymore
if(CMAKE_VERSION VERSION_LESS 3.5)
set(DEPRECATION_OR_WARNING WARNING)
else()
set(DEPRECATION_OR_WARNING DEPRECATION)
endif()
message(${DEPRECATION_OR_WARNING} "Unprefixed options such as ${_MAGNUM_WARN_DEPRECATED_UNPREFIXED_OPTION} are deprecated, use MAGNUM_${_MAGNUM_WARN_DEPRECATED_UNPREFIXED_OPTION} instead. Delete the unprefixed variable from CMake cache or set both to the same value to silence this warning.")
endif()
endif()
# Dynamic linking is meaningless on Emscripten and too inconvenient on Android
if(CORRADE_TARGET_EMSCRIPTEN OR CORRADE_TARGET_ANDROID)
set(BUILD_STATIC ON)
set(BUILD_PLUGINS_STATIC ON)
set(MAGNUM_BUILD_STATIC ON)
set(MAGNUM_BUILD_PLUGINS_STATIC ON)
# Dynamic plugins are not working on iOS or Windows RT at the moment
elseif(CORRADE_TARGET_IOS OR CORRADE_TARGET_WINDOWS_RT)
set(BUILD_PLUGINS_STATIC ON)
endif()
if(BUILD_STATIC)
set(MAGNUM_BUILD_STATIC 1)
if(BUILD_STATIC_UNIQUE_GLOBALS)
set(MAGNUM_BUILD_STATIC_UNIQUE_GLOBALS 1)
endif()
set(MAGNUM_BUILD_PLUGINS_STATIC ON)
endif()
# Check dependencies
if(WITH_GL)
if(NOT TARGET_GLES OR TARGET_DESKTOP_GLES)
if(MAGNUM_WITH_GL)
if(NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES)
# OpenGL library preference. Prefer to use GLVND, since that's the
# better approach nowadays, but allow the users to override it from
# outside in case it is broken for some reason (Nvidia drivers in
@ -248,50 +477,40 @@ if(WITH_GL)
set(OpenGL_GL_PREFERENCE GLVND)
endif()
find_package(OpenGL REQUIRED)
elseif(TARGET_GLES2)
elseif(MAGNUM_TARGET_GLES2)
find_package(OpenGLES2 REQUIRED)
else()
find_package(OpenGLES3 REQUIRED)
endif()
else()
if(TARGET_GL)
message(FATAL_ERROR "WITH_GL is OFF but TARGET_GL is enabled. Hmm.")
endif()
# Especially now with the backwards compatibility for unprefixed variables
# it's easiest to just force-disable all this
set(MAGNUM_TARGET_GL OFF)
# These are implicitly enabled for embedded platforms, disable them all for
# consistency
set(TARGET_GLES OFF)
set(TARGET_GLES2 OFF)
set(TARGET_DESKTOP_GLES OFF)
set(MAGNUM_TARGET_GLES OFF)
set(MAGNUM_TARGET_GLES2 OFF)
set(MAGNUM_TARGET_DESKTOP_GLES OFF)
endif()
# Configuration variables (saved later to configure.h)
if(TARGET_GL)
set(MAGNUM_TARGET_GL 1)
if(NOT MAGNUM_WITH_VK)
# Especially now with the backwards compatibility for unprefixed variables
# it's easiest to just force-disable this
set(MAGNUM_TARGET_VK OFF)
endif()
if(TARGET_GLES)
set(MAGNUM_TARGET_GLES 1)
if(TARGET_GLES2)
set(MAGNUM_TARGET_GLES2 1)
else()
# Dependent configuration variables
if(MAGNUM_TARGET_GLES)
if(NOT MAGNUM_TARGET_GLES2)
set(MAGNUM_TARGET_GLES3 1)
endif()
if(CORRADE_TARGET_EMSCRIPTEN)
set(TARGET_WEBGL 1)
set(MAGNUM_TARGET_WEBGL 1)
endif()
if(TARGET_DESKTOP_GLES)
set(MAGNUM_TARGET_DESKTOP_GLES 1)
endif()
endif()
if(TARGET_HEADLESS)
set(MAGNUM_TARGET_HEADLESS 1)
endif()
if(TARGET_VK)
set(MAGNUM_TARGET_VK 1)
endif()
# Testing setup
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
find_package(Corrade REQUIRED TestSuite)
if(CORRADE_TARGET_IOS)
set(CORRADE_TESTSUITE_BUNDLE_IDENTIFIER_PREFIX "cz.mosra.magnum")
@ -306,39 +525,39 @@ if(BUILD_TESTS)
endif()
endif()
if(WITH_OPENGLTESTER)
if(MAGNUM_WITH_OPENGLTESTER)
if(MAGNUM_TARGET_HEADLESS OR CORRADE_TARGET_EMSCRIPTEN OR CORRADE_TARGET_ANDROID)
set(WITH_WINDOWLESSEGLAPPLICATION ON)
set(MAGNUM_WITH_WINDOWLESSEGLAPPLICATION ON)
set(OPENGLTESTER_APPLICATION MagnumWindowlessEglApplication)
elseif(CORRADE_TARGET_IOS)
set(WITH_WINDOWLESSIOSAPPLICATION ON)
set(MAGNUM_WITH_WINDOWLESSIOSAPPLICATION ON)
set(OPENGLTESTER_APPLICATION MagnumWindowlessIosApplication)
elseif(CORRADE_TARGET_APPLE AND NOT MAGNUM_TARGET_GLES)
set(WITH_WINDOWLESSCGLAPPLICATION ON)
set(MAGNUM_WITH_WINDOWLESSCGLAPPLICATION ON)
set(OPENGLTESTER_APPLICATION MagnumWindowlessCglApplication)
elseif(CORRADE_TARGET_UNIX)
if(MAGNUM_TARGET_GLES AND NOT MAGNUM_TARGET_DESKTOP_GLES)
set(WITH_WINDOWLESSEGLAPPLICATION ON)
set(MAGNUM_WITH_WINDOWLESSEGLAPPLICATION ON)
set(OPENGLTESTER_APPLICATION MagnumWindowlessEglApplication)
else()
set(WITH_WINDOWLESSGLXAPPLICATION ON)
set(MAGNUM_WITH_WINDOWLESSGLXAPPLICATION ON)
set(OPENGLTESTER_APPLICATION MagnumWindowlessGlxApplication)
endif()
elseif(CORRADE_TARGET_WINDOWS)
if(NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES)
set(WITH_WINDOWLESSWGLAPPLICATION ON)
set(MAGNUM_WITH_WINDOWLESSWGLAPPLICATION ON)
set(OPENGLTESTER_APPLICATION MagnumWindowlessWglApplication)
else()
set(WITH_WINDOWLESSWINDOWSEGLAPPLICATION ON)
set(MAGNUM_WITH_WINDOWLESSWINDOWSEGLAPPLICATION ON)
set(OPENGLTESTER_APPLICATION MagnumWindowlessWindowsEglApplication)
endif()
else()
# Assuming this gets hit only if BUILD_GL_TESTS are enabled
message(FATAL_ERROR "Cannot run tests for OpenGL code on this platform. Set BUILD_GL_TESTS to OFF to skip building them.")
# Assuming this gets hit only if MAGNUM_BUILD_GL_TESTS are enabled
message(FATAL_ERROR "Cannot run tests for OpenGL code on this platform. Set MAGNUM_BUILD_GL_TESTS to OFF to skip building them.")
endif()
endif()
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
set(SHARED_OR_STATIC SHARED)
else()
set(SHARED_OR_STATIC STATIC)
@ -503,6 +722,6 @@ add_subdirectory(modules)
add_subdirectory(src)
# Build snippets as part of testing
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(doc/snippets)
endif()

370
doc/building.dox

@ -128,7 +128,8 @@ vcpkg install magnum
Not all features are installed by default; only those that are implicitly
enabled in @ref building-features together with @ref Platform::Sdl2Application "Sdl2Application".
To opt-in or opt-out of additional features, you can use the following syntax;
feature names are simply names of CMake `WITH_*` options but lowercase, e.g.:
feature names are simply names of CMake `MAGNUM_WITH_*` options but lowercase,
e.g.:
@code{.bat}
vcpkg install magnum[glfwapplication,tgaimporter]
@ -356,7 +357,7 @@ applications) can be built and installed using these four commands:
mkdir build && cd build
cmake .. \
-DCMAKE_INSTALL_PREFIX=/usr \
-DWITH_SDL2APPLICATION=ON
-DMAGNUM_WITH_SDL2APPLICATION=ON
make
make install # sudo may be needed
@endcode
@ -451,56 +452,57 @@ By default the engine is built for desktop OpenGL. Using the `TARGET_*` CMake
options you can target other platforms. Note that some features are
available for desktop OpenGL only, see @ref requires-gl.
- `TARGET_GL` --- Build libraries with OpenGL interoperability enabled.
Enabled by default when `WITH_GL` is enabled. Disabling this will cause
other libraries to not depend on the @ref GL library, but doesn't affect
the @ref GL library itself.
- `TARGET_GLES` --- Target OpenGL ES. Available only when `WITH_GL` is
enabled.
- `TARGET_GLES2` --- Target OpenGL ES 2.0 instead of 3.0 and later. Available
only when `WITH_GL` is set. Currently enabled by default when `TARGET_GLES`
is set.
- `TARGET_DESKTOP_GLES` --- Target OpenGL ES on desktop, i.e. use OpenGL ES
emulation in desktop OpenGL drivers. Available on Linux and Windows, though
might not be supported by all drivers. Available only when `WITH_GL` is
enabled.
- `TARGET_HEADLESS` --- Build command-line utilities for use on a headless
machine. Basically it means that EGL with no display attachment is being
used everywhere instead of platform-specific toolkits like CGL, GLX or WGL.
Supported mainly on OpenGL ES drivers. Available only when `WITH_GL` is
enabled.
- `TARGET_VK` --- Build libraries with Vulkan interoperability enabled.
Enabled by default when `WITH_VK` is enabled. Disabling this will cause
libraries to not depend on the @ref Vk library, but doesn't affect the
@ref Vk library itself.
- `MAGNUM_TARGET_GL` --- Build libraries with OpenGL interoperability
enabled. Enabled by default when `MAGNUM_WITH_GL` is enabled. Disabling
this will cause other libraries to not depend on the @ref GL library, but
doesn't affect the @ref GL library itself.
- `MAGNUM_TARGET_GLES` --- Target OpenGL ES. Available only when
`MAGNUM_WITH_GL` is enabled.
- `MAGNUM_TARGET_GLES2` --- Target OpenGL ES 2.0 instead of 3.0 and later.
Available only when `MAGNUM_WITH_GL` is enabled. Currently enabled by
default when `MAGNUM_TARGET_GLES` is set.
- `MAGNUM_TARGET_DESKTOP_GLES` --- Target OpenGL ES on desktop, i.e. use
OpenGL ES emulation in desktop OpenGL drivers. Available on Linux and
Windows, though might not be supported by all drivers. Available only when
`MAGNUM_WITH_GL` is enabled.
- `MAGNUM_TARGET_HEADLESS` --- Build command-line utilities for use on a
headless machine. Basically it means that EGL with no display attachment is
being used everywhere instead of platform-specific toolkits like CGL, GLX
or WGL. Supported mainly on OpenGL ES drivers. Available only when
`MAGNUM_WITH_GL` is enabled.
- `MAGNUM_TARGET_VK` --- Build libraries with Vulkan interoperability
enabled. Enabled by default when `MAGNUM_WITH_VK` is enabled. Disabling
this will cause libraries to not depend on the @ref Vk library, but doesn't
affect the @ref Vk library itself.
By default the engine is built with nearly everything except the @ref Audio
and @ref Vk libraries, plugins, command-line utilities and application
libraries (see below). Using the following `WITH_*` CMake options you can
specify which parts will be built and which not:
libraries (see below). Using the following `MAGNUM_WITH_*` CMake options you
can specify which parts will be built and which not:
- `WITH_AUDIO` --- Build the @ref Audio library. Depends on
- `MAGNUM_WITH_AUDIO` --- Build the @ref Audio library. Depends on
[OpenAL](https://www.openal.org/), not enabled by default.
- `WITH_DEBUGTOOLS` --- Build the @ref DebugTools library.
- `WITH_GL` --- Build the @ref GL library. Enabled automatically if
`WITH_SHADERS` is enabled.
- `WITH_MESHTOOLS` --- Build the @ref MeshTools library. Enables also
building of the Trade library.
- `WITH_PRIMITIVES` --- Build the @ref Primitives library. Enables also
building of the Trade library.
- `WITH_SCENEGRAPH` --- Build the @ref SceneGraph library
- `WITH_SCENETOOLS` --- Build the @ref SceneTools library. Enables also
building of the Trade library.
- `WITH_SHADERS` --- Build the @ref Shaders library. Enables also building of
the GL library.
- `WITH_SHADERTOOLS` --- Build the @ref ShaderTools library
- `WITH_TEXT` --- Build the @ref Text library. Enables also building of
the TextureTools library.
- `WITH_TEXTURETOOLS` --- Build the @ref TextureTools library. Enabled
automatically if `WITH_TEXT` or `WITH_DISTANCEFIELDCONVERTER` is enabled.
- `WITH_TRADE` --- Build the @ref Trade library.
- `WITH_VK` --- Build the @ref Vk library. Depends on Vulkan, not enabled by
default.
- `MAGNUM_WITH_DEBUGTOOLS` --- Build the @ref DebugTools library.
- `MAGNUM_WITH_GL` --- Build the @ref GL library. Enabled automatically if
`MAGNUM_WITH_SHADERS` is enabled.
- `MAGNUM_WITH_MESHTOOLS` --- Build the @ref MeshTools library. Enables also
building of the @ref Trade library.
- `MAGNUM_WITH_PRIMITIVES` --- Build the @ref Primitives library. Enables
also building of the @ref Trade library.
- `MAGNUM_WITH_SCENEGRAPH` --- Build the @ref SceneGraph library
- `MAGNUM_WITH_SCENETOOLS` --- Build the @ref SceneTools library. Enables
also building of the @ref Trade library.
- `MAGNUM_WITH_SHADERS` --- Build the @ref Shaders library. Enables also
building of the @ref GL library.
- `MAGNUM_WITH_SHADERTOOLS` --- Build the @ref ShaderTools library
- `MAGNUM_WITH_TEXT` --- Build the @ref Text library. Enables also building
of the @ref TextureTools library.
- `MAGNUM_WITH_TEXTURETOOLS` --- Build the @ref TextureTools library. Enabled
automatically if `MAGNUM_WITH_TEXT` or `MAGNUM_WITH_DISTANCEFIELDCONVERTER`
is enabled.
- `MAGNUM_WITH_TRADE` --- Build the @ref Trade library.
- `MAGNUM_WITH_VK` --- Build the @ref Vk library. Depends on Vulkan, not
enabled by default.
None of the @ref Platform "application libraries" is built by default (and *you
need at least one*, unless you are handling platform integration yourself ---
@ -510,161 +512,173 @@ your platform best. The @ref Platform::Sdl2Application "Sdl2Application"
library is a good default choice, as it is the most portable --- and if you're
going to build any of the @ref example-index "examples", you'll need it.
- `WITH_ANDROIDAPPLICATION` --- Build the
- `MAGNUM_WITH_ANDROIDAPPLICATION` --- Build the
@ref Platform::AndroidApplication "AndroidApplication" library. Available
only on @ref CORRADE_TARGET_ANDROID "Android". Enables also building of the
GL library.
- `WITH_EMSCRIPTENAPPLICATION` --- Build the
- `MAGNUM_WITH_EMSCRIPTENAPPLICATION` --- Build the
@ref Platform::EmscriptenApplication "EmscriptenApplication" library.
Available only on @ref CORRADE_TARGET_EMSCRIPTEN "Emscripten".
- `WITH_GLFWAPPLICATION` --- Build the
- `MAGNUM_WITH_GLFWAPPLICATION` --- Build the
@ref Platform::GlfwApplication "GlfwApplication" library. Depends on
[GLFW](http://glfw.org).
- `WITH_GLXAPPLICATION` --- Build the
- `MAGNUM_WITH_GLXAPPLICATION` --- Build the
@ref Platform::GlxApplication "GlxApplication" library. Depends on **X11**.
Requires `TARGET_GL` to be enabled.
- `WITH_SDL2APPLICATION` --- Build the
Requires `MAGNUM_TARGET_GL` to be enabled.
- `MAGNUM_WITH_SDL2APPLICATION` --- Build the
@ref Platform::Sdl2Application "Sdl2Application" library. Depends on
[SDL2](http://www.libsdl.org).
- `WITH_XEGLAPPLICATION` --- Build the
- `MAGNUM_WITH_XEGLAPPLICATION` --- Build the
@ref Platform::XEglApplication "XEglApplication" library. Enables also
building of the GL library.
- `WITH_WINDOWLESSCGLAPPLICATION` --- Build the
building of the @ref GL library.
- `MAGNUM_WITH_WINDOWLESSCGLAPPLICATION` --- Build the
@ref Platform::WindowlessCglApplication "WindowlessCglApplication" library.
Requires `TARGET_GL` to be enabled.
- `WITH_WINDOWLESSEGLAPPLICATION` --- Build the
Requires `MAGNUM_TARGET_GL` to be enabled.
- `MAGNUM_WITH_WINDOWLESSEGLAPPLICATION` --- Build the
@ref Platform::WindowlessEglApplication "WindowlessEglApplication" library.
Requires `TARGET_GL` to be enabled.
- `WITH_WINDOWLESSGLXAPPLICATION` --- Build the
Requires `MAGNUM_TARGET_GL` to be enabled.
- `MAGNUM_WITH_WINDOWLESSGLXAPPLICATION` --- Build the
@ref Platform::WindowlessGlxApplication "WindowlessGlxApplication" library.
Requires `TARGET_GL` to be enabled.
- `WITH_WINDOWLESSIOSAPPLICATION` --- Build the
Requires `MAGNUM_TARGET_GL` to be enabled.
- `MAGNUM_WITH_WINDOWLESSIOSAPPLICATION` --- Build the
@ref Platform::WindowlessIosApplication "WindowlessIosApplication" library.
Requires `TARGET_GL` to be enabled.
- `WITH_WINDOWLESSWGLAPPLICATION` --- Build the
Requires `MAGNUM_TARGET_GL` to be enabled.
- `MAGNUM_WITH_WINDOWLESSWGLAPPLICATION` --- Build the
@ref Platform::WindowlessWglApplication "WindowlessWglApplication" library.
Requires `TARGET_GL` to be enabled.
- `WITH_WINDOWLESSWINDOWSEGLAPPLICATION` --- Build the
Requires `MAGNUM_TARGET_GL` to be enabled.
- `MAGNUM_WITH_WINDOWLESSWINDOWSEGLAPPLICATION` --- Build the
@ref Platform::WindowlessWindowsEglApplication "WindowlessWindowsEglApplication"
library. Requires `TARGET_GL` to be enabled.
library. Requires `MAGNUM_TARGET_GL` to be enabled.
None of the context libraries is built by default. Similarly to the application
libraries, they are always built as static. You need them only if you chose to
not use any of the application libraries above (see @ref platform-custom for
more information):
- `WITH_CGLCONTEXT` --- Build the CGL context handling library. Requires
`TARGET_GL` to be enabled.
- `WITH_EGLCONTEXT` --- Build the EGL context handling library. Requires
`TARGET_GL` to be enabled.
- `WITH_GLXCONTEXT` --- Build the GLX context handling library. Requires
`TARGET_GL` to be enabled.
- `WITH_WGLCONTEXT` --- Build the WGL context handling library. Requires
`TARGET_GL` to be enabled.
- `MAGNUM_WITH_CGLCONTEXT` --- Build the CGL context handling library.
Requires `MAGNUM_TARGET_GL` to be enabled.
- `MAGNUM_WITH_EGLCONTEXT` --- Build the EGL context handling library.
Requires `MAGNUM_TARGET_GL` to be enabled.
- `MAGNUM_WITH_GLXCONTEXT` --- Build the GLX context handling library.
Requires `MAGNUM_TARGET_GL` to be enabled.
- `MAGNUM_WITH_WGLCONTEXT` --- Build the WGL context handling library.
Requires `MAGNUM_TARGET_GL` to be enabled.
There are also extensions to @ref Corrade::TestSuite::Tester for testing GPU
code:
- `WITH_OPENGLTESTER` --- The @ref GL::OpenGLTester class. Requires
`TARGET_GL` to be enabled; enables building of one of the windowless
- `MAGNUM_WITH_OPENGLTESTER` --- The @ref GL::OpenGLTester class. Requires
`MAGNUM_TARGET_GL` to be enabled; enables building of one of the windowless
application libraries based on the target platform.
- `WITH_VULKANTESTER` --- The @ref Vk::VulkanTester class. Requires
`TARGET_VK` to be enabled.
- `MAGNUM_WITH_VULKANTESTER` --- The @ref Vk::VulkanTester class. Requires
`MAGNUM_TARGET_VK` to be enabled.
Magnum also contains a set of dependency-less plugins for importing essential
file formats. Additional plugins are provided in a separate plugin repository,
see @ref building-plugins for more information. None of the plugins is built by
default.
- `WITH_ANYAUDIOIMPORTER` --- Build the @ref Audio::AnyImporter "AnyAudioImporter"
plugin. Enables also building of the @ref Audio library.
- `WITH_ANYIMAGECONVERTER` --- Build the
- `MAGNUM_WITH_ANYAUDIOIMPORTER` --- Build the
@ref Audio::AnyImporter "AnyAudioImporter" plugin. Enables also building of
the @ref Audio library.
- `MAGNUM_WITH_ANYIMAGECONVERTER` --- Build the
@ref Trade::AnyImageConverter "AnyImageConverter" plugin. Enables also
building of the @ref Trade library.
- `WITH_ANYIMAGEIMPORTER` --- Build the @ref Trade::AnyImageImporter "AnyImageImporter"
plugin. Enables also building of the @ref Trade library.
- `WITH_ANYSCENECONVERTER` --- Build the @ref Trade::AnySceneConverter "AnySceneConverter"
plugin. Enables also building of the @ref Trade library.
- `WITH_ANYSCENEIMPORTER` --- Build the @ref Trade::AnySceneImporter "AnySceneImporter"
plugin. Enables also building of the @ref Trade library.
- `WITH_ANYSHADERCONVERTER` --- Build the @ref ShaderTools::AnyConverter "AnyShaderConverter"
plugin. Enables also building of the @ref ShaderTools library.
- `WITH_MAGNUMFONT` --- Build the @ref Text::MagnumFont "MagnumFont" plugin.
Enables also building of the @ref Text library and the
@ref Trade::TgaImporter "TgaImporter" plugin. Requires `TARGET_GL` to be
enabled.
- `WITH_MAGNUMFONTCONVERTER` --- Build the
- `MAGNUM_WITH_ANYIMAGEIMPORTER` --- Build the
@ref Trade::AnyImageImporter "AnyImageImporter" plugin. Enables also
building of the @ref Trade library.
- `MAGNUM_WITH_ANYSCENECONVERTER` --- Build the
@ref Trade::AnySceneConverter "AnySceneConverter" plugin. Enables also
building of the @ref Trade library.
- `MAGNUM_WITH_ANYSCENEIMPORTER` --- Build the
@ref Trade::AnySceneImporter "AnySceneImporter" plugin. Enables also
building of the @ref Trade library.
- `MAGNUM_WITH_ANYSHADERCONVERTER` --- Build the
@ref ShaderTools::AnyConverter "AnyShaderConverter" plugin. Enables also
building of the @ref ShaderTools library.
- `MAGNUM_WITH_MAGNUMFONT` --- Build the @ref Text::MagnumFont "MagnumFont"
plugin. Enables also building of the @ref Text library and the
@ref Trade::TgaImporter "TgaImporter" plugin. Requires `MAGNUM_TARGET_GL`
to be enabled.
- `MAGNUM_WITH_MAGNUMFONTCONVERTER` --- Build the
@ref Text::MagnumFontConverter "MagnumFontConverter" plugin. Enables also
building of the @ref Text library and the
@ref Trade::TgaImageConverter "TgaImageConverter" plugin.
- `WITH_OBJIMPORTER` --- Build the @ref Trade::ObjImporter "ObjImporter"
plugin. Enables also building of the @ref Trade library.
- `WITH_TGAIMPORTER` --- Build the @ref Trade::TgaImporter "TgaImporter"
plugin. Enables also building of the @ref Trade library.
- `WITH_TGAIMAGECONVERTER` --- Build the
- `MAGNUM_WITH_OBJIMPORTER` --- Build the
@ref Trade::ObjImporter "ObjImporter" plugin. Enables also building of the
@ref Trade library.
- `MAGNUM_WITH_TGAIMPORTER` --- Build the
@ref Trade::TgaImporter "TgaImporter" plugin. Enables also building of the
@ref Trade library.
- `MAGNUM_WITH_TGAIMAGECONVERTER` --- Build the
@ref Trade::TgaImageConverter "TgaImageConverter" plugin. Enables also
building of the @ref Trade library.
- `WITH_WAVAUDIOIMPORTER` --- Build the @ref Audio::WavImporter "WavAudioImporter"
plugin. Enables also building of the @ref Audio library.
- `MAGNUM_WITH_WAVAUDIOIMPORTER` --- Build the
@ref Audio::WavImporter "WavAudioImporter" plugin. Enables also building of
the @ref Audio library.
There are also a few command-line utilities, also all disabled by default:
- `WITH_GL_INFO` --- Build the @ref magnum-gl-info "magnum-gl-info"
- `MAGNUM_WITH_GL_INFO` --- Build the @ref magnum-gl-info "magnum-gl-info"
executable, which provides information about the engine OpenGL
capabilities. Requires `TARGET_GL` to be enabled; enables also building of
the @ref GL library and one of the windowless application libraries based
on the target platform.
- `WITH_VK_INFO` --- Build the @ref magnum-vk-info "magnum-vk-info"
capabilities. Requires `MAGNUM_TARGET_GL` to be enabled; enables also
building of the @ref GL library and one of the windowless application
libraries based on the target platform.
- `MAGNUM_WITH_VK_INFO` --- Build the @ref magnum-vk-info "magnum-vk-info"
executable, which provides information about the engine Vulkan
capabilities. Requires `TARGET_VK` to be enabled; enables also building of
the @ref Vk library.
- `WITH_AL_INFO` --- Build the @ref magnum-al-info "magnum-al-info"
capabilities. Requires `MAGNUM_TARGET_VK` to be enabled; enables also
building of the @ref Vk library.
- `MAGNUM_WITH_AL_INFO` --- Build the @ref magnum-al-info "magnum-al-info"
executable, which provides information about the engine OpenAL
capabilities. Enables also building of the @ref Audio library.
- `WITH_DISTANCEFIELDCONVERTER` --- Build the
- `MAGNUM_WITH_DISTANCEFIELDCONVERTER` --- Build the
@ref magnum-distancefieldconverter "magnum-distancefieldconverter"
executable for converting black&white images to distance field textures.
Available only on desktop GL. Requires `TARGET_GL` to be enabled; enables
also building of the @ref TextureTools and @ref GL libraries and one of the
windowless application libraries based on the target platform.
- `WITH_FONTCONVERTER` --- Build the @ref magnum-fontconverter "magnum-fontconverter"
executable for converting fonts of different formats. Available only on
desktop GL. Requires `TARGET_GL` to be enabled; enables also building of
the @ref Text and @ref GL libraries and one of the windowless application
libraries based on the target platform.
- `WITH_IMAGECONVERTER` --- Build the @ref magnum-imageconverter "magnum-imageconverter"
executable for converting images of different formats. Enables also
building of the @ref Trade library.
- `WITH_SCENECONVERTER` --- Build the @ref magnum-sceneconverter "magnum-sceneconverter"
executable for converting scenes of different formats. Enables also
building of the @ref MeshTools and @ref SceneTools library.
- `WITH_SHADERCONVERTER` --- Build the @ref magnum-shaderconverter "magnum-shaderconverter"
executable for converting scenes of different formats. Enables also
building of the @ref ShaderTools library.
Available only on desktop GL. Requires `MAGNUM_TARGET_GL` to be enabled;
enables also building of the @ref TextureTools and @ref GL libraries and
one of the windowless application libraries based on the target platform.
- `MAGNUM_WITH_FONTCONVERTER` --- Build the
@ref magnum-fontconverter "magnum-fontconverter" executable for converting
fonts of different formats. Available only on desktop GL. Requires
`MAGNUM_TARGET_GL` to be enabled; enables also building of the @ref Text
and @ref GL libraries and one of the windowless application libraries based
on the target platform.
- `MAGNUM_WITH_IMAGECONVERTER` --- Build the
@ref magnum-imageconverter "magnum-imageconverter" executable for
converting images of different formats. Enables also building of the
@ref Trade library.
- `MAGNUM_WITH_SCENECONVERTER` --- Build the
@ref magnum-sceneconverter "magnum-sceneconverter" executable for
converting scenes of different formats. Enables also building of the
@ref MeshTools and @ref SceneTools library.
- `MAGNUM_WITH_SHADERCONVERTER` --- Build the
@ref magnum-shaderconverter "magnum-shaderconverter" executable for
converting scenes of different formats. Enables also building of the
@ref ShaderTools library.
Options controlling the build:
- `BUILD_STATIC` --- Build all libraries as static. Default is shared, except
on platforms such as @ref CORRADE_TARGET_ANDROID "Android" or
- `MAGNUM_BUILD_STATIC` --- Build all libraries as static. Default is shared,
except on platforms such as @ref CORRADE_TARGET_ANDROID "Android" or
@ref CORRADE_TARGET_EMSCRIPTEN "Emscripten" that don't support dynamic
linking.
- `BUILD_STATIC_PIC` --- Build static libraries with position-independent
code. Enabled by default when building static libraries, disable if you
don't need this feature. On @ref CORRADE_TARGET_EMSCRIPTEN "Emscripten"
this option is always off.
- `BUILD_STATIC_UNIQUE_GLOBALS` --- Build static libraries in a way that
keeps their globals unique even across different shared libraries. Enabled
by default for static builds. May introduce additional overhead on some
platforms, disable if you will only link static libraries to one final
- `MAGNUM_BUILD_STATIC_PIC` --- Build static libraries with
position-independent code. Enabled by default when building static
libraries, disable if you don't need this feature. On
@ref CORRADE_TARGET_EMSCRIPTEN "Emscripten" this option is always off.
- `MAGNUM_BUILD_STATIC_UNIQUE_GLOBALS` --- Build static libraries in a way
that keeps their globals unique even across different shared libraries.
Enabled by default for static builds. May introduce additional overhead on
some platforms, disable if you will only link static libraries to one final
executable and won't use any dynamic plugins.
- `BUILD_PLUGINS_STATIC` --- Build plugins as static. By default, plugins are
built as dynamic. Independent of the `BUILD_STATIC` option to allow having
static libraries with dynamic plugins and vice versa. To some extent it's
also possible to have only a subset of plugins built as static --- set
`MAGNUM_<PLUGIN>_BUILD_STATIC` for particular plugins to `ON` or `OFF` to
override this option.
- `BUILD_DEPRECATED` --- Include deprecated APIs in the build. Enabled by
default to preserve backwards compatibility, disabling it forces you to
- `MAGNUM_BUILD_PLUGINS_STATIC` --- Build plugins as static. By default,
plugins are built as dynamic. Independent of the `MAGNUM_BUILD_STATIC`
option to allow having static libraries with dynamic plugins and vice
versa. To some extent it's also possible to have only a subset of plugins
built as static --- set `MAGNUM_<PLUGIN>_BUILD_STATIC` for particular
plugins to `ON` or `OFF` to override this option.
- `MAGNUM_BUILD_DEPRECATED` --- Include deprecated APIs in the build. Enabled
by default to preserve backwards compatibility, disabling it forces you to
update your code whenever there's a breaking API change. It's however
recommended to have this option disabled when deploying a final application
as it can result in smaller binaries.
@ -714,7 +728,7 @@ installed files. The following variables are supported:
path is used, it's relative to `CMAKE_INSTALL_PREFIX`.
The following variables are deprecated and provided only for backwards
compatibility if `BUILD_DEPRECATED` isn't disabled.
compatibility if `MAGNUM_BUILD_DEPRECATED` isn't disabled.
- `MAGNUM_INCLUDE_INSTALL_PREFIX` --- Overrides location where
platform-independent include files, CMake scripts and other files are
@ -743,7 +757,7 @@ command-line option.
@subsection building-tests Building and running tests
If you want to build also the tests (which are not built by default), enable
`BUILD_TESTS` in CMake. The tests use Corrade's
`MAGNUM_BUILD_TESTS` in CMake. The tests use Corrade's
@ref Corrade::TestSuite "TestSuite" framework and can be run either manually
(the binaries are located in `Test/` subdirectories in the build directory) or
using
@ -759,9 +773,9 @@ The @ref Audio library has tests which require OpenAL to be able to create a
context. That is the case on most platforms, so they are enabled by default.
In case it's not possible to have OpenAL context (such as when running
@ref CORRADE_TARGET_EMSCRIPTEN "Emscripten" tests under Node.js), you can
disable building of them with `BUILD_AL_TESTS`. The tests are suffixed with
`ALTest` so they can be also selectively included/excluded when running CTest,
e.g.:
disable building of them with `MAGNUM_BUILD_AL_TESTS`. The tests are suffixed
with `ALTest` so they can be also selectively included/excluded when running
CTest, e.g.:
@code{.sh}
ctest -E ALTest # run everything except tests requiring OpenAL context
@ -771,16 +785,16 @@ Platforms which have windowless GL context creation implemented (currently all
platforms except @ref CORRADE_TARGET_EMSCRIPTEN "Emscripten",
@ref CORRADE_TARGET_WINDOWS_RT "Windows RT" and
@ref CORRADE_TARGET_ANDROID "Android") can build also tests for OpenGL
functionality. You can enable them with `BUILD_GL_TESTS`. All GL tests are
suffixed with `GLTest` so they can be also selectively included/excluded when
running CTest, e.g.:
functionality. You can enable them with `MAGNUM_BUILD_GL_TESTS`. All GL tests
are suffixed with `GLTest` so they can be also selectively included/excluded
when running CTest, e.g.:
@code{.sh}
ctest -R GLTest # run only tests requiring OpenGL context
@endcode
Tests requiring Vulkan to work are also disabled by default, enable them with
`BUILD_VK_TESTS`.
`MAGNUM_BUILD_VK_TESTS`.
@section building-doc Building documentation
@ -805,16 +819,16 @@ solution to build it. Alternatively, you can get an up-to-date version from any
browser distribution --- both Firefox and all Chromium-based browsers ship with
it. Put the `libGLESv2`/`libEGL` libraries to a location where CMake can find
them or set `CMAKE_PREFIX_PATH` accordingly. ANGLE supports only OpenGL ES,
thus you need to enable `TARGET_GLES`. The engine is built for OpenGL ES 2.0 by
default, switch to 3.0 by disabling `TARGET_GLES2`.
thus you need to enable `MAGNUM_TARGET_GLES`. The engine is built for OpenGL ES
2.0 by default, switch to 3.0 by disabling `MAGNUM_TARGET_GLES2`.
@code{.bat}
mkdir build-angle && cd build-angle
cmake .. ^
-DCMAKE_PREFIX_PATH=<path-to-ANGLE-installation> ^
-DTARGET_GLES=ON ^
-DTARGET_GLES2=OFF ^
-DWITH_SDL2APPLICATION=ON
-DMAGNUM_TARGET_GLES=ON ^
-DMAGNUM_TARGET_GLES2=OFF ^
-DMAGNUM_WITH_SDL2APPLICATION=ON
cmake --build .
@endcode
@ -874,8 +888,8 @@ cmake .. ^
-DCMAKE_SYSTEM_NAME=WindowsStore ^
-DCMAKE_SYSTEM_VERSION=10 ^
-DCMAKE_INSTALL_PREFIX="C:/Sys-winrt" ^
-DBUILD_STATIC=ON ^
-DWITH_SDL2APPLICATION=ON ^
-DMAGNUM_BUILD_STATIC=ON ^
-DMAGNUM_WITH_SDL2APPLICATION=ON ^
-G "Visual Studio 14 2015" ..
cmake --build .
@endcode
@ -958,7 +972,7 @@ WebAssembly build. Don't forget to adapt `EMSCRIPTEN_PREFIX` variable in
`generic/Emscripten*.cmake` to path where Emscripten is installed; you can also
pass it explicitly on command-line using `-DEMSCRIPTEN_PREFIX`. Default is
`/usr/lib/emscripten`. Emscripten supports dynamic libraries only to simplify
porting and they are generally slower, thus `BUILD_STATIC` is implicitly
porting and they are generally slower, thus `MAGNUM_BUILD_STATIC` is implicitly
enabled.
Then create build directory and run `cmake` and the build command in it. You
@ -967,7 +981,7 @@ can omit specifying `CORRADE_RC_EXECUTABLE` if
through `PATH`.
WebGL 1.0 (GLES 2.0 equivalent) is enabled by default, switch to 2.0 (GLES 3.0
equivalent) by disabling `TARGET_GLES2`. If you enable one of the
equivalent) by disabling `MAGNUM_TARGET_GLES2`. If you enable one of the
@ref magnum-gl-info or @ref magnum-al-info utilities, you can override their
install location by setting `MAGNUM_DEPLOY_PREFIX` --- putting them for example
in your webserver root.
@ -981,7 +995,7 @@ cmake .. \
-DCMAKE_INSTALL_PREFIX=/usr/lib/emscripten/system \
-DCORRADE_RC_EXECUTABLE=/path/to/corrade-rc \
-DMAGNUM_DEPLOY_PREFIX=/srv/http/magnum \
-DWITH_SDL2APPLICATION=ON
-DMAGNUM_WITH_SDL2APPLICATION=ON
cmake --build .
@endcode
@ -989,7 +1003,7 @@ Then you can install the library using @cb{.sh} cmake --build . --target install
to make it available to depending projects.
If you have Node.js installed, you can also build and run unit tests using
`ctest`. See the `BUILD_TESTS` option @ref building-tests "above".
`ctest`. See the `MAGNUM_BUILD_TESTS` option @ref building-tests "above".
For ArchLinux there are also prepared package files in `package/archlinux`,
named `PKGBUILD-emscripten`, `PKGBUILD-emscripten-webgl2`,
@ -1023,10 +1037,10 @@ You can omit specifying `CORRADE_RC_EXECUTABLE` if
through `PATH`.
As every application is in its own sandbox, it doesn't make sense to build
shared libraries (although it is supported). Enable `BUILD_STATIC` to build
static libraries. Dynamically loaded plugins are not supported on iOS at the
moment, thus `BUILD_PLUGINS_STATIC` is implicitly enabled. OpenGL ES 2.0 is
enabled by default, switch to 3.0 by disabling `TARGET_GLES2`.
shared libraries (although it is supported). Enable `MAGNUM_BUILD_STATIC` to
build static libraries. Dynamically loaded plugins are not supported on iOS at
the moment, thus `MAGNUM_BUILD_PLUGINS_STATIC` is implicitly enabled. OpenGL ES
2.0 is enabled by default, switch to 3.0 by disabling `MAGNUM_TARGET_GLES2`.
@m_class{m-console-wrap}
@ -1038,10 +1052,10 @@ cmake .. \
-DCMAKE_OSX_ARCHITECTURES="arm64;armv7;armv7s" \
-DCMAKE_INSTALL_PREFIX=~/ios-libs \
-DCORRADE_RC_EXECUTABLE=/path/to/corrade-rc \
-DBUILD_STATIC=ON \
-DBUILD_PLUGINS_STATIC=ON \
-DTARGET_GLES2=OFF \
-DWITH_SDL2APPLICATION=ON \
-DMAGNUM_BUILD_STATIC=ON \
-DMAGNUM_BUILD_PLUGINS_STATIC=ON \
-DMAGNUM_TARGET_GLES2=OFF \
-DMAGNUM_WITH_SDL2APPLICATION=ON \
-G Xcode
cmake --build .
@endcode
@ -1072,10 +1086,10 @@ Create a build directory and run `cmake` and the build command in it. Set
ABI. Check the [CMake Android cross-compiling documentation](https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html#cross-compiling-for-android)
for further information. You can omit specifying `CORRADE_RC_EXECUTABLE` if
@ref building-cross-corrade-rc "natively-built corrade-rc" is accessible
through `PATH`. Note that `BUILD_STATIC` is implicitly enabled, because
through `PATH`. Note that `MAGNUM_BUILD_STATIC` is implicitly enabled, because
manually loading all depending shared libraries using JNI would be too
inconvenient. The engine is built for OpenGL ES 2.0 by default, switch to 3.0
by disabling `TARGET_GLES2`.
by disabling `MAGNUM_TARGET_GLES2`.
If you set `CMAKE_INSTALL_PREFIX` to `/usr` subdirectory of the particular
Android platform sysroot (as shown below), Magnum's buildsystem will also pick
@ -1114,8 +1128,8 @@ cmake .. \
-DCMAKE_FIND_ROOT_PATH=/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/sysroot \
-DCMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX=/aarch64-linux-android/24 \
-DCORRADE_RC_EXECUTABLE=/path/to/corrade-rc \
-DTARGET_GLES2=OFF \
-DWITH_ANDROIDAPPLICATION=ON
-DMAGNUM_TARGET_GLES2=OFF \
-DMAGNUM_WITH_ANDROIDAPPLICATION=ON
cmake --build .
@endcode

7
doc/changelog.dox

@ -722,6 +722,13 @@ See also:
@subsection changelog-latest-deprecated Deprecated APIs
- All @ref building-features "CMake build options" are now prefixed with
`MAGNUM_`. For backwards compatibility, unless @ref MAGNUM_BUILD_DEPRECATED
is disabled and unless a prefixed option is already set during the initial
run, the unprefixed options are still recognized with a warning. In
particular, if `BUILD_DEPRECATED` is set but `MAGNUM_BUILD_DEPRECATED` not,
the unprefixed options are also recognized. See also
[mosra/corrade#139](https://github.com/mosra/corrade/issues/139).
- The @cpp Array @ce, @cpp Array1D @ce, @cpp Array2D @ce and
@cpp Array3D @ce types that were used exclusively for specifying
@ref SamplerWrapping in various texture APIs are deprecated in favor of

6
doc/cmake.dox

@ -81,7 +81,7 @@ For example:
@code{.cmake}
add_subdirectory(corrade EXCLUDE_FROM_ALL) # so only things you use are built
set(WITH_ANYIMAGEIMPORTER ON CACHE BOOL "" FORCE) # enable what you need
set(MAGNUM_WITH_ANYIMAGEIMPORTER ON CACHE BOOL "" FORCE) # enable what you need
add_subdirectory(magnum EXCLUDE_FROM_ALL)
find_package(Magnum REQUIRED ...) # see below
@ -123,8 +123,8 @@ is to list them explicitly like shown below, another (but uglier) is to not use
implicitly.
@code{.cmake}
set(WITH_ANYIMAGEIMPORTER ON CACHE BOOL "" FORCE)
set(WITH_ANYSCENEIMPORTER ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_ANYIMAGEIMPORTER ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_ANYSCENEIMPORTER ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
# So the AnyImageImporter / AnySceneImporter gets built implicitly

41
doc/developers.dox

@ -36,10 +36,10 @@ required to follow them to the point.
@section developers-library Checklist for adding / removing a library
1. Add a `WITH_LIBRARYNAME` CMake option to:
1. Add a `MAGNUM_WITH_LIBRARYNAME` CMake option to:
- root `CMakeLists.txt` (if it has some inter-library dependencies,
update the others / convert them to @cmake cmake_dependent_option() @ce,
adding `NOT WITH_LIBRARYNAME` to their condition --- note the
adding `NOT MAGNUM_WITH_LIBRARYNAME` to their condition --- note the
conditions are ANDed so they need to be specified in reverse)
- the list in `doc/building.dox` (and similar files in other repos)
2. Update `FindMagnum.cmake` (or similar in other repos):
@ -73,17 +73,17 @@ required to follow them to the point.
- verify that target installation is done in proper places (separate
`RUNTIME` / `LIBRARY` / `ARCHIVE` destinations)
- verify that @cmake set_target_properties(MagnumLibraryName PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION}) @ce
is done in case `BUILD_STATIC` is *not* set
is done in case `MAGNUM_BUILD_STATIC` is *not* set
- verify that @cmake set_target_properties(MagnumLibraryName PROPERTIES POSITION_INDEPENDENT_CODE ON) @ce
is done in case `BUILD_STATIC_PIC` is set
is done in case `MAGNUM_BUILD_STATIC_PIC` is set
- verify that @cmake add_library(Magnum::LibraryName ALIAS MagnumLibraryName) @ce
(or equivalent) is added to make the library visible for CMake
subprojects
6. Create a new `src/Magnum/LibraryName/Test/` directory:
- add a `CMakeLists.txt` with pre-populated license header, add your name
to it
- conditionally @cmake add_subdirectory() @ce it if `BUILD_TESTS` is
enabled
- conditionally @cmake add_subdirectory() @ce it if `MAGNUM_BUILD_TESTS`
is enabled
7. Create a new `src/Magnum/LibraryName/LibraryName.h` header for forward
declarations (if needed), add a file-level doc block with
<tt>Forward declarations for the \@ref Magnum::LibraryName namespace</tt>
@ -95,18 +95,19 @@ required to follow them to the point.
target name
- if the library is combined from an `OBJECT` library, add its name to
the above @cpp #ifdef @ce as well (and then explicitly add
@cmake target_compile_definitions(MagnumLibraryNameObjects PRIVATE "MagnumLibraryNameObjects_EXPORTS") @ce to `CMakeLists.txt` in case `BUILD_STATIC` is not set)
@cmake target_compile_definitions(MagnumLibraryNameObjects PRIVATE "MagnumLibraryNameObjects_EXPORTS") @ce
to `CMakeLists.txt` in case `MAGNUM_BUILD_STATIC` is not set)
- the macro *does not* contain the full namespace path but rather mirrors
the library *file* name
9. Mention the directory and namespace in `doc/namespaces.dox`, basically
copy-pasting the following from existing documentation:
- directory-level doc block referencing the namespace
- namespace-level doc block mentioning the `WITH_LIBRARYNAME` option,
dependencies (if any) and a code snippet showing how to use it with
CMake
- namespace-level doc block mentioning the `MAGNUM_WITH_LIBRARYNAME`
option, dependencies (if any) and a code snippet showing how to use it
with CMake
10. Code and test the rest of the library, see @ref developers-file and
@ref developers-symbol for more information
11. Add the `WITH_LIBRARYNAME` option to all files in `package/` directory,
11. Add the `MAGNUM_WITH_LIBRARYNAME` option to all files in `package/` directory,
explicitly saying either `ON` or `OFF` based on platform support:
- all `package/archlinux/PKGBUILD*` files (and the AUR package(s))
- the `package/debian/rules` file (watch out, tabs!)
@ -214,8 +215,8 @@ Similarly to @ref developers-library except points 2 and 5, with:
--- for the plugin library it's done automatically inside
@cmake add_plugin() @ce
- verify that @cmake set_target_properties(PluginName PROPERTIES POSITION_INDEPENDENT_CODE ON) @ce
is done in case `BUILD_STATIC_PIC` is set
- verify that in case of `BUILD_PLUGINS_STATIC` the
is done in case `MAGNUM_BUILD_STATIC_PIC` is set
- verify that in case of `MAGNUM_BUILD_PLUGINS_STATIC` the
`importStaticPlugin.cpp` file is installed is set and that an
*absolute* path to it is added to @cmake target_sources() @ce
- verify that @cmake add_library(MagnumPlugins::PluginName ALIAS PluginName) @ce
@ -270,7 +271,7 @@ inverse --- but usually @ref developers-deprecation "deprecate first".
@section developers-example Checklist for adding / removing an example
1. Add a `WITH_EXAMPLENAME_EXAMPLE` CMake option to:
1. Add a `MAGNUM_WITH_EXAMPLENAME_EXAMPLE` CMake option to:
- root `CMakeLists.txt`
- the list in `doc/building-examples.dox`
2. Add a new `src/example-name` directory, copy up-to-date UNLICENSE headers
@ -321,7 +322,7 @@ in inverse.
- use @cmake corrade_add_test() @ce to add it to tests
- if some tests need GL context, add a separate test with `GLTest`
suffix, wrapping the corresponding @cmake corrade_add_test() @ce in
@cmake if(BUILD_GL_TESTS) @ce
@cmake if(MAGNUM_BUILD_GL_TESTS) @ce
6. Populate the file, see @ref developers-symbol and @ref coding-style for
more information.
7. Mention the new functionality in `doc/changelog.dox` (and similar files in
@ -459,11 +460,11 @@ in inverse --- but usually @ref developers-deprecation "deprecate first".
disable warnings for library *users*)
- a @cmake message(FATAL_ERROR) @ce to corresponding `CMakeLists.txt` in
case @ref MAGNUM_BUILD_DEPRECATED is not enabled
- a @m_class{m-label m-danger} **deprecated** label next to the `WITH_*`
CMake option in the corresponding `doc/building.dox` page and next to
the CMake component name in the corresponding `doc/cmake.dox` page
(and similar files in other repos), possibly also to all pages that
list it (if any)
- a @m_class{m-label m-danger} **deprecated** label next to the
`MAGNUM_WITH_*` CMake option in the corresponding `doc/building.dox`
page and next to the CMake component name in the corresponding
`doc/cmake.dox` page (and similar files in other repos), possibly also
to all pages that list it (if any)
3. If the library was enabled by default, make it disabled by default. Update
relevant sections in `doc/building.dox` and `doc/cmake.dox`.
4. Include the library component in the corresponding `Find` module component

19
doc/getting-started.dox

@ -76,7 +76,7 @@ set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/modules/" ${CMAKE_MODULE_PATH})
add_subdirectory(corrade EXCLUDE_FROM_ALL)
# Add Magnum as a subproject, enable Sdl2Application
set(WITH_SDL2APPLICATION ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_SDL2APPLICATION ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
add_subdirectory(src)
@ -104,7 +104,7 @@ the `SDL2-2.0.10` directory to `CMAKE_PREFIX_PATH`:
...
set(CMAKE_PREFIX_PATH ${PROJECT_SOURCE_DIR}/SDL2-2.0.10 ${CMAKE_PREFIX_PATH})
set(WITH_SDL2APPLICATION ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_SDL2APPLICATION ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode
@ -135,10 +135,10 @@ If you are lucky, you may already have Magnum packages ready for your platform:
If not, follow the full installation guides for @ref building-corrade "Corrade"
and @ref building "Magnum" to build & install everything; don't forget to
enable `WITH_SDL2APPLICATION` when building Magnum so the bootstrap project can
correctly find and use it. This is "the hard way" and it's recommended only if
you have at least some prior experience with building projects from source
using CMake.
enable `MAGNUM_WITH_SDL2APPLICATION` when building Magnum so the bootstrap
project can correctly find and use it. This is "the hard way" and it's
recommended only if you have at least some prior experience with building
projects from source using CMake.
Compared to @ref getting-started-setup-subproject "Option A", you don't need to
clone the subprojects and modify the `CMakeLists.txt` file, however you'll need
@ -316,8 +316,9 @@ want to try it with other toolkits such as [GLFW](https://www.glfw.org/) or
[Qt](https://www.qt.io/) there are similar projects in other branches of the
[bootstrap repository](https://github.com/mosra/magnum-bootstrap). If you
download [base-glfw.zip](https://github.com/mosra/magnum-bootstrap/archive/base-glfw.zip), you get a GLFW-based project. It's mostly the same, with only minor
differences. Enable `WITH_GLFWAPPLICATION` instead of `WITH_SDL2APPLICATION`,
on Linux or Mac install one of the following packages:
differences. Enable `MAGNUM_WITH_GLFWAPPLICATION` instead of
`MAGNUM_WITH_SDL2APPLICATION`, on Linux or Mac install one of the following
packages:
@code{.sh}
sudo pacman -S glfw-x11 # on ArchLinux
@ -333,7 +334,7 @@ or [glfw-3.3.bin.WIN64.zip](https://github.com/glfw/glfw/releases/download/3.3/g
...
# or glfw-3.3.bin.WIN32 here
set(CMAKE_PREFIX_PATH ${PROJECT_SOURCE_DIR}/glfw-3.3.bin.WIN64 ${CMAKE_PREFIX_PATH})
set(WITH_GLFWAPPLICATION ON)
set(MAGNUM_WITH_GLFWAPPLICATION ON)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

86
doc/namespaces.dox

@ -54,7 +54,7 @@ more information.
Base classes for creating applications with various toolkits.
Parts of this namespace are built if `WITH_*APPLICATION` is enabled when
Parts of this namespace are built if `MAGNUM_WITH_*APPLICATION` is enabled when
building Magnum, with each library having specific toolkit dependencies and
platform requirements. To use a particular application library with CMake,
request given `*Application` component of the `Magnum` package and link
@ -248,8 +248,8 @@ See @ref building, @ref cmake and @ref animation for more information.
Audio import, playback and integration with @ref SceneGraph.
This library depends on the [OpenAL](https://www.openal.org/) library and is
built if `WITH_AUDIO` is enabled when building Magnum. To use this library with
CMake, put [FindOpenAL.cmake](https://github.com/mosra/magnum/blob/master/modules/FindOpenAL.cmake)
built if `MAGNUM_WITH_AUDIO` is enabled when building Magnum. To use this
library with CMake, put [FindOpenAL.cmake](https://github.com/mosra/magnum/blob/master/modules/FindOpenAL.cmake)
into your `modules/` directory, request the `Audio` component of the `Magnum`
package and link to the `Magnum::Audio` target:
@ -272,7 +272,7 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON) # needed if building dynamic libraries
set(LIBTYPE STATIC) # omit or set to SHARED if you want a shared OpenAL library
add_subdirectory(openal-soft EXCLUDE_FROM_ALL)
set(WITH_AUDIO ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_AUDIO ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode
@ -295,9 +295,9 @@ utility documentation, @ref building, @ref building-plugins, @ref cmake,
Debugging helpers, renderers and profilers.
This library is built if `WITH_DEBUGTOOLS` is enabled when building Magnum. To
use this library with CMake, request the `DebugTools` component of the `Magnum`
package and link to the `Magnum::DebugTools` target:
This library is built if `MAGNUM_WITH_DEBUGTOOLS` is enabled when building
Magnum. To use this library with CMake, request the `DebugTools` component of
the `Magnum` package and link to the `Magnum::DebugTools` target:
@code{.cmake}
find_package(Magnum REQUIRED DebugTools)
@ -318,9 +318,9 @@ See @ref building, @ref cmake and @ref debug-tools for more information.
C++11 wrappers around OpenGL objects with state tracking and transparent
extension support.
All of this library except @ref GL::OpenGLTester is built if `WITH_GL` is
enabled when building Magnum. To use this library with CMake, request the `GL`
component of the `Magnum` package and link to the `Magnum::GL` target:
All of this library except @ref GL::OpenGLTester is built if `MAGNUM_WITH_GL`
is enabled when building Magnum. To use this library with CMake, request the
`GL` component of the `Magnum` package and link to the `Magnum::GL` target:
@code{.cmake}
find_package(Magnum REQUIRED GL)
@ -357,9 +357,9 @@ See @ref building, @ref cmake and @ref opengl for more information.
Tools for generating, optimizing and cleaning meshes.
This library is built if `WITH_MESHTOOLS` is enabled when building Magnum. To
use this library with CMake, request the `MeshTools` component of the `Magnum`
package and link to the `Magnum::MeshTools` target:
This library is built if `MAGNUM_WITH_MESHTOOLS` is enabled when building
Magnum. To use this library with CMake, request the `MeshTools` component of
the `Magnum` package and link to the `Magnum::MeshTools` target:
@code{.cmake}
find_package(Magnum REQUIRED MeshTools)
@ -369,8 +369,8 @@ target_link_libraries(your-app PRIVATE Magnum::MeshTools)
@endcode
Note that functionality depending on @ref GL APIs is available only if Magnum
is built with both `WITH_GL` and `TARGET_GL` enabled (which is done by
default).
is built with both `MAGNUM_WITH_GL` and `MAGNUM_TARGET_GL` enabled (which is
done by default).
See @ref building and @ref cmake for more information.
*/
@ -383,9 +383,9 @@ See @ref building and @ref cmake for more information.
Basic primitives for testing purposes.
This library is built if `WITH_PRIMITIVES` is enabled when building Magnum. To
use this library with CMake, request the `Primitives` component of the `Magnum`
package and link to the `Magnum::Primitives` target:
This library is built if `MAGNUM_WITH_PRIMITIVES` is enabled when building
Magnum. To use this library with CMake, request the `Primitives` component of
the `Magnum` package and link to the `Magnum::Primitives` target:
@code{.cmake}
find_package(Magnum REQUIRED Primitives)
@ -405,9 +405,9 @@ See @ref building and @ref cmake for more information.
Managing object hierarchy, transformations and interactions.
This library is built if `WITH_SCENEGRAPH` is enabled when building Magnum. To
use this library with CMake, request the `SceneGraph` component of the `Magnum`
package and link to the `Magnum::SceneGraph` target:
This library is built if `MAGNUM_WITH_SCENEGRAPH` is enabled when building
Magnum. To use this library with CMake, request the `SceneGraph` component of
the `Magnum` package and link to the `Magnum::SceneGraph` target:
@code{.cmake}
find_package(Magnum REQUIRED SceneGraph)
@ -429,9 +429,9 @@ See @ref building, @ref cmake and @ref scenegraph for more information.
Scene manipulation and optimization tools.
This library is built if `WITH_SCENETOOLS` is enabled when building Magnum. To
use this library with CMake, request the `SceneTools` component of the
`Magnum` package and link to the `Magnum::SceneTools` target:
This library is built if `MAGNUM_WITH_SCENETOOLS` is enabled when building
Magnum. To use this library with CMake, request the `SceneTools` component of
the `Magnum` package and link to the `Magnum::SceneTools` target:
@code{.cmake}
find_package(Magnum REQUIRED SceneTools)
@ -453,8 +453,8 @@ Additional utilities are built separately. See the
Collection of shaders for easy prototyping and basic usage.
This library is built if `WITH_SHADERS` is enabled when building Magnum. To
use this library with CMake, request the `Shaders` component of the `Magnum`
This library is built if `MAGNUM_WITH_SHADERS` is enabled when building Magnum.
To use this library with CMake, request the `Shaders` component of the `Magnum`
package and link to the `Magnum::Shaders` target:
@code{.cmake}
@ -529,9 +529,9 @@ See @ref building, @ref cmake and @ref shaders for more information.
Shader validation, conversion, compilation and reflection.
This library is built if `WITH_SHADERTOOLS` is enabled when building Magnum. To
use this library with CMake, request the `ShaderTools` component of the
`Magnum` package and link to the `Magnum::ShaderTools` target:
This library is built if `MAGNUM_WITH_SHADERTOOLS` is enabled when building
Magnum. To use this library with CMake, request the `ShaderTools` component of
the `Magnum` package and link to the `Magnum::ShaderTools` target:
@code{.cmake}
find_package(Magnum REQUIRED ShaderTools)
@ -555,9 +555,9 @@ Additional plugins and utilities are built separately. See particular
Font texture creation and text layout.
This library is built if `WITH_TEXT` is enabled when building Magnum. To use
this library with CMake, request the `Text` component of the `Magnum` package
and link to the `Magnum::Text` target:
This library is built if `MAGNUM_WITH_TEXT` is enabled when building Magnum. To
use this library with CMake, request the `Text` component of the `Magnum`
package and link to the `Magnum::Text` target:
@code{.cmake}
find_package(Magnum REQUIRED Text)
@ -581,9 +581,9 @@ and `*FontConverter` class documentation, the
Tools for generating, compressing and optimizing textures.
This library is built if `WITH_TEXTURETOOLS` is enabled when building Magnum.
To use this library with CMake, request the `TextureTools` component of the
`Magnum` package in CMake and link to the `Magnum::TextureTools` target:
This library is built if `MAGNUM_WITH_TEXTURETOOLS` is enabled when building
Magnum. To use this library with CMake, request the `TextureTools` component of
the `Magnum` package in CMake and link to the `Magnum::TextureTools` target:
@code{.cmake}
find_package(Magnum REQUIRED TextureTools)
@ -593,8 +593,8 @@ target_link_libraries(your-app PRIVATE Magnum::TextureTools)
@endcode
Note that functionality depending on @ref GL APIs is available only if Magnum
is built with both `WITH_GL` and `TARGET_GL` enabled (which is done by
default).
is built with both `MAGNUM_WITH_GL` and `MAGNUM_TARGET_GL` enabled (which is
done by default).
Additional utilities are built separately. See the
@ref magnum-distancefieldconverter "magnum-distancefieldconverter" utility
@ -610,9 +610,9 @@ documentation, @ref building and @ref cmake for more information.
Contains plugin interfaces for importing data of various formats and classes
for direct access to the data.
This library is built if `WITH_TRADE` is enabled when building Magnum. To use
this library with CMake, request the `Trade` component of the `Magnum` package
and link to the `Magnum::Trade` target:
This library is built if `MAGNUM_WITH_TRADE` is enabled when building Magnum.
To use this library with CMake, request the `Trade` component of the `Magnum`
package and link to the `Magnum::Trade` target:
@code{.cmake}
find_package(Magnum REQUIRED Trade)
@ -638,8 +638,8 @@ Additional plugins and utilities are built separately. See particular
C++14 wrappers and helpers for Vulkan development.
This library is depends on [Vulkan](https://www.khronos.org/vulkan/) and is
built if `WITH_VK` is enabled when building Magnum. To use this library with
CMake, put [FindVulkan.cmake](https://github.com/mosra/magnum/blob/master/modules/FindVulkan.cmake)
built if `MAGNUM_WITH_VK` is enabled when building Magnum. To use this library
with CMake, put [FindVulkan.cmake](https://github.com/mosra/magnum/blob/master/modules/FindVulkan.cmake)
into your `modules/` directory, request the `Vk` component of the `Magnum`
package and link to the `Magnum::Vk` target:
@ -655,7 +655,7 @@ Additionally, if you're using Magnum as a CMake subproject, do the following
library is not built by default:
@code{.cmake}
set(WITH_VK ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_VK ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

4
doc/platforms-android.dox

@ -1041,8 +1041,8 @@ quick, the log is spitting out a lot of info all the time. Possible causes:
[official API level documentation](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
for more information.
- The device doesn't support OpenGL ES 3.0 yet. Rebuild Magnum and its
dependencies with the `TARGET_GLES2` option enabled. See @ref building-features
for more information.
dependencies with the `MAGNUM_TARGET_GLES2` option enabled. See
@ref building-features for more information.
- Loading fails with `ANativeActivity_onCreate` symbol not being found. If
you are using @ref Platform::AndroidApplication, this issue should be
prevented, otherwise you need to add `-u ANativeActivity_onCreate` to your

10
doc/plugins.dox

@ -117,11 +117,11 @@ time it is actually needed. However, if you need to port to a platform which
does not support dynamic linking or you simply want to have the plugin loaded
at all times, you can use static plugins.
The plugins are built as static if the `BUILD_PLUGINS_STATIC` CMake parameter
is enabled (see @ref building and @ref building-plugins for more information).
The actual usage in the code is basically the same as above, but you need to
explicitly find the plugin and link it into the executable. If you use CMake,
it would look like this:
The plugins are built as static if the `MAGNUM_BUILD_PLUGINS_STATIC` CMake
option is enabled (see @ref building and @ref building-plugins for more
information). The actual usage in the code is basically the same as above, but
you need to explicitly find the plugin and link it into the executable. If you
use CMake, it would look like this:
@code{.cmake}
find_package(MagnumPlugins REQUIRED

38
doc/snippets/CMakeLists.txt

@ -37,7 +37,7 @@ set_directory_properties(PROPERTIES
CORRADE_USE_PEDANTIC_FLAGS ON)
# Emscripten needs special flag to use WebGL 2
if(CORRADE_TARGET_EMSCRIPTEN AND NOT TARGET_GLES2)
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()
@ -68,11 +68,11 @@ if((CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT CMAKE_CXX_COMPILER_VERSION VERS
set_target_properties(snippets-Magnum-cpp14 PROPERTIES CORRADE_CXX_STANDARD 14)
endif()
if(WITH_AUDIO)
if(MAGNUM_WITH_AUDIO)
add_library(snippets-MagnumAudio STATIC MagnumAudio.cpp)
target_link_libraries(snippets-MagnumAudio PRIVATE MagnumAudio)
if(WITH_SCENEGRAPH)
if(MAGNUM_WITH_SCENEGRAPH)
add_library(snippets-MagnumAudio-scenegraph STATIC
MagnumAudio-scenegraph.cpp)
target_link_libraries(snippets-MagnumAudio-scenegraph PRIVATE
@ -81,7 +81,7 @@ if(WITH_AUDIO)
endif()
endif()
if(WITH_GL)
if(MAGNUM_WITH_GL)
add_library(snippets-MagnumGL STATIC
MagnumGL.cpp
MagnumMeshTools-gl.cpp
@ -90,20 +90,20 @@ if(WITH_GL)
target_link_libraries(snippets-MagnumGL PRIVATE MagnumGL)
endif()
if(WITH_MESHTOOLS)
if(MAGNUM_WITH_MESHTOOLS)
add_library(snippets-MagnumMeshTools STATIC
MagnumMeshTools.cpp
MagnumMeshTools-gl.cpp)
target_link_libraries(snippets-MagnumMeshTools PRIVATE MagnumMeshTools)
endif()
if(WITH_SHADERTOOLS)
if(MAGNUM_WITH_SHADERTOOLS)
add_library(snippets-MagnumShaderTools STATIC
MagnumShaderTools.cpp)
target_link_libraries(snippets-MagnumShaderTools PRIVATE MagnumShaderTools)
endif()
if(WITH_TRADE)
if(MAGNUM_WITH_TRADE)
add_library(snippets-MagnumTrade STATIC
plugins.cpp
MagnumTrade.cpp)
@ -115,12 +115,12 @@ endif()
find_package(Corrade COMPONENTS TestSuite)
if(WITH_DEBUGTOOLS)
if(MAGNUM_WITH_DEBUGTOOLS)
add_library(snippets-MagnumDebugTools STATIC
MagnumDebugTools.cpp)
target_link_libraries(snippets-MagnumDebugTools PRIVATE MagnumDebugTools)
if(BUILD_GL_TESTS AND NOT MAGNUM_TARGET_GLES)
if(MAGNUM_BUILD_GL_TESTS AND NOT MAGNUM_TARGET_GLES)
add_executable(debugtools-frameprofiler debugtools-frameprofiler.cpp)
target_link_libraries(debugtools-frameprofiler PRIVATE
MagnumDebugTools MagnumOpenGLTester)
@ -143,25 +143,25 @@ if(WITH_DEBUGTOOLS)
target_include_directories(debugtools-compareimage PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
endif()
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
add_library(snippets-MagnumDebugTools-gl STATIC
MagnumDebugTools-gl.cpp)
target_link_libraries(snippets-MagnumDebugTools-gl PRIVATE MagnumDebugTools)
endif()
endif()
if(WITH_PRIMITIVES)
if(MAGNUM_WITH_PRIMITIVES)
add_library(snippets-MagnumPrimitives STATIC
MagnumPrimitives.cpp)
target_link_libraries(snippets-MagnumPrimitives PRIVATE MagnumPrimitives)
endif()
if(WITH_SCENEGRAPH)
if(MAGNUM_WITH_SCENEGRAPH)
add_library(snippets-MagnumSceneGraph STATIC
MagnumSceneGraph.cpp)
target_link_libraries(snippets-MagnumSceneGraph PRIVATE MagnumSceneGraph)
if(WITH_SDL2APPLICATION AND WITH_GL AND WITH_PRIMITIVES AND WITH_SHADERS AND WITH_MESHTOOLS)
if(MAGNUM_WITH_SDL2APPLICATION AND MAGNUM_WITH_GL AND MAGNUM_WITH_PRIMITIVES AND MAGNUM_WITH_SHADERS AND MAGNUM_WITH_MESHTOOLS)
add_library(snippets-MagnumSceneGraph-gl STATIC
MagnumSceneGraph-gl.cpp)
target_link_libraries(snippets-MagnumSceneGraph-gl PRIVATE
@ -174,18 +174,18 @@ if(WITH_SCENEGRAPH)
endif()
endif()
if(WITH_SCENETOOLS)
if(MAGNUM_WITH_SCENETOOLS)
add_library(snippets-MagnumSceneTools STATIC
MagnumSceneTools.cpp)
target_link_libraries(snippets-MagnumSceneTools PRIVATE MagnumSceneTools)
endif()
if(WITH_VK)
if(MAGNUM_WITH_VK)
add_library(snippets-MagnumVk STATIC MagnumVk.cpp)
target_link_libraries(snippets-MagnumVk PRIVATE MagnumVk)
endif()
if(WITH_SDL2APPLICATION AND TARGET_GL)
if(MAGNUM_WITH_SDL2APPLICATION AND MAGNUM_TARGET_GL)
add_executable(getting-started getting-started.cpp)
add_executable(getting-started-blue getting-started-blue.cpp)
target_link_libraries(getting-started PRIVATE MagnumSdl2Application)
@ -197,16 +197,16 @@ if(WITH_SDL2APPLICATION AND TARGET_GL)
target_link_libraries(snippets-MagnumPlatform PRIVATE MagnumSdl2Application)
endif()
if((NOT TARGET_GLES AND WITH_SDL2APPLICATION) OR (TARGET_GLES AND WITH_XEGLAPPLICATION))
if((NOT MAGNUM_TARGET_GLES AND MAGNUM_WITH_SDL2APPLICATION) OR (MAGNUM_TARGET_GLES AND MAGNUM_WITH_XEGLAPPLICATION))
add_library(snippets-MagnumPlatform-portability STATIC MagnumPlatform-portability.cpp)
if(TARGET_GLES)
if(MAGNUM_TARGET_GLES)
target_link_libraries(snippets-MagnumPlatform-portability PRIVATE MagnumXEglApplication)
else()
target_link_libraries(snippets-MagnumPlatform-portability PRIVATE MagnumSdl2Application)
endif()
endif()
if(WITH_WINDOWLESSEGLAPPLICATION)
if(MAGNUM_WITH_WINDOWLESSEGLAPPLICATION)
add_library(snippets-MagnumPlatform-custom STATIC MagnumPlatform-custom.cpp)
add_library(snippets-MagnumPlatform-windowless STATIC MagnumPlatform-windowless.cpp)
add_library(snippets-MagnumPlatform-windowless-custom STATIC MagnumPlatform-windowless-custom.cpp)

9
doc/troubleshooting.dox

@ -48,10 +48,11 @@ things:
guaranteed to stay in the codebase for a year at least (or two subsequent
version releases, whichever is longer) and only then they get removed. To
make sure you're no longer using any deprecated functionality, it's
possible to disable the `BUILD_DEPRECATED` @ref building-features "CMake option"
when building Magnum, although for a smoother experience it's recommended
to flip this option back on when upgrading. A list of deprecated APIs is
maintained @ref changelog-latest-deprecated "in the changelog".
possible to disable the `MAGNUM_BUILD_DEPRECATED`
@ref building-features "CMake option" when building Magnum, although for a
smoother experience it's recommended to flip this option back on when
upgrading. A list of deprecated APIs is maintained
@ref changelog-latest-deprecated "in the changelog".
- In some rare cases, it's impossible to provide a deprecated migration path
and an API gets changed in a backwards-incompatible manner, directly
leading to a compile error. Another possibility is that transitive header

2
modules/FindMagnum.cmake

@ -1073,7 +1073,7 @@ if(NOT CMAKE_VERSION VERSION_LESS 3.16)
# misleading messages.
elseif(NOT _component IN_LIST _MAGNUM_IMPLICITLY_ENABLED_COMPONENTS)
string(TOUPPER ${_component} _COMPONENT)
list(APPEND _MAGNUM_REASON_FAILURE_MESSAGE "${_component} is not built by default. Make sure you enabled WITH_${_COMPONENT} when building Magnum.")
list(APPEND _MAGNUM_REASON_FAILURE_MESSAGE "${_component} is not built by default. Make sure you enabled MAGNUM_WITH_${_COMPONENT} when building Magnum.")
# Otherwise we have no idea. Better be silent than to print something
# misleading.
else()

2
src/CMakeLists.txt

@ -44,7 +44,7 @@ endif()
# passed via target_link_libraries() etc. without requiring CMake 3.13
# https://github.com/emscripten-core/emscripten/blob/main/ChangeLog.md#13919-07072020
# -- change to that once we drop support for older Emscripten versions
if(CORRADE_TARGET_EMSCRIPTEN AND CMAKE_VERSION VERSION_LESS 3.13 AND WITH_GL AND NOT TARGET_GLES2)
if(CORRADE_TARGET_EMSCRIPTEN AND CMAKE_VERSION VERSION_LESS 3.13 AND MAGNUM_WITH_GL AND NOT MAGNUM_TARGET_GLES2)
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s USE_WEBGL2=1")
endif()

2
src/Magnum/Animation/CMakeLists.txt

@ -40,6 +40,6 @@ add_custom_target(MagnumAnimation SOURCES ${MagnumAnimation_HEADERS})
install(FILES ${MagnumAnimation_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/Animation)
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

20
src/Magnum/Audio/CMakeLists.txt

@ -58,7 +58,7 @@ if(NOT CORRADE_PLUGINMANAGER_NO_DYNAMIC_PLUGIN_SUPPORT)
${CMAKE_CURRENT_BINARY_DIR}/configure.h)
endif()
if(WITH_SCENEGRAPH)
if(MAGNUM_WITH_SCENEGRAPH)
list(APPEND MagnumAudio_HEADERS
Listener.h
Playable.h
@ -78,10 +78,10 @@ target_include_directories(MagnumAudioObjects PUBLIC
$<TARGET_PROPERTY:OpenAL::OpenAL,INTERFACE_INCLUDE_DIRECTORIES>
$<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>
$<TARGET_PROPERTY:Corrade::PluginManager,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumAudioObjects PRIVATE "MagnumAudioObjects_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumAudioObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
@ -91,16 +91,16 @@ add_library(MagnumAudio ${SHARED_OR_STATIC}
${MagnumAudio_GracefulAssert_SRCS})
target_include_directories(MagnumAudio PUBLIC ${OPENAL_INCLUDE_DIR})
set_target_properties(MagnumAudio PROPERTIES DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
set_target_properties(MagnumAudio PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION})
elseif(BUILD_STATIC_PIC)
elseif(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumAudio PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumAudio PUBLIC
Magnum
Corrade::PluginManager
OpenAL::OpenAL)
if(WITH_SCENEGRAPH)
if(MAGNUM_WITH_SCENEGRAPH)
target_link_libraries(MagnumAudio PUBLIC MagnumSceneGraph)
endif()
@ -130,7 +130,7 @@ endif()
# Magnum Audio target alias for superprojects
add_library(Magnum::Audio ALIAS MagnumAudio)
if(WITH_AL_INFO)
if(MAGNUM_WITH_AL_INFO)
add_executable(magnum-al-info al-info.cpp)
target_link_libraries(magnum-al-info PRIVATE MagnumAudio)
@ -168,7 +168,7 @@ if(WITH_AL_INFO)
add_executable(Magnum::al-info ALIAS magnum-al-info)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
# Library with graceful assert for testing
add_library(MagnumAudioTestLib ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumAudioObjects>
@ -177,14 +177,14 @@ if(BUILD_TESTS)
"CORRADE_GRACEFUL_ASSERT" "MagnumAudio_EXPORTS")
target_include_directories(MagnumAudioTestLib PUBLIC ${OPENAL_INCLUDE_DIR})
set_target_properties(MagnumAudioTestLib PROPERTIES DEBUG_POSTFIX "-d")
if(BUILD_STATIC_PIC)
if(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumAudioTestLib PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumAudioTestLib PUBLIC
Magnum
Corrade::PluginManager
OpenAL::OpenAL)
if(WITH_SCENEGRAPH)
if(MAGNUM_WITH_SCENEGRAPH)
target_link_libraries(MagnumAudioTestLib PUBLIC MagnumSceneGraph)
endif()

6
src/Magnum/Audio/Extensions.h

@ -47,8 +47,8 @@ compile-time decisions rather than @ref Extension instances. See
@ref Context::isExtensionSupported() for example usage.
This library depends on the [OpenAL](https://www.openal.org/) library and is
built if `WITH_AUDIO` is enabled when building Magnum. To use this library with
CMake, put [FindOpenAL.cmake](https://github.com/mosra/magnum/blob/master/modules/FindOpenAL.cmake)
built if `MAGNUM_WITH_AUDIO` is enabled when building Magnum. To use this
library with CMake, put [FindOpenAL.cmake](https://github.com/mosra/magnum/blob/master/modules/FindOpenAL.cmake)
into your `modules/` directory, request the `Audio` component of the `Magnum`
package and link to the `Magnum::Audio` target:
@ -71,7 +71,7 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON) # needed if building dynamic libraries
set(LIBTYPE STATIC) # omit or set to SHARED if you want a shared OpenAL library
add_subdirectory(openal-soft EXCLUDE_FROM_ALL)
set(WITH_AUDIO ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_AUDIO ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

4
src/Magnum/Audio/Test/CMakeLists.txt

@ -46,13 +46,13 @@ corrade_add_test(AudioContextTest ContextTest.cpp LIBRARIES MagnumAudio)
corrade_add_test(AudioRendererTest RendererTest.cpp LIBRARIES MagnumAudio)
corrade_add_test(AudioSourceTest SourceTest.cpp LIBRARIES MagnumAudio)
if(BUILD_AL_TESTS)
if(MAGNUM_BUILD_AL_TESTS)
corrade_add_test(AudioBufferALTest BufferALTest.cpp LIBRARIES MagnumAudio)
corrade_add_test(AudioContextALTest ContextALTest.cpp LIBRARIES MagnumAudio)
corrade_add_test(AudioRendererALTest RendererALTest.cpp LIBRARIES MagnumAudio)
corrade_add_test(AudioSourceALTest SourceALTest.cpp LIBRARIES MagnumAudio)
if(WITH_SCENEGRAPH)
if(MAGNUM_WITH_SCENEGRAPH)
corrade_add_test(AudioListenerALTest ListenerALTest.cpp LIBRARIES MagnumSceneGraph MagnumAudio)
corrade_add_test(AudioPlayableALTest PlayableALTest.cpp LIBRARIES MagnumSceneGraph MagnumAudio)
endif()

8
src/Magnum/Audio/al-info.cpp

@ -39,10 +39,10 @@ namespace Magnum {
@m_div{m-button m-primary} <a href="https://magnum.graphics/showcase/al-info/">@m_div{m-big}Live web version @m_enddiv @m_div{m-small} uses WebAssembly & WebAudio @m_enddiv </a> @m_enddiv
This utility is built if `WITH_AL_INFO` is enabled when building Magnum. To use
this utility with CMake, you need to request the `al-info` component of the
`Magnum` package and use the `Magnum::al-info` target for example in a custom
command:
This utility is built if `MAGNUM_WITH_AL_INFO` is enabled when building Magnum.
To use this utility with CMake, you need to request the `al-info` component of
the `Magnum` package and use the `Magnum::al-info` target for example in a
custom command:
@code{.cmake}
find_package(Magnum REQUIRED al-info)

42
src/Magnum/CMakeLists.txt

@ -147,10 +147,10 @@ target_include_directories(MagnumMathObjects PUBLIC
${PROJECT_SOURCE_DIR}/src
${PROJECT_BINARY_DIR}/src
$<TARGET_PROPERTY:Corrade::Utility,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumMathObjects PRIVATE "MagnumMathObjects_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumMathObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
# Differs from CMAKE_FOLDER
@ -165,10 +165,10 @@ target_include_directories(MagnumObjects PUBLIC
${PROJECT_SOURCE_DIR}/src
${PROJECT_BINARY_DIR}/src
$<TARGET_PROPERTY:Corrade::Utility,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumObjects PRIVATE "MagnumObjects_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
@ -179,9 +179,9 @@ add_library(Magnum ${SHARED_OR_STATIC}
${MagnumMath_GracefulAssert_SRCS}
${Magnum_GracefulAssert_SRCS})
set_target_properties(Magnum PROPERTIES DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
set_target_properties(Magnum PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION})
elseif(BUILD_STATIC_PIC)
elseif(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(Magnum PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_include_directories(Magnum PUBLIC
@ -204,59 +204,59 @@ add_subdirectory(Animation)
add_subdirectory(Math)
add_subdirectory(Platform)
if(WITH_AUDIO)
if(MAGNUM_WITH_AUDIO)
add_subdirectory(Audio)
endif()
if(WITH_DEBUGTOOLS)
if(MAGNUM_WITH_DEBUGTOOLS)
add_subdirectory(DebugTools)
endif()
if(WITH_GL)
if(MAGNUM_WITH_GL)
add_subdirectory(GL)
endif()
if(WITH_MESHTOOLS)
if(MAGNUM_WITH_MESHTOOLS)
add_subdirectory(MeshTools)
endif()
if(WITH_PRIMITIVES)
if(MAGNUM_WITH_PRIMITIVES)
add_subdirectory(Primitives)
endif()
if(WITH_SCENEGRAPH)
if(MAGNUM_WITH_SCENEGRAPH)
add_subdirectory(SceneGraph)
endif()
if(WITH_SCENETOOLS)
if(MAGNUM_WITH_SCENETOOLS)
add_subdirectory(SceneTools)
endif()
if(WITH_SHADERS)
if(MAGNUM_WITH_SHADERS)
add_subdirectory(Shaders)
endif()
if(WITH_SHADERTOOLS)
if(MAGNUM_WITH_SHADERTOOLS)
add_subdirectory(ShaderTools)
endif()
if(WITH_TEXT)
if(MAGNUM_WITH_TEXT)
add_subdirectory(Text)
endif()
if(WITH_TEXTURETOOLS)
if(MAGNUM_WITH_TEXTURETOOLS)
add_subdirectory(TextureTools)
endif()
if(WITH_TRADE)
if(MAGNUM_WITH_TRADE)
add_subdirectory(Trade)
endif()
if(WITH_VK)
if(MAGNUM_WITH_VK)
add_subdirectory(Vk)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
# Math library with graceful assert for testing
add_library(MagnumMathTestLib ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumMathObjects>
@ -283,7 +283,7 @@ if(BUILD_TESTS)
target_compile_definitions(MagnumTestLib PRIVATE
"CORRADE_GRACEFUL_ASSERT" "Magnum_EXPORTS")
set_target_properties(MagnumTestLib PROPERTIES DEBUG_POSTFIX "-d")
if(BUILD_STATIC_PIC)
if(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumTestLib PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumTestLib PUBLIC Corrade::Utility)

34
src/Magnum/DebugTools/CMakeLists.txt

@ -48,7 +48,7 @@ if(MAGNUM_BUILD_DEPRECATED)
list(APPEND MagnumDebugTools_HEADERS Profiler.h)
endif()
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
list(APPEND MagnumDebugTools_SRCS
ResourceManager.cpp
Screenshot.cpp
@ -62,7 +62,7 @@ if(TARGET_GL)
if(MAGNUM_TARGET_GLES AND NOT MAGNUM_TARGET_GLES2)
corrade_add_resource(MagnumDebugTools_RESOURCES resources.conf)
list(APPEND MagnumDebugTools_SRCS ${MagnumDebugTools_RESOURCES})
if(BUILD_STATIC)
if(MAGNUM_BUILD_STATIC)
# On the static build we're importing the resources manually, so no
# need to have the implicit initializers as well.
set_property(SOURCE ${MagnumDebugTools_RESOURCES} APPEND PROPERTY
@ -80,7 +80,7 @@ if(TARGET_GL)
BufferData.h)
endif()
if(WITH_SCENEGRAPH)
if(MAGNUM_WITH_SCENEGRAPH)
list(APPEND MagnumDebugTools_SRCS
ForceRenderer.cpp
ObjectRenderer.cpp)
@ -96,7 +96,7 @@ endif()
# Build the TestSuite-related functionality only if it is present
find_package(Corrade COMPONENTS TestSuite)
if(Corrade_TestSuite_FOUND AND WITH_TRADE)
if(Corrade_TestSuite_FOUND AND MAGNUM_WITH_TRADE)
list(APPEND MagnumDebugTools_GracefulAssert_SRCS
CompareImage.cpp)
@ -110,13 +110,13 @@ add_library(MagnumDebugToolsObjects OBJECT
${MagnumDebugTools_HEADERS}
${MagnumDebugTools_PRIVATE_HEADERS})
target_include_directories(MagnumDebugToolsObjects PUBLIC $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumDebugToolsObjects PRIVATE "MagnumDebugToolsObjects_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumDebugToolsObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
target_include_directories(MagnumDebugToolsObjects PUBLIC $<TARGET_PROPERTY:MagnumGL,INTERFACE_INCLUDE_DIRECTORIES>)
endif()
@ -125,20 +125,20 @@ add_library(MagnumDebugTools ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumDebugToolsObjects>
${MagnumDebugTools_GracefulAssert_SRCS})
set_target_properties(MagnumDebugTools PROPERTIES DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
set_target_properties(MagnumDebugTools PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION})
elseif(BUILD_STATIC_PIC)
elseif(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumDebugTools PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumDebugTools PUBLIC Magnum)
if(Corrade_TestSuite_FOUND AND WITH_TRADE)
if(Corrade_TestSuite_FOUND AND MAGNUM_WITH_TRADE)
target_link_libraries(MagnumDebugTools PUBLIC
Corrade::TestSuite
MagnumTrade)
endif()
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
target_link_libraries(MagnumDebugTools PUBLIC MagnumGL)
if(WITH_SCENEGRAPH)
if(MAGNUM_WITH_SCENEGRAPH)
target_link_libraries(MagnumDebugTools PUBLIC
MagnumMeshTools
MagnumPrimitives
@ -153,7 +153,7 @@ install(TARGETS MagnumDebugTools
ARCHIVE DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR})
install(FILES ${MagnumDebugTools_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/DebugTools)
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
# Library with graceful assert for testing
add_library(MagnumDebugToolsTestLib ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumDebugToolsObjects>
@ -161,18 +161,18 @@ if(BUILD_TESTS)
set_target_properties(MagnumDebugToolsTestLib PROPERTIES DEBUG_POSTFIX "-d")
target_compile_definitions(MagnumDebugToolsTestLib PRIVATE
"CORRADE_GRACEFUL_ASSERT" "MagnumDebugTools_EXPORTS")
if(BUILD_STATIC_PIC)
if(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumDebugToolsTestLib PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumDebugToolsTestLib PUBLIC Magnum)
if(Corrade_TestSuite_FOUND AND WITH_TRADE)
if(Corrade_TestSuite_FOUND AND MAGNUM_WITH_TRADE)
target_link_libraries(MagnumDebugToolsTestLib PUBLIC
Corrade::TestSuite
MagnumTrade)
endif()
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
target_link_libraries(MagnumDebugToolsTestLib PUBLIC MagnumGL)
if(WITH_SCENEGRAPH)
if(MAGNUM_WITH_SCENEGRAPH)
target_link_libraries(MagnumDebugToolsTestLib PUBLIC
MagnumMeshTools
MagnumPrimitives

6
src/Magnum/DebugTools/ColorMap.h

@ -42,9 +42,9 @@ namespace Magnum { namespace DebugTools {
A collection of predefined color maps for visualization of gradient data.
This library is built if `WITH_DEBUGTOOLS` is enabled when building Magnum. To
use this library with CMake, request the `DebugTools` component of the `Magnum`
package and link to the `Magnum::DebugTools` target:
This library is built if `MAGNUM_WITH_DEBUGTOOLS` is enabled when building
Magnum. To use this library with CMake, request the `DebugTools` component of
the `Magnum` package and link to the `Magnum::DebugTools` target:
@code{.cmake}
find_package(Magnum REQUIRED DebugTools)

8
src/Magnum/DebugTools/ForceRenderer.h

@ -48,8 +48,8 @@ namespace Magnum { namespace DebugTools {
See @ref ForceRenderer documentation for more information.
@note This class is available only if Magnum is compiled with
@ref MAGNUM_TARGET_GL "TARGET_GL" and `WITH_SCENEGRAPH` enabled (done by
default). See @ref building-features for more information.
@ref MAGNUM_TARGET_GL "TARGET_GL" and `MAGNUM_WITH_SCENEGRAPH` enabled
(done by default). See @ref building-features for more information.
*/
class ForceRendererOptions {
public:
@ -113,8 +113,8 @@ to it.
@snippet MagnumDebugTools-gl.cpp ForceRenderer
@note This class is available only if Magnum is compiled with
@ref MAGNUM_TARGET_GL "TARGET_GL" and `WITH_SCENEGRAPH` enabled (done by
default). See @ref building-features for more information.
@ref MAGNUM_TARGET_GL "TARGET_GL" and `MAGNUM_WITH_SCENEGRAPH` enabled
(done by default). See @ref building-features for more information.
@see @ref ForceRenderer2D, @ref ForceRenderer3D, @ref ForceRendererOptions
*/

8
src/Magnum/DebugTools/ObjectRenderer.h

@ -47,8 +47,8 @@ namespace Magnum { namespace DebugTools {
See @ref ObjectRenderer documentation for more information.
@note This class is available only if Magnum is compiled with
@ref MAGNUM_TARGET_GL "TARGET_GL" and `WITH_SCENEGRAPH` enabled (done by
default). See @ref building-features for more information.
@ref MAGNUM_TARGET_GL "TARGET_GL" and `MAGNUM_WITH_SCENEGRAPH` enabled
(done by default). See @ref building-features for more information.
*/
class ObjectRendererOptions {
public:
@ -85,8 +85,8 @@ Example code:
@snippet MagnumDebugTools-gl.cpp ObjectRenderer
@note This class is available only if Magnum is compiled with
@ref MAGNUM_TARGET_GL "TARGET_GL" and `WITH_SCENEGRAPH` enabled (done by
default). See @ref building-features for more information.
@ref MAGNUM_TARGET_GL "TARGET_GL" and `MAGNUM_WITH_SCENEGRAPH` enabled
(done by default). See @ref building-features for more information.
@see @ref ObjectRenderer2D, @ref ObjectRenderer3D, @ref ObjectRendererOptions
*/

70
src/Magnum/DebugTools/Test/CMakeLists.txt

@ -30,7 +30,7 @@ set(CMAKE_FOLDER "Magnum/DebugTools/Test")
corrade_add_test(DebugToolsFrameProfilerTest FrameProfilerTest.cpp
LIBRARIES MagnumDebugToolsTestLib)
if(WITH_TRADE)
if(MAGNUM_WITH_TRADE)
# Otherwise CMake complains that Corrade::PluginManager is not found, wtf
find_package(Corrade REQUIRED PluginManager)
@ -49,17 +49,17 @@ if(WITH_TRADE)
# Corrade doesn't support dynamic plugins on iOS, this sorta works around
# that. Should be revisited when updating Travis to newer Xcode (xcode7.3
# has CMake 3.6).
if(NOT BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(NOT MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
set(ANYIMAGEIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:AnyImageImporter>)
endif()
if(WITH_ANYIMAGECONVERTER)
if(MAGNUM_WITH_ANYIMAGECONVERTER)
set(ANYIMAGECONVERTER_PLUGIN_FILENAME $<TARGET_FILE:AnyImageConverter>)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
set(TGAIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImporter>)
endif()
if(WITH_TGAIMAGECONVERTER)
if(MAGNUM_WITH_TGAIMAGECONVERTER)
set(TGAIMAGECONVERTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImageConverter>)
endif()
endif()
@ -77,42 +77,42 @@ if(WITH_TRADE)
CompareImageExpected.tga
CompareImageCompressed.dds)
target_include_directories(DebugToolsCompareImageTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGECONVERTER)
if(MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGECONVERTER)
target_link_libraries(DebugToolsCompareImageTest PRIVATE AnyImageConverter)
endif()
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
target_link_libraries(DebugToolsCompareImageTest PRIVATE AnyImageImporter)
endif()
if(WITH_TGAIMAGECONVERTER)
if(MAGNUM_WITH_TGAIMAGECONVERTER)
target_link_libraries(DebugToolsCompareImageTest PRIVATE TgaImageConverter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(DebugToolsCompareImageTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
if(WITH_ANYIMAGECONVERTER)
if(MAGNUM_WITH_ANYIMAGECONVERTER)
add_dependencies(DebugToolsCompareImageTest AnyImageConverter)
endif()
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
add_dependencies(DebugToolsCompareImageTest AnyImageImporter)
endif()
if(WITH_TGAIMAGECONVERTER)
if(MAGNUM_WITH_TGAIMAGECONVERTER)
add_dependencies(DebugToolsCompareImageTest TgaImageConverter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(DebugToolsCompareImageTest TgaImporter)
endif()
endif()
endif()
if(TARGET_GL)
if(WITH_SCENEGRAPH)
if(MAGNUM_TARGET_GL)
if(MAGNUM_WITH_SCENEGRAPH)
corrade_add_test(DebugToolsForceRendererTest ForceRendererTest.cpp LIBRARIES MagnumMathTestLib)
endif()
if(BUILD_GL_TESTS)
if(MAGNUM_BUILD_GL_TESTS)
corrade_add_test(DebugToolsFrameProfilerGLTest FrameProfilerGLTest.cpp
LIBRARIES MagnumDebugTools MagnumOpenGLTester)
corrade_add_test(DebugToolsTextureImageGLTest TextureImageGLTest.cpp
@ -123,41 +123,41 @@ if(TARGET_GL)
LIBRARIES MagnumDebugTools MagnumOpenGLTester)
endif()
if(WITH_TRADE)
if(MAGNUM_WITH_TRADE)
corrade_add_test(DebugToolsScreenshotGLTest ScreenshotGLTest.cpp LIBRARIES MagnumDebugTools MagnumOpenGLTester)
# The configure.h file is provided for DebugToolsCompareImageTest
# already
target_include_directories(DebugToolsScreenshotGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGECONVERTER)
if(MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGECONVERTER)
target_link_libraries(DebugToolsScreenshotGLTest PRIVATE AnyImageConverter)
endif()
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
target_link_libraries(DebugToolsScreenshotGLTest PRIVATE AnyImageImporter)
endif()
if(WITH_TGAIMAGECONVERTER)
if(MAGNUM_WITH_TGAIMAGECONVERTER)
target_link_libraries(DebugToolsScreenshotGLTest PRIVATE TgaImageConverter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(DebugToolsScreenshotGLTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
if(WITH_ANYIMAGECONVERTER)
if(MAGNUM_WITH_ANYIMAGECONVERTER)
add_dependencies(DebugToolsScreenshotGLTest AnyImageConverter)
endif()
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
add_dependencies(DebugToolsScreenshotGLTest AnyImageImporter)
endif()
if(WITH_TGAIMAGECONVERTER)
if(MAGNUM_WITH_TGAIMAGECONVERTER)
add_dependencies(DebugToolsScreenshotGLTest TgaImageConverter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(DebugToolsScreenshotGLTest TgaImporter)
endif()
endif()
if(CORRADE_BUILD_STATIC AND NOT BUILD_PLUGINS_STATIC)
if(CORRADE_BUILD_STATIC AND NOT MAGNUM_BUILD_PLUGINS_STATIC)
# CMake < 3.4 does this implicitly, but 3.4+ not anymore (see
# CMP0065). That's generally okay, *except if* the build is
# static, the executable uses a plugin manager and needs to
@ -167,7 +167,7 @@ if(TARGET_GL)
endif()
endif()
if(WITH_SCENEGRAPH AND WITH_TRADE)
if(MAGNUM_WITH_SCENEGRAPH AND MAGNUM_WITH_TRADE)
corrade_add_test(DebugToolsForceRendererGLTest ForceRendererGLTest.cpp
LIBRARIES MagnumDebugTools MagnumOpenGLTester
FILES ForceRenderer2D.tga ForceRenderer3D.tga)
@ -176,22 +176,22 @@ if(TARGET_GL)
FILES ObjectRenderer2D.tga ObjectRenderer3D.tga)
target_include_directories(DebugToolsForceRendererGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
target_include_directories(DebugToolsObjectRendererGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
target_link_libraries(DebugToolsForceRendererGLTest PRIVATE AnyImageImporter)
target_link_libraries(DebugToolsObjectRendererGLTest PRIVATE AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(DebugToolsForceRendererGLTest PRIVATE TgaImporter)
target_link_libraries(DebugToolsObjectRendererGLTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
add_dependencies(DebugToolsForceRendererGLTest AnyImageImporter)
add_dependencies(DebugToolsObjectRendererGLTest AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(DebugToolsForceRendererGLTest TgaImporter)
add_dependencies(DebugToolsObjectRendererGLTest TgaImporter)
endif()

38
src/Magnum/GL/CMakeLists.txt

@ -112,7 +112,7 @@ set(MagnumGL_PRIVATE_HEADERS
Implementation/TextureState.h)
# Desktop-only stuff
if(NOT TARGET_GLES)
if(NOT MAGNUM_TARGET_GLES)
list(APPEND MagnumGL_SRCS
PipelineStatisticsQuery.cpp
RectangleTexture.cpp)
@ -122,7 +122,7 @@ if(NOT TARGET_GLES)
endif()
# OpenGL ES 3.0 and WebGL 2.0 stuff
if(NOT TARGET_GLES2)
if(NOT MAGNUM_TARGET_GLES2)
list(APPEND MagnumGL_SRCS
PrimitiveQuery.cpp
TextureArray.cpp
@ -144,7 +144,7 @@ if(NOT TARGET_GLES2)
endif()
# Desktop and OpenGL ES stuff that is not available in WebGL
if(NOT TARGET_WEBGL)
if(NOT MAGNUM_TARGET_WEBGL)
list(APPEND MagnumGL_SRCS
DebugOutput.cpp
@ -157,7 +157,7 @@ if(NOT TARGET_WEBGL)
Implementation/DebugState.h)
# Desktop and OpenGL ES 3.0 stuff that is not available in ES2 and WebGL
if(NOT TARGET_GLES2)
if(NOT MAGNUM_TARGET_GLES2)
list(APPEND MagnumGL_SRCS
BufferTexture.cpp
CubeMapTextureArray.cpp
@ -172,7 +172,7 @@ if(NOT TARGET_WEBGL)
endif()
# Desktop, OpenGL ES and WebGL 2.0 stuff that is not available in WebGL 1.0
if(NOT (TARGET_WEBGL AND TARGET_GLES2))
if(NOT (MAGNUM_TARGET_WEBGL AND MAGNUM_TARGET_GLES2))
list(APPEND MagnumGL_SRCS
SampleQuery.cpp)
list(APPEND MagnumGL_HEADERS
@ -189,10 +189,10 @@ add_library(MagnumGLObjects OBJECT
# where only our headers will be used
target_include_directories(MagnumGLObjects PUBLIC
$<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumGLObjects PRIVATE "MagnumGLObjects_EXPORTS" "FlextGL_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumGLObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
@ -207,14 +207,14 @@ add_library(MagnumGL ${SHARED_OR_STATIC}
${MagnumGL_FlextGL_SRCS}
${MagnumGL_GracefulAssert_SRCS})
set_target_properties(MagnumGL PROPERTIES DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumGL PRIVATE "FlextGL_EXPORTS")
set_target_properties(MagnumGL PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION})
elseif(BUILD_STATIC_PIC)
elseif(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumGL PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumGL PUBLIC Magnum)
if(NOT TARGET_GLES OR TARGET_DESKTOP_GLES)
if(NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES)
# If the GLVND library (CMake 3.11+) was found, link to the imported
# target. Otherwise (and also on all systems except Linux) link to the
# classic libGL. Can't use OpenGL_OpenGL_FOUND, because that one is set
@ -226,7 +226,7 @@ if(NOT TARGET_GLES OR TARGET_DESKTOP_GLES)
else()
target_link_libraries(MagnumGL PUBLIC ${OPENGL_gl_LIBRARY})
endif()
elseif(TARGET_GLES2)
elseif(MAGNUM_TARGET_GLES2)
target_link_libraries(MagnumGL PUBLIC OpenGLES2::OpenGLES2)
else()
target_link_libraries(MagnumGL PUBLIC OpenGLES3::OpenGLES3)
@ -239,9 +239,9 @@ install(TARGETS MagnumGL
install(FILES ${MagnumGL_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/GL)
# OpenGLTester class
if(WITH_OPENGLTESTER)
if(NOT TARGET_GL)
message(SEND_ERROR "OpenGLTester is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_OPENGLTESTER)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "OpenGLTester is available only if MAGNUM_TARGET_GL is enabled")
endif()
find_package(Corrade REQUIRED TestSuite)
@ -283,7 +283,7 @@ if(WITH_OPENGLTESTER)
add_library(Magnum::OpenGLTester ALIAS MagnumOpenGLTester)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
# Library with graceful assert for testing
add_library(MagnumGLTestLib ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumGLObjects>
@ -292,12 +292,12 @@ if(BUILD_TESTS)
set_target_properties(MagnumGLTestLib PROPERTIES DEBUG_POSTFIX "-d")
target_compile_definitions(MagnumGLTestLib PRIVATE
"CORRADE_GRACEFUL_ASSERT" "MagnumGL_EXPORTS" "FlextGL_EXPORTS")
if(BUILD_STATIC_PIC)
if(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumGLTestLib PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumGLTestLib PUBLIC
Magnum)
if(NOT TARGET_GLES OR TARGET_DESKTOP_GLES)
if(NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES)
# If the GLVND library (CMake 3.11+) was found, link to the imported
# target. Otherwise (and also on all systems except Linux) link to the
# classic libGL. Can't use OpenGL_OpenGL_FOUND, because that one is set
@ -309,13 +309,13 @@ if(BUILD_TESTS)
else()
target_link_libraries(MagnumGLTestLib PUBLIC ${OPENGL_gl_LIBRARY})
endif()
elseif(TARGET_GLES2)
elseif(MAGNUM_TARGET_GLES2)
target_link_libraries(MagnumGLTestLib PUBLIC OpenGLES2::OpenGLES2)
else()
target_link_libraries(MagnumGLTestLib PUBLIC OpenGLES3::OpenGLES3)
endif()
if(BUILD_GL_TESTS)
if(MAGNUM_BUILD_GL_TESTS)
add_library(MagnumOpenGLTesterTestLib STATIC
$<TARGET_OBJECTS:MagnumOpenGLTesterObjects>
${PROJECT_SOURCE_DIR}/src/dummy.cpp) # XCode workaround, see file comment for details

6
src/Magnum/GL/Extensions.h

@ -62,9 +62,9 @@ but these structs are better suited for compile-time decisions rather than
@ref Extension instances. See @ref Context::isExtensionSupported() for example
usage.
This library is built if `WITH_GL` is enabled when building Magnum. To use this
library with CMake, request the `GL` component of the `Magnum` package and link
to the `Magnum::GL` target:
This library is built if `MAGNUM_WITH_GL` is enabled when building Magnum. To
use this library with CMake, request the `GL` component of the `Magnum` package
and link to the `Magnum::GL` target:
@code{.cmake}
find_package(Magnum REQUIRED GL)

6
src/Magnum/GL/OpenGLTester.h

@ -71,8 +71,8 @@ the base features.
This class is available on platforms with corresponding
`Platform::Windowless*Application` implementation, which currently means all
platforms. It is built into a separate static library and only if
`WITH_OPENGLTESTER` is enabled when building Magnum. To use it with CMake,
request the `OpenGLTester` component of the `Magnum` package. Derive
`MAGNUM_WITH_OPENGLTESTER` is enabled when building Magnum. To use it with
CMake, request the `OpenGLTester` component of the `Magnum` package. Derive
your test class from this class instead of @ref Corrade::TestSuite::Tester and
either link to `Magnum::OpenGLTester` target or add it to the `LIBRARIES`
section of the @ref corrade-cmake-add-test "corrade_add_test()" macro:
@ -88,7 +88,7 @@ Additionally, if you're using Magnum as a CMake subproject, ensure it's enabled
as it's not built by default:
@code{.cmake}
set(WITH_OPENGLTESTER ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_OPENGLTESTER ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

18
src/Magnum/GL/Test/CMakeLists.txt

@ -70,7 +70,7 @@ if(NOT MAGNUM_TARGET_GLES)
corrade_add_test(GLRectangleTextureTest RectangleTextureTest.cpp LIBRARIES MagnumGL)
endif()
if(BUILD_GL_TESTS)
if(MAGNUM_BUILD_GL_TESTS)
# Otherwise CMake complains that Corrade::PluginManager is not found, wtf
find_package(Corrade REQUIRED PluginManager)
@ -109,11 +109,11 @@ if(BUILD_GL_TESTS)
# Corrade doesn't support dynamic plugins on iOS, this sorta works around
# that. Should be revisited when updating Travis to newer Xcode (xcode7.3
# has CMake 3.6).
if(NOT BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(NOT MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
set(ANYIMAGEIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:AnyImageImporter>)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
set(TGAIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImporter>)
endif()
endif()
@ -128,19 +128,19 @@ if(BUILD_GL_TESTS)
LIBRARIES MagnumOpenGLTester MagnumDebugTools
FILES RendererGLTestFiles/pointcoord.tga)
target_include_directories(GLRendererGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
target_link_libraries(GLRendererGLTest PRIVATE AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(GLRendererGLTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
add_dependencies(GLRendererGLTest AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(GLRendererGLTest TgaImporter)
endif()
endif()

2
src/Magnum/Math/Algorithms/CMakeLists.txt

@ -39,6 +39,6 @@ add_custom_target(MagnumMathAlgorithms SOURCES ${MagnumMathAlgorithms_HEADERS})
install(FILES ${MagnumMathAlgorithms_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/Math/Algorithms)
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

2
src/Magnum/Math/CMakeLists.txt

@ -76,6 +76,6 @@ install(FILES ${MagnumMath_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/Ma
add_subdirectory(Algorithms)
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

22
src/Magnum/MeshTools/CMakeLists.txt

@ -70,7 +70,7 @@ set(MagnumMeshTools_HEADERS
set(MagnumMeshTools_INTERNAL_HEADERS
Implementation/Tipsify.h)
if(BUILD_DEPRECATED)
if(MAGNUM_BUILD_DEPRECATED)
list(APPEND MagnumMeshTools_GracefulAssert_SRCS
CombineIndexedArrays.cpp)
list(APPEND MagnumMeshTools_HEADERS
@ -78,7 +78,7 @@ if(BUILD_DEPRECATED)
GenerateFlatNormals.h)
endif()
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
list(APPEND MagnumMeshTools_SRCS
FullScreenTriangle.cpp)
@ -96,13 +96,13 @@ add_library(MagnumMeshToolsObjects OBJECT
${MagnumMeshTools_HEADERS}
${MagnumMeshTools_INTERNAL_HEADERS})
target_include_directories(MagnumMeshToolsObjects PUBLIC $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumMeshToolsObjects PRIVATE "MagnumMeshToolsObjects_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumMeshToolsObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
target_include_directories(MagnumMeshToolsObjects PUBLIC $<TARGET_PROPERTY:MagnumGL,INTERFACE_INCLUDE_DIRECTORIES>)
endif()
@ -111,14 +111,14 @@ add_library(MagnumMeshTools ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumMeshToolsObjects>
${MagnumMeshTools_GracefulAssert_SRCS})
set_target_properties(MagnumMeshTools PROPERTIES DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
set_target_properties(MagnumMeshTools PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION})
elseif(BUILD_STATIC_PIC)
elseif(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumMeshTools PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumMeshTools PUBLIC
Magnum MagnumTrade)
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
target_link_libraries(MagnumMeshTools PUBLIC MagnumGL)
endif()
@ -128,7 +128,7 @@ install(TARGETS MagnumMeshTools
ARCHIVE DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR})
install(FILES ${MagnumMeshTools_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/MeshTools)
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
# Library with graceful assert for testing
add_library(MagnumMeshToolsTestLib ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumMeshToolsObjects>
@ -136,12 +136,12 @@ if(BUILD_TESTS)
set_target_properties(MagnumMeshToolsTestLib PROPERTIES DEBUG_POSTFIX "-d")
target_compile_definitions(MagnumMeshToolsTestLib PRIVATE
"CORRADE_GRACEFUL_ASSERT" "MagnumMeshTools_EXPORTS")
if(BUILD_STATIC_PIC)
if(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumMeshToolsTestLib PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumMeshToolsTestLib PUBLIC
Magnum MagnumTrade)
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
target_link_libraries(MagnumMeshToolsTestLib PUBLIC MagnumGL)
endif()

20
src/Magnum/MeshTools/Test/CMakeLists.txt

@ -52,14 +52,14 @@ set_property(TARGET
MeshToolsSubdivideTest
APPEND PROPERTY COMPILE_DEFINITIONS "CORRADE_GRACEFUL_ASSERT")
if(BUILD_DEPRECATED)
if(MAGNUM_BUILD_DEPRECATED)
corrade_add_test(MeshToolsCombineIndexedArraysTest CombineIndexedArraysTest.cpp LIBRARIES MagnumMeshToolsTestLib)
set_property(TARGET
MeshToolsCombineIndexedArraysTest
APPEND PROPERTY COMPILE_DEFINITIONS "CORRADE_GRACEFUL_ASSERT")
endif()
if(BUILD_GL_TESTS)
if(MAGNUM_BUILD_GL_TESTS)
# Otherwise CMake complains that Corrade::PluginManager is not found
find_package(Corrade REQUIRED PluginManager)
@ -80,11 +80,11 @@ if(BUILD_GL_TESTS)
# Corrade doesn't support dynamic plugins on iOS, this sorta works around
# that. Should be revisited when updating Travis to newer Xcode (xcode7.3
# has CMake 3.6).
if(NOT BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(NOT MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
set(ANYIMAGEIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:AnyImageImporter>)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
set(TGAIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImporter>)
endif()
endif()
@ -113,19 +113,19 @@ if(BUILD_GL_TESTS)
CompileTestFiles/textured2D.tga
CompileTestFiles/textured3D.tga)
target_include_directories(MeshToolsCompileGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
target_link_libraries(MeshToolsCompileGLTest PRIVATE AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(MeshToolsCompileGLTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
add_dependencies(MeshToolsCompileGLTest AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(MeshToolsCompileGLTest TgaImporter)
endif()
endif()

7
src/Magnum/Platform/AndroidApplication.h

@ -88,8 +88,9 @@ together with a troubleshooting guide is available in @ref platforms-android.
@section Platform-AndroidApplication-usage General usage
This application library is built if `WITH_ANDROIDAPPLICATION` is enabled when
building Magnum. To use this library with CMake, put [FindEGL.cmake](https://github.com/mosra/magnum/blob/master/modules/FindEGL.cmake)
This application library is built if `MAGNUM_WITH_ANDROIDAPPLICATION` is
enabled when building Magnum. To use this library with CMake, put
[FindEGL.cmake](https://github.com/mosra/magnum/blob/master/modules/FindEGL.cmake)
and [FindOpenGLES2.cmake](https://github.com/mosra/magnum/blob/master/modules/FindOpenGLES2.cmake) (or
[FindOpenGLES3.cmake](https://github.com/mosra/magnum/blob/master/modules/FindOpenGLES3.cmake))
into your `modules/` directory, request the `AndroidApplication` component of
@ -112,7 +113,7 @@ Additionally, if you're using Magnum as a CMake subproject, do the following
library is not built by default:
@code{.cmake}
set(WITH_ANDROIDAPPLICATION ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_ANDROIDAPPLICATION ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

174
src/Magnum/Platform/CMakeLists.txt

@ -42,7 +42,7 @@ set(MagnumPlatform_PRIVATE_HEADERS )
# DPI scaling queries and related stuff for EmscriptenApplication,
# Sdl2Application and GlfwApplication
if(WITH_EMSCRIPTENAPPLICATION OR WITH_GLFWAPPLICATION OR WITH_SDL2APPLICATION)
if(MAGNUM_WITH_EMSCRIPTENAPPLICATION OR MAGNUM_WITH_GLFWAPPLICATION OR MAGNUM_WITH_SDL2APPLICATION)
# List of libraries to link when using the MagnumPlatformObjects target
# TODO: use target_link_libraries() when we are on a CMake version that
# supports it (3.12?)
@ -64,7 +64,7 @@ if(WITH_EMSCRIPTENAPPLICATION OR WITH_GLFWAPPLICATION OR WITH_SDL2APPLICATION)
${MagnumPlatform_HEADERS}
${MagnumPlatform_PRIVATE_HEADERS})
target_include_directories(MagnumPlatformObjects PUBLIC $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumPlatformObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
@ -95,9 +95,9 @@ set(MagnumPlatform_FILES )
install(FILES ${MagnumPlatform_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/Platform)
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
# Decide about platform-specific context for cross-platform toolkits
if(WITH_GLFWAPPLICATION OR WITH_SDL2APPLICATION)
if(MAGNUM_WITH_GLFWAPPLICATION OR MAGNUM_WITH_SDL2APPLICATION)
if(CORRADE_TARGET_APPLE AND NOT MAGNUM_TARGET_GLES)
set(NEED_CGLCONTEXT 1)
set(MagnumSomeContext_OBJECTS $<TARGET_OBJECTS:MagnumCglContextObjects>)
@ -115,7 +115,7 @@ if(TARGET_GL)
endif()
# This is needed also by [Windowless]GlxApplication
if((WITH_GLXAPPLICATION OR WITH_WINDOWLESSGLXAPPLICATION OR WITH_GLFWAPPLICATION OR WITH_SDL2APPLICATION) AND CORRADE_TARGET_UNIX AND (NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES))
if((MAGNUM_WITH_GLXAPPLICATION OR MAGNUM_WITH_WINDOWLESSGLXAPPLICATION OR MAGNUM_WITH_GLFWAPPLICATION OR MAGNUM_WITH_SDL2APPLICATION) AND CORRADE_TARGET_UNIX AND (NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES))
# If the GLVND library (CMake 3.11+) was found and linked to, we need
# to link to GLX explicitly. Otherwise (and also on all systems except
# Linux) the transitive dependency to classic GL lib from MagnumGL is
@ -130,9 +130,9 @@ if(TARGET_GL)
endif()
# Android application
if(WITH_ANDROIDAPPLICATION)
if(MAGNUM_WITH_ANDROIDAPPLICATION)
if(NOT ${CMAKE_SYSTEM_NAME} STREQUAL Android)
message(FATAL_ERROR "AndroidApplication is available only when targeting Android. Set WITH_ANDROIDAPPLICATION to OFF to skip building it.")
message(FATAL_ERROR "AndroidApplication is available only when targeting Android. Set MAGNUM_WITH_ANDROIDAPPLICATION to OFF to skip building it.")
endif()
find_package(EGL REQUIRED)
@ -180,9 +180,9 @@ if(WITH_ANDROIDAPPLICATION)
endif()
# Emscripten application
if(WITH_EMSCRIPTENAPPLICATION)
if(MAGNUM_WITH_EMSCRIPTENAPPLICATION)
if(NOT CORRADE_TARGET_EMSCRIPTEN)
message(FATAL_ERROR "EmscriptenApplication is available only when targeting Emscripten. Set WITH_EMSCRIPTENAPPLICATION to OFF to skip building it.")
message(FATAL_ERROR "EmscriptenApplication is available only when targeting Emscripten. Set MAGNUM_WITH_EMSCRIPTENAPPLICATION to OFF to skip building it.")
endif()
set(MagnumEmscriptenApplication_SRCS
@ -203,7 +203,7 @@ if(WITH_EMSCRIPTENAPPLICATION)
${MagnumPlatform_LINK_LIBRARIES})
target_compile_definitions(MagnumEmscriptenApplication PRIVATE
${MagnumPlatform_COMPILE_DEFINITIONS})
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
target_link_libraries(MagnumEmscriptenApplication PUBLIC MagnumGL)
endif()
@ -218,17 +218,17 @@ if(WITH_EMSCRIPTENAPPLICATION)
endif()
# GLFW application
if(WITH_GLFWAPPLICATION)
if(MAGNUM_WITH_GLFWAPPLICATION)
find_package(GLFW)
if(NOT GLFW_FOUND)
message(FATAL_ERROR "GLFW library, required by GlfwApplication, was not found. Set WITH_GLFWAPPLICATION to OFF to skip building it.")
message(FATAL_ERROR "GLFW library, required by GlfwApplication, was not found. Set MAGNUM_WITH_GLFWAPPLICATION to OFF to skip building it.")
endif()
set(MagnumGlfwApplication_SRCS
$<TARGET_OBJECTS:MagnumPlatformObjects>
GlfwApplication.cpp)
set(MagnumGlfwApplication_HEADERS GlfwApplication.h)
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
list(APPEND MagnumGlfwApplication_SRCS ${MagnumSomeContext_OBJECTS})
endif()
@ -237,7 +237,7 @@ if(WITH_GLFWAPPLICATION)
${MagnumGlfwApplication_HEADERS})
set_target_properties(MagnumGlfwApplication PROPERTIES
DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumGlfwApplication PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
# Assuming that PIC is not needed because the Application lib is always
@ -248,7 +248,7 @@ if(WITH_GLFWAPPLICATION)
${MagnumPlatform_LINK_LIBRARIES})
target_compile_definitions(MagnumGlfwApplication PRIVATE
${MagnumPlatform_COMPILE_DEFINITIONS})
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
target_link_libraries(MagnumGlfwApplication PUBLIC
MagnumGL
# need to link to GLX explicitly if using GLVND (CMake 3.11+)
@ -290,17 +290,17 @@ if(WITH_GLFWAPPLICATION)
endif()
# SDL2 application
if(WITH_SDL2APPLICATION)
if(MAGNUM_WITH_SDL2APPLICATION)
find_package(SDL2)
if(NOT SDL2_FOUND)
message(FATAL_ERROR "SDL2 library, required by Sdl2Application, was not found. Set WITH_SDL2APPLICATION to OFF to skip building it.")
message(FATAL_ERROR "SDL2 library, required by Sdl2Application, was not found. Set MAGNUM_WITH_SDL2APPLICATION to OFF to skip building it.")
endif()
set(MagnumSdl2Application_SRCS
$<TARGET_OBJECTS:MagnumPlatformObjects>
Sdl2Application.cpp)
set(MagnumSdl2Application_HEADERS Sdl2Application.h)
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
list(APPEND MagnumSdl2Application_SRCS ${MagnumSomeContext_OBJECTS})
endif()
@ -309,7 +309,7 @@ if(WITH_SDL2APPLICATION)
${MagnumSdl2Application_HEADERS})
set_target_properties(MagnumSdl2Application PROPERTIES
DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumSdl2Application PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
# Assuming that PIC is not needed because the Application lib is always
@ -320,7 +320,7 @@ if(WITH_SDL2APPLICATION)
${MagnumPlatform_LINK_LIBRARIES})
target_compile_definitions(MagnumSdl2Application PRIVATE
${MagnumPlatform_COMPILE_DEFINITIONS})
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
target_link_libraries(MagnumSdl2Application PUBLIC
MagnumGL
# need to link to GLX explicitly if using GLVND (CMake 3.11+)
@ -374,9 +374,9 @@ if(CORRADE_TARGET_EMSCRIPTEN)
endif()
# GLX application
if(WITH_GLXAPPLICATION)
if(NOT TARGET_GL)
message(SEND_ERROR "GlxApplication is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_GLXAPPLICATION)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "GlxApplication is available only if MAGNUM_TARGET_GL is enabled")
endif()
set(NEED_ABSTRACTXAPPLICATION 1)
@ -385,7 +385,7 @@ if(WITH_GLXAPPLICATION)
find_package(X11)
if(NOT X11_FOUND)
message(FATAL_ERROR "X11 library, required by some applications, was not found. Set WITH_*X*APPLICATION to OFF to skip building them.")
message(FATAL_ERROR "X11 library, required by some applications, was not found. Set MAGNUM_WITH_*X*APPLICATION to OFF to skip building them.")
endif()
set(MagnumGlxApplication_SRCS
@ -420,9 +420,9 @@ if(WITH_GLXAPPLICATION)
endif()
# X/EGL application
if(WITH_XEGLAPPLICATION)
if(NOT TARGET_GL)
message(SEND_ERROR "XEglApplication is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_XEGLAPPLICATION)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "XEglApplication is available only if MAGNUM_TARGET_GL is enabled")
endif()
set(NEED_ABSTRACTXAPPLICATION 1)
@ -430,12 +430,12 @@ if(WITH_XEGLAPPLICATION)
set(NEED_EGLCONTEXT 1)
find_package(EGL)
if(NOT EGL_FOUND)
message(FATAL_ERROR "EGL library, required by some applications, was not found. Set WITH_*EGL*APPLICATION to OFF to skip building them.")
message(FATAL_ERROR "EGL library, required by some applications, was not found. Set MAGNUM_WITH_*EGL*APPLICATION to OFF to skip building them.")
endif()
find_package(X11)
if(NOT X11_FOUND)
message(FATAL_ERROR "X11 library, required by some applications, was not found. Set WITH_*X*APPLICATION to OFF to skip building them.")
message(FATAL_ERROR "X11 library, required by some applications, was not found. Set MAGNUM_WITH_*X*APPLICATION to OFF to skip building them.")
endif()
set(MagnumXEglApplication_SRCS
@ -466,9 +466,9 @@ if(WITH_XEGLAPPLICATION)
endif()
# Windowless EGL application
if(WITH_WINDOWLESSEGLAPPLICATION)
if(NOT TARGET_GL)
message(SEND_ERROR "WindowlessEglApplication is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_WINDOWLESSEGLAPPLICATION)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "WindowlessEglApplication is available only if MAGNUM_TARGET_GL is enabled")
endif()
set(NEED_EGLCONTEXT 1)
@ -488,7 +488,7 @@ if(WITH_WINDOWLESSEGLAPPLICATION)
${MagnumWindowlessEglApplication_PRIVATE_HEADERS})
set_target_properties(MagnumWindowlessEglApplication PROPERTIES
DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumWindowlessEglApplication PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumWindowlessEglApplication PUBLIC MagnumGL EGL::EGL)
@ -504,16 +504,16 @@ if(WITH_WINDOWLESSEGLAPPLICATION)
endif()
# Windowless GLX application
if(WITH_WINDOWLESSGLXAPPLICATION)
if(NOT TARGET_GL)
message(SEND_ERROR "WindowlessGlxApplication is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_WINDOWLESSGLXAPPLICATION)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "WindowlessGlxApplication is available only if MAGNUM_TARGET_GL is enabled")
endif()
set(NEED_GLXCONTEXT 1)
find_package(X11)
if(NOT X11_FOUND)
message(FATAL_ERROR "X11 library, required by some applications, was not found. Set WITH_*X*APPLICATION to OFF to skip building them.")
message(FATAL_ERROR "X11 library, required by some applications, was not found. Set MAGNUM_WITH_*X*APPLICATION to OFF to skip building them.")
endif()
set(MagnumWindowlessGlxApplication_SRCS
@ -528,7 +528,7 @@ if(WITH_WINDOWLESSGLXAPPLICATION)
DEBUG_POSTFIX "-d")
# X11 macros are a mess, disable warnings for C-style casts
target_compile_options(MagnumWindowlessGlxApplication PRIVATE "-Wno-old-style-cast")
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumWindowlessGlxApplication PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_include_directories(MagnumWindowlessGlxApplication PUBLIC ${X11_INCLUDE_DIR})
@ -549,9 +549,9 @@ if(WITH_WINDOWLESSGLXAPPLICATION)
endif()
# Windowless iOS application
if(WITH_WINDOWLESSIOSAPPLICATION)
if(NOT TARGET_GL)
message(SEND_ERROR "WindowlessIosApplication is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_WINDOWLESSIOSAPPLICATION)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "WindowlessIosApplication is available only if MAGNUM_TARGET_GL is enabled")
endif()
set(NEED_EGLCONTEXT 1)
@ -571,7 +571,7 @@ if(WITH_WINDOWLESSIOSAPPLICATION)
${MagnumWindowlessIosApplication_HEADERS})
set_target_properties(MagnumWindowlessIosApplication PROPERTIES
DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumWindowlessIosApplication PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumWindowlessIosApplication
@ -590,9 +590,9 @@ if(WITH_WINDOWLESSIOSAPPLICATION)
endif()
# Windowless WGL application
if(WITH_WINDOWLESSWGLAPPLICATION)
if(NOT TARGET_GL)
message(SEND_ERROR "WindowlessWglApplication is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_WINDOWLESSWGLAPPLICATION)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "WindowlessWglApplication is available only if MAGNUM_TARGET_GL is enabled")
endif()
set(NEED_WGLCONTEXT 1)
@ -608,7 +608,7 @@ if(WITH_WINDOWLESSWGLAPPLICATION)
set_target_properties(MagnumWindowlessWglApplication PROPERTIES
DEBUG_POSTFIX "-d")
target_compile_definitions(MagnumWindowlessWglApplication PRIVATE "UNICODE")
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumWindowlessWglApplication PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumWindowlessWglApplication PUBLIC MagnumGL)
@ -624,9 +624,9 @@ if(WITH_WINDOWLESSWGLAPPLICATION)
endif()
# Windowless Windows/EGL application
if(WITH_WINDOWLESSWINDOWSEGLAPPLICATION)
if(NOT TARGET_GL)
message(SEND_ERROR "WindowlessWindowsEglApplication is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_WINDOWLESSWINDOWSEGLAPPLICATION)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "WindowlessWindowsEglApplication is available only if MAGNUM_TARGET_GL is enabled")
endif()
set(NEED_EGLCONTEXT 1)
@ -646,7 +646,7 @@ if(WITH_WINDOWLESSWINDOWSEGLAPPLICATION)
${MagnumWindowlessWindowsEglApplication_PRIVATE_HEADERS})
set_target_properties(MagnumWindowlessWindowsEglApplication PROPERTIES
DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumWindowlessWindowsEglApplication PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumWindowlessWindowsEglApplication PUBLIC MagnumGL EGL::EGL)
@ -662,12 +662,12 @@ if(WITH_WINDOWLESSWINDOWSEGLAPPLICATION)
endif()
# Windowless CGL application
if(WITH_WINDOWLESSCGLAPPLICATION)
if(NOT TARGET_GL)
message(SEND_ERROR "WindowlessCglApplication is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_WINDOWLESSCGLAPPLICATION)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "WindowlessCglApplication is available only if MAGNUM_TARGET_GL is enabled")
endif()
if(TARGET_GLES)
message(SEND_ERROR "WindowlessCglApplication is not available if TARGET_GLES is enabled")
if(MAGNUM_TARGET_GLES)
message(SEND_ERROR "WindowlessCglApplication is not available if MAGNUM_TARGET_GLES is enabled")
endif()
set(NEED_CGLCONTEXT 1)
@ -682,7 +682,7 @@ if(WITH_WINDOWLESSCGLAPPLICATION)
${MagnumWindowlessCglApplication_HEADERS})
set_target_properties(MagnumWindowlessCglApplication PROPERTIES
DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumWindowlessCglApplication PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumWindowlessCglApplication PUBLIC MagnumGL)
@ -737,7 +737,7 @@ endif()
if(NEED_EGLCONTEXTHANDLER)
find_package(EGL)
if(NOT EGL_FOUND)
message(FATAL_ERROR "EGL library, required by some contexts, was not found. Set WITH_*EGL*APPLICATION to OFF to skip building them.")
message(FATAL_ERROR "EGL library, required by some contexts, was not found. Set MAGNUM_WITH_*EGL*APPLICATION to OFF to skip building them.")
endif()
set(MagnumEglContextHandler_SRCS
@ -787,17 +787,17 @@ elseif(MAGNUM_TARGET_GLES AND NOT MAGNUM_TARGET_GLES2)
endif()
# CGL context
if(NEED_CGLCONTEXT OR WITH_CGLCONTEXT)
if(NEED_CGLCONTEXT OR MAGNUM_WITH_CGLCONTEXT)
add_library(MagnumCglContextObjects OBJECT ${MagnumContext_SRCS})
target_include_directories(MagnumCglContextObjects PUBLIC $<TARGET_PROPERTY:MagnumGL,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumCglContextObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
# Also create proper static library, if requested
if(WITH_CGLCONTEXT)
if(NOT TARGET_GL)
message(SEND_ERROR "CglContext is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_CGLCONTEXT)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "CglContext is available only if MAGNUM_TARGET_GL is enabled")
endif()
add_library(MagnumCglContext STATIC
@ -805,7 +805,7 @@ if(NEED_CGLCONTEXT OR WITH_CGLCONTEXT)
${PROJECT_SOURCE_DIR}/src/dummy.cpp) # XCode workaround, see file comment for details
set_target_properties(MagnumCglContext PROPERTIES
DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumCglContext PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumCglContext PUBLIC MagnumGL)
@ -821,10 +821,10 @@ if(NEED_CGLCONTEXT OR WITH_CGLCONTEXT)
endif()
# EGL context
if(NEED_EGLCONTEXT OR WITH_EGLCONTEXT)
if(NEED_EGLCONTEXT OR MAGNUM_WITH_EGLCONTEXT)
find_package(EGL)
if(NOT EGL_FOUND)
message(FATAL_ERROR "EGL library, required by some contexts, was not found. Set WITH_*APPLICATION and/or WITH_EGLCONTEXT to OFF to skip building them.")
message(FATAL_ERROR "EGL library, required by some contexts, was not found. Set MAGNUM_WITH_*APPLICATION and/or MAGNUM_WITH_EGLCONTEXT to OFF to skip building them.")
endif()
add_library(MagnumEglContextObjects OBJECT ${MagnumContext_SRCS})
@ -832,14 +832,14 @@ if(NEED_EGLCONTEXT OR WITH_EGLCONTEXT)
$<TARGET_PROPERTY:MagnumGL,INTERFACE_INCLUDE_DIRECTORIES>
$<TARGET_PROPERTY:EGL::EGL,INTERFACE_INCLUDE_DIRECTORIES>)
target_compile_definitions(MagnumEglContextObjects PRIVATE "MAGNUM_PLATFORM_USE_EGL")
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumEglContextObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
# Also create proper static library, if requested
if(WITH_EGLCONTEXT)
if(NOT TARGET_GL)
message(SEND_ERROR "EglContext is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_EGLCONTEXT)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "EglContext is available only if MAGNUM_TARGET_GL is enabled")
endif()
add_library(MagnumEglContext STATIC
@ -847,7 +847,7 @@ if(NEED_EGLCONTEXT OR WITH_EGLCONTEXT)
${PROJECT_SOURCE_DIR}/src/dummy.cpp) # XCode workaround, see file comment for details
set_target_properties(MagnumEglContext PROPERTIES
DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumEglContext PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumEglContext PUBLIC MagnumGL EGL::EGL)
@ -863,26 +863,26 @@ if(NEED_EGLCONTEXT OR WITH_EGLCONTEXT)
endif()
# GLX context
if(NEED_GLXCONTEXT OR WITH_GLXCONTEXT)
if(NEED_GLXCONTEXT OR MAGNUM_WITH_GLXCONTEXT)
add_library(MagnumGlxContextObjects OBJECT ${MagnumContext_SRCS})
target_include_directories(MagnumGlxContextObjects PUBLIC
$<TARGET_PROPERTY:MagnumGL,INTERFACE_INCLUDE_DIRECTORIES>
${X11_INCLUDE_DIR})
target_compile_definitions(MagnumGlxContextObjects PRIVATE "MAGNUM_PLATFORM_USE_GLX")
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumGlxContextObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
# Also create proper static library, if requested
if(WITH_GLXCONTEXT)
if(NOT TARGET_GL)
message(SEND_ERROR "GlxContext is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_GLXCONTEXT)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "GlxContext is available only if MAGNUM_TARGET_GL is enabled")
endif()
add_library(MagnumGlxContext STATIC $<TARGET_OBJECTS:MagnumGlxContextObjects>)
set_target_properties(MagnumGlxContext PROPERTIES
DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumGlxContext PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_include_directories(MagnumGlxContext PUBLIC ${X11_INCLUDE_DIR})
@ -902,23 +902,23 @@ if(NEED_GLXCONTEXT OR WITH_GLXCONTEXT)
endif()
# WGL context
if(NEED_WGLCONTEXT OR WITH_WGLCONTEXT)
if(NEED_WGLCONTEXT OR MAGNUM_WITH_WGLCONTEXT)
add_library(MagnumWglContextObjects OBJECT ${MagnumContext_SRCS})
target_include_directories(MagnumWglContextObjects PUBLIC $<TARGET_PROPERTY:MagnumGL,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumWglContextObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
# Also create proper static library, if requested
if(WITH_WGLCONTEXT)
if(NOT TARGET_GL)
message(SEND_ERROR "WglContext is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_WGLCONTEXT)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "WglContext is available only if MAGNUM_TARGET_GL is enabled")
endif()
add_library(MagnumWglContext STATIC $<TARGET_OBJECTS:MagnumWglContextObjects>)
set_target_properties(MagnumWglContext PROPERTIES
DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumWglContext PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumWglContext PUBLIC MagnumGL)
@ -934,9 +934,9 @@ if(NEED_WGLCONTEXT OR WITH_WGLCONTEXT)
endif()
# Magnum GL Info
if(WITH_GL_INFO)
if(NOT TARGET_GL)
message(SEND_ERROR "magnum-gl-info is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_GL_INFO)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "magnum-gl-info is available only if MAGNUM_TARGET_GL is enabled")
endif()
add_executable(magnum-gl-info gl-info.cpp)
@ -960,7 +960,7 @@ if(WITH_GL_INFO)
target_link_libraries(magnum-gl-info PRIVATE MagnumWindowlessWglApplication)
endif()
else()
message(FATAL_ERROR "magnum-gl-info is not available on this platform. Set WITH_GL_INFO to OFF to skip building it.")
message(FATAL_ERROR "magnum-gl-info is not available on this platform. Set MAGNUM_WITH_GL_INFO to OFF to skip building it.")
endif()
if(NOT CORRADE_TARGET_EMSCRIPTEN)
@ -1000,6 +1000,6 @@ endif()
# Force IDEs display also all header files and additional files in project view
add_custom_target(MagnumPlatform SOURCES ${MagnumPlatform_HEADERS} ${MagnumPlatform_FILES})
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

6
src/Magnum/Platform/EmscriptenApplication.h

@ -120,8 +120,8 @@ together with a troubleshooting guide is available in @ref platforms-html5.
@section Platform-EmscriptenApplication-usage General usage
This application library is built if `WITH_EMSCRIPTENAPPLICATION` is enabled
when building Magnum. To use this library with CMake, put
This application library is built if `MAGNUM_WITH_EMSCRIPTENAPPLICATION` is
enabled when building Magnum. To use this library with CMake, put
[FindOpenGLES2.cmake](https://github.com/mosra/magnum/blob/master/modules/FindOpenGLES2.cmake) (or
[FindOpenGLES3.cmake](https://github.com/mosra/magnum/blob/master/modules/FindOpenGLES3.cmake))
into your `modules/` directory, request the `EmscriptenApplication` component
@ -144,7 +144,7 @@ Additionally, if you're using Magnum as a CMake subproject, do the following
library is not built by default:
@code{.cmake}
set(WITH_EMSCRIPTENAPPLICATION ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_EMSCRIPTENAPPLICATION ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

6
src/Magnum/Platform/GlfwApplication.h

@ -99,8 +99,8 @@ See @ref cmake for more information.
@section Platform-GlfwApplication-usage General usage
This application library depends on the [GLFW](http://glfw.org) library and is
built if `WITH_GLFWAPPLICATION` is enabled when building Magnum. To use this
library with CMake, put
built if `MAGNUM_WITH_GLFWAPPLICATION` is enabled when building Magnum. To use
this library with CMake, put
[FindGLFW.cmake](https://github.com/mosra/magnum/blob/master/modules/FindGLFW.cmake)
into your `modules/` directory, request the `GlfwApplication` component of the
`Magnum` package and link to the `Magnum::GlfwApplication` target:
@ -126,7 +126,7 @@ set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
add_subdirectory(glfw EXCLUDE_FROM_ALL)
set(WITH_GLFWAPPLICATION ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_GLFWAPPLICATION ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

8
src/Magnum/Platform/GlxApplication.h

@ -54,9 +54,9 @@ more information.
@section Platform-GlxApplication-usage General usage
This application library depends on the **X11** library and is built if `WITH_GLXAPPLICATION` is enabled when building Magnum. To use this library from
CMake, request the `GlxApplication` component of the `Magnum` package and link
to the `Magnum::GlxApplication` target:
This application library depends on the **X11** library and is built if `MAGNUM_WITH_GLXAPPLICATION` is enabled when building Magnum. To use this
library with CMake, request the `GlxApplication` component of the `Magnum`
package and link to the `Magnum::GlxApplication` target:
@code{.cmake}
find_package(Magnum REQUIRED GlxApplication)
@ -70,7 +70,7 @@ Additionally, if you're using Magnum as a CMake subproject, do the following
library is not built by default:
@code{.cmake}
set(WITH_GLXAPPLICATION ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_GLXAPPLICATION ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

6
src/Magnum/Platform/Sdl2Application.h

@ -209,8 +209,8 @@ final package along with a PowerShell script for easy local installation.
@section Platform-Sdl2Application-usage General usage
This application library depends on the [SDL2](http://www.libsdl.org) library
(Emscripten has it built in) and is built if `WITH_SDL2APPLICATION` is enabled
when building Magnum. To use this library with CMake, put
(Emscripten has it built in) and is built if `MAGNUM_WITH_SDL2APPLICATION` is
enabled when building Magnum. To use this library with CMake, put
[FindSDL2.cmake](https://github.com/mosra/magnum/blob/master/modules/FindSDL2.cmake)
into your `modules/` directory, request the `Sdl2Application` component of
the `Magnum` package and link to the `Magnum::Sdl2Application` target:
@ -252,7 +252,7 @@ set(SDL_THREADS OFF CACHE BOOL "" FORCE)
set(SDL_SHARED OFF CACHE BOOL "" FORCE)
add_subdirectory(SDL EXCLUDE_FROM_ALL)
set(WITH_SDL2APPLICATION ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_SDL2APPLICATION ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

26
src/Magnum/Platform/Test/CMakeLists.txt

@ -31,11 +31,11 @@ set(CMAKE_FOLDER "Magnum/Platform/Test")
find_package(Corrade REQUIRED Main)
# Icons for SDL/GLFW
if(NOT CORRADE_TARGET_EMSCRIPTEN AND (WITH_SDL2APPLICATION OR WITH_GLFWAPPLICATION))
if(NOT CORRADE_TARGET_EMSCRIPTEN AND (MAGNUM_WITH_SDL2APPLICATION OR MAGNUM_WITH_GLFWAPPLICATION))
corrade_add_resource(Platform_RESOURCES resources.conf)
endif()
if(WITH_ANDROIDAPPLICATION)
if(MAGNUM_WITH_ANDROIDAPPLICATION)
add_library(PlatformAndroidApplicationTest SHARED AndroidApplicationTest.cpp)
target_link_libraries(PlatformAndroidApplicationTest PRIVATE MagnumAndroidApplication)
if(CMAKE_ANDROID_NDK)
@ -43,7 +43,7 @@ if(WITH_ANDROIDAPPLICATION)
endif()
endif()
if(WITH_EMSCRIPTENAPPLICATION)
if(MAGNUM_WITH_EMSCRIPTENAPPLICATION)
add_executable(PlatformEmscriptenApplicationTest EmscriptenApplicationTest.cpp)
target_link_libraries(PlatformEmscriptenApplicationTest PRIVATE
MagnumEmscriptenApplication MagnumGL
@ -80,7 +80,7 @@ if(WITH_EMSCRIPTENAPPLICATION)
$<TARGET_FILE_DIR:PlatformMultipleEmscriptenApplicationTest>/PlatformMultipleEmscriptenApplicationTest.html)
endif()
if(WITH_GLFWAPPLICATION)
if(MAGNUM_WITH_GLFWAPPLICATION)
add_executable(PlatformGlfwApplicationTest WIN32 GlfwApplicationTest.cpp)
# HiDPi.manifest not needed, as GLFW sets that on its own
target_link_libraries(PlatformGlfwApplicationTest PRIVATE MagnumGlfwApplication Corrade::Main)
@ -96,12 +96,12 @@ if(WITH_GLFWAPPLICATION)
endif()
endif()
if(WITH_GLXAPPLICATION)
if(MAGNUM_WITH_GLXAPPLICATION)
add_executable(PlatformGlxApplicationTest GlxApplicationTest.cpp)
target_link_libraries(PlatformGlxApplicationTest PRIVATE MagnumGlxApplication)
endif()
if(WITH_SDL2APPLICATION)
if(MAGNUM_WITH_SDL2APPLICATION)
add_executable(PlatformSdl2ApplicationTest WIN32 Sdl2ApplicationTest.cpp)
if(CORRADE_TARGET_WINDOWS AND NOT CORRADE_TARGET_WINDOWS_RT)
if(MSVC)
@ -134,17 +134,17 @@ if(WITH_SDL2APPLICATION)
endif()
endif()
if(WITH_XEGLAPPLICATION)
if(MAGNUM_WITH_XEGLAPPLICATION)
add_executable(PlatformXEglApplicationTest XEglApplicationTest.cpp)
target_link_libraries(PlatformXEglApplicationTest PRIVATE MagnumXEglApplication)
endif()
if(WITH_WINDOWLESSCGLAPPLICATION)
if(MAGNUM_WITH_WINDOWLESSCGLAPPLICATION)
add_executable(PlatformWindowlessCglApplicationTest WindowlessCglApplicationTest.cpp)
target_link_libraries(PlatformWindowlessCglApplicationTest PRIVATE MagnumWindowlessCglApplication)
endif()
if(WITH_WINDOWLESSEGLAPPLICATION)
if(MAGNUM_WITH_WINDOWLESSEGLAPPLICATION)
add_executable(PlatformWindowlessEglApplicationTest WindowlessEglApplicationTest.cpp)
target_link_libraries(PlatformWindowlessEglApplicationTest PRIVATE MagnumWindowlessEglApplication)
if(CORRADE_TARGET_EMSCRIPTEN)
@ -159,12 +159,12 @@ if(WITH_WINDOWLESSEGLAPPLICATION)
endif()
endif()
if(WITH_WINDOWLESSGLXAPPLICATION)
if(MAGNUM_WITH_WINDOWLESSGLXAPPLICATION)
add_executable(PlatformWindowlessGlxApplicationTest WindowlessGlxApplicationTest.cpp)
target_link_libraries(PlatformWindowlessGlxApplicationTest PRIVATE MagnumWindowlessGlxApplication)
endif()
if(WITH_WINDOWLESSIOSAPPLICATION)
if(MAGNUM_WITH_WINDOWLESSIOSAPPLICATION)
add_executable(PlatformWindowlessIosApplicationTest WindowlessIosApplicationTest.cpp)
target_link_libraries(PlatformWindowlessIosApplicationTest PRIVATE MagnumWindowlessIosApplication)
set_target_properties(PlatformWindowlessIosApplicationTest PROPERTIES
@ -172,12 +172,12 @@ if(WITH_WINDOWLESSIOSAPPLICATION)
XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED "YES")
endif()
if(WITH_WINDOWLESSWGLAPPLICATION)
if(MAGNUM_WITH_WINDOWLESSWGLAPPLICATION)
add_executable(PlatformWindowlessWglApplicationTest WindowlessWglApplicationTest.cpp)
target_link_libraries(PlatformWindowlessWglApplicationTest PRIVATE MagnumWindowlessWglApplication)
endif()
if(WITH_WINDOWLESSWINDOWSEGLAPPLICATION)
if(MAGNUM_WITH_WINDOWLESSWINDOWSEGLAPPLICATION)
add_executable(PlatformWindowlessWindowsEglApplicationTest WindowlessWindowsEglApplicationTest.cpp)
target_link_libraries(PlatformWindowlessWindowsEglApplicationTest PRIVATE MagnumWindowlessWindowsEglApplication)
endif()

6
src/Magnum/Platform/WindowlessCglApplication.h

@ -312,8 +312,8 @@ See @ref cmake for more information.
@section Platform-WindowlessCglApplication-usage General usage
This application library is built if `WITH_WINDOWLESSCGLAPPLICATION` is enabled
when building Magnum. To use this library from CMake, request the
This application library is built if `MAGNUM_WITH_WINDOWLESSCGLAPPLICATION` is
enabled when building Magnum. To use this library from CMake, request the
`WindowlessCglApplication` component of the `Magnum` package and link to the `Magnum::WindowlessCglApplication` target:
@code{.cmake}
@ -333,7 +333,7 @@ Additionally, if you're using Magnum as a CMake subproject, do the following
library is not built by default:
@code{.cmake}
set(WITH_WINDOWLESSCGLAPPLICATION ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_WINDOWLESSCGLAPPLICATION ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

7
src/Magnum/Platform/WindowlessEglApplication.h

@ -489,8 +489,9 @@ together with a troubleshooting guide is available in @ref platforms-html5.
@section Platform-WindowlessEglApplication-usage General usage
This application library is built if `WITH_WINDOWLESSEGLAPPLICATION` is enabled
when building Magnum. To use this library from CMake, put [FindEGL.cmake](https://github.com/mosra/magnum/blob/master/modules/FindEGL.cmake)
This application library is built if `MAGNUM_WITH_WINDOWLESSEGLAPPLICATION` is
enabled when building Magnum. To use this library from CMake, put
[FindEGL.cmake](https://github.com/mosra/magnum/blob/master/modules/FindEGL.cmake)
into your `modules/` directory, request the `WindowlessEglApplication`
component of the `Magnum` package and link to the
`Magnum::WindowlessEglApplication` target:
@ -507,7 +508,7 @@ Additionally, if you're using Magnum as a CMake subproject, do the following
library is not built by default:
@code{.cmake}
set(WITH_WINDOWLESSEGLAPPLICATION ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_WINDOWLESSEGLAPPLICATION ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

6
src/Magnum/Platform/WindowlessGlxApplication.h

@ -370,8 +370,8 @@ See @ref cmake for more information.
@section Platform-WindowlessGlxApplication-usage General usage
This application library depends on the **X11** library and is built if
`WITH_WINDOWLESSGLXAPPLICATION` is enabled when building Magnum. To use this
library with CMake, you need to request the `WindowlessGlxApplication`
`MAGNUM_WITH_WINDOWLESSGLXAPPLICATION` is enabled when building Magnum. To use
this library from CMake, you need to request the `WindowlessGlxApplication`
component of the `Magnum` package and link to the
`Magnum::WindowlessGlxApplication` target:
@ -392,7 +392,7 @@ Additionally, if you're using Magnum as a CMake subproject, do the following
library is not built by default:
@code{.cmake}
set(WITH_WINDOWLESSGLXAPPLICATION ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_WINDOWLESSGLXAPPLICATION ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

4
src/Magnum/Platform/WindowlessIosApplication.h

@ -276,7 +276,7 @@ See @ref cmake for more information.
@section Platform-WindowlessIosApplication-usage General usage
This application library is built if `WITH_WINDOWLESSIOSAPPLICATION` is
This application library is built if `MAGNUM_WITH_WINDOWLESSIOSAPPLICATION` is
enabled when building Magnum. To use this library from CMake, put [FindEGL.cmake](https://github.com/mosra/magnum/blob/master/modules/FindEGL.cmake)
into your `modules/` directory, request the `WindowlessIosApplication`
component of the `Magnum` package and link to the
@ -299,7 +299,7 @@ Additionally, if you're using Magnum as a CMake subproject, do the following
library is not built by default:
@code{.cmake}
set(WITH_WINDOWLESSIOSAPPLICATION ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_WINDOWLESSIOSAPPLICATION ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

6
src/Magnum/Platform/WindowlessWglApplication.h

@ -355,8 +355,8 @@ See @ref cmake for more information.
@section Platform-WindowlessWglApplication-usage General usage
This application library is built if `WITH_WINDOWLESSWGLAPPLICATION` is enabled
when building Magnum. To use this library from CMake, request the
This application library is built if `MAGNUM_WITH_WINDOWLESSWGLAPPLICATION` is
enabled when building Magnum. To use this library from CMake, request the
`WindowlessWglApplication` component of the `Magnum` package and link to the
`Magnum::WindowlessWglApplication` target:
@ -377,7 +377,7 @@ Additionally, if you're using Magnum as a CMake subproject, do the following
library is not built by default:
@code{.cmake}
set(WITH_WINDOWLESSWGLAPPLICATION ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_WINDOWLESSWGLAPPLICATION ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

7
src/Magnum/Platform/WindowlessWindowsEglApplication.h

@ -330,8 +330,9 @@ See @ref cmake for more information.
@section Platform-WindowlessWindowsEglApplication-usage General usage
This application library is built if `WITH_WINDOWLESSWINDOWSEGLAPPLICATION` is
enabled when building Magnum. To use this library from CMake, put [FindEGL.cmake](https://github.com/mosra/magnum/blob/master/modules/FindEGL.cmake)
This application library is built if `MAGNUM_WITH_WINDOWLESSWINDOWSEGLAPPLICATION`
is enabled when building Magnum. To use this library from CMake, put
[FindEGL.cmake](https://github.com/mosra/magnum/blob/master/modules/FindEGL.cmake)
into your `modules/` directory, request the `WindowlessWindowsEglApplication`
component of the `Magnum` package and link to the
`Magnum::WindowlessWindowsEglApplication` target:
@ -353,7 +354,7 @@ Additionally, if you're using Magnum as a CMake subproject, do the following
library is not built by default:
@code{.cmake}
set(WITH_WINDOWLESSWINDOWSEGLAPPLICATION ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_WINDOWLESSWINDOWSEGLAPPLICATION ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

6
src/Magnum/Platform/XEglApplication.h

@ -56,8 +56,8 @@ more information.
@section Platform-XEglApplication-usage General usage
This application library depends on **X11** and **EGL** libraries and is built
if `WITH_XEGLAPPLICATION` is enabled when building Magnum. To use this library
from CMake, put [FindEGL.cmake](https://github.com/mosra/magnum/blob/master/modules/FindEGL.cmake)
if `MAGNUM_WITH_XEGLAPPLICATION` is enabled when building Magnum. To use this
library from CMake, put [FindEGL.cmake](https://github.com/mosra/magnum/blob/master/modules/FindEGL.cmake)
into your `modules/` directory, request the `XEglApplication` component of the
`Magnum` package and link to the `Magnum::XEglApplication` target:
@ -73,7 +73,7 @@ Additionally, if you're using Magnum as a CMake subproject, do the following
library is not built by default:
@code{.cmake}
set(WITH_XEGLAPPLICATION ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_XEGLAPPLICATION ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
@endcode

8
src/Magnum/Platform/gl-info.cpp

@ -89,10 +89,10 @@ namespace Magnum {
@m_div{m-button m-primary} <a href="https://magnum.graphics/showcase/gl-info/">@m_div{m-big}Live web version @m_enddiv @m_div{m-small} uses WebAssembly & WebGL @m_enddiv </a> @m_enddiv
This utility is built if `WITH_GL_INFO` is enabled when building Magnum. To use
this utility with CMake, you need to request the `gl-info` component of the
`Magnum` package and use the `Magnum::gl-info` target for example in a custom
command:
This utility is built if `MAGNUM_WITH_GL_INFO` is enabled when building Magnum.
To use this utility with CMake, you need to request the `gl-info` component of
the `Magnum` package and use the `Magnum::gl-info` target for example in a
custom command:
@code{.cmake}
find_package(Magnum REQUIRED gl-info)

6
src/Magnum/Primitives/CMakeLists.txt

@ -76,9 +76,9 @@ add_library(MagnumPrimitives ${SHARED_OR_STATIC}
${MagnumPrimitives_PRIVATE_HEADERS})
set_target_properties(MagnumPrimitives PROPERTIES
DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
set_target_properties(MagnumPrimitives PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION})
elseif(BUILD_STATIC_PIC)
elseif(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumPrimitives PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumPrimitives PUBLIC
@ -92,7 +92,7 @@ install(TARGETS MagnumPrimitives
ARCHIVE DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR})
install(FILES ${MagnumPrimitives_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/Primitives)
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

10
src/Magnum/SceneGraph/CMakeLists.txt

@ -80,10 +80,10 @@ add_library(MagnumSceneGraphObjects OBJECT
${MagnumSceneGraph_SRCS}
${MagnumSceneGraph_HEADERS})
target_include_directories(MagnumSceneGraphObjects PUBLIC $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumSceneGraphObjects PRIVATE "MagnumSceneGraphObjects_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumSceneGraphObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
@ -93,9 +93,9 @@ add_library(MagnumSceneGraph ${SHARED_OR_STATIC}
${MagnumSceneGraph_GracefulAssert_SRCS})
set_target_properties(MagnumSceneGraph PROPERTIES
DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
set_target_properties(MagnumSceneGraph PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION})
elseif(BUILD_STATIC_PIC)
elseif(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumSceneGraph PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumSceneGraph Magnum)
@ -106,7 +106,7 @@ install(TARGETS MagnumSceneGraph
ARCHIVE DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR})
install(FILES ${MagnumSceneGraph_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/SceneGraph)
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
# Library with graceful assert for testing
add_library(MagnumSceneGraphTestLib ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumSceneGraphObjects>

14
src/Magnum/SceneTools/CMakeLists.txt

@ -52,10 +52,10 @@ set(MagnumSceneTools_PRIVATE_HEADERS
#${MagnumSceneTools_HEADERS}
#${MagnumSceneTools_PRIVATE_HEADERS})
#target_include_directories(MagnumSceneToolsObjects PUBLIC $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
#if(NOT BUILD_STATIC)
#if(NOT MAGNUM_BUILD_STATIC)
#target_compile_definitions(MagnumSceneToolsObjects PRIVATE "MagnumSceneToolsObjects_EXPORTS")
#endif()
#if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
#if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
#set_target_properties(MagnumSceneToolsObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
#endif()
@ -66,9 +66,9 @@ add_library(MagnumSceneTools ${SHARED_OR_STATIC}
${MagnumSceneTools_HEADERS}
${MagnumSceneTools_PRIVATE_HEADERS})
set_target_properties(MagnumSceneTools PROPERTIES DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
set_target_properties(MagnumSceneTools PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION})
elseif(BUILD_STATIC_PIC)
elseif(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumSceneTools PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumSceneTools PUBLIC
@ -81,7 +81,7 @@ install(TARGETS MagnumSceneTools
ARCHIVE DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR})
install(FILES ${MagnumSceneTools_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/SceneTools)
if(WITH_SCENECONVERTER)
if(MAGNUM_WITH_SCENECONVERTER)
add_executable(magnum-sceneconverter sceneconverter.cpp)
target_link_libraries(magnum-sceneconverter PRIVATE
Magnum
@ -95,7 +95,7 @@ if(WITH_SCENECONVERTER)
add_executable(Magnum::sceneconverter ALIAS magnum-sceneconverter)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
# Library with graceful assert for testing
add_library(MagnumSceneToolsTestLib ${SHARED_OR_STATIC}
#$<TARGET_OBJECTS:MagnumSceneToolsObjects>
@ -103,7 +103,7 @@ if(BUILD_TESTS)
set_target_properties(MagnumSceneToolsTestLib PROPERTIES DEBUG_POSTFIX "-d")
target_compile_definitions(MagnumSceneToolsTestLib PRIVATE
"CORRADE_GRACEFUL_ASSERT" "MagnumSceneTools_EXPORTS")
if(BUILD_STATIC_PIC)
if(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumSceneToolsTestLib PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumSceneToolsTestLib PUBLIC

8
src/Magnum/SceneTools/sceneconverter.cpp

@ -65,10 +65,10 @@ namespace Magnum {
@m_footernavigation
@m_keywords{magnum-sceneconverter sceneconverter}
This utility is built if `WITH_SCENECONVERTER` is enabled when building Magnum.
To use this utility with CMake, you need to request the `sceneconverter`
component of the `Magnum` package and use the `Magnum::sceneconverter` target
for example in a custom command:
This utility is built if `MAGNUM_WITH_SCENECONVERTER` is enabled when building
Magnum. To use this utility with CMake, you need to request the
`sceneconverter` component of the `Magnum` package and use the
`Magnum::sceneconverter` target for example in a custom command:
@code{.cmake}
find_package(Magnum REQUIRED imageconverter)

14
src/Magnum/ShaderTools/CMakeLists.txt

@ -58,10 +58,10 @@ endif()
# ${MagnumShaderTools_HEADERS}
# ${MagnumShaderTools_PRIVATE_HEADERS})
# target_include_directories(MagnumShaderToolsObjects PUBLIC $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
# if(NOT BUILD_STATIC)
# if(NOT MAGNUM_BUILD_STATIC)
# target_compile_definitions(MagnumShaderToolsObjects PRIVATE "MagnumShaderToolsObjects_EXPORTS")
# endif()
# if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
# if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
# set_target_properties(MagnumShaderToolsObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
# endif()
@ -72,9 +72,9 @@ add_library(MagnumShaderTools ${SHARED_OR_STATIC}
${MagnumShaderTools_HEADERS}
${MagnumShaderTools_PRIVATE_HEADERS})
set_target_properties(MagnumShaderTools PROPERTIES DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
set_target_properties(MagnumShaderTools PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION})
elseif(BUILD_STATIC_PIC)
elseif(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumShaderTools PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumShaderTools PUBLIC
@ -87,7 +87,7 @@ install(TARGETS MagnumShaderTools
ARCHIVE DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR})
install(FILES ${MagnumShaderTools_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/ShaderTools)
if(WITH_SHADERCONVERTER)
if(MAGNUM_WITH_SHADERCONVERTER)
add_executable(magnum-shaderconverter shaderconverter.cpp)
target_link_libraries(magnum-shaderconverter PRIVATE
Magnum
@ -99,7 +99,7 @@ if(WITH_SHADERCONVERTER)
add_executable(Magnum::shaderconverter ALIAS magnum-shaderconverter)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
# Library with graceful assert for testing
add_library(MagnumShaderToolsTestLib ${SHARED_OR_STATIC}
# $<TARGET_OBJECTS:MagnumShaderToolsObjects>
@ -107,7 +107,7 @@ if(BUILD_TESTS)
set_target_properties(MagnumShaderToolsTestLib PROPERTIES DEBUG_POSTFIX "-d")
target_compile_definitions(MagnumShaderToolsTestLib PRIVATE
"CORRADE_GRACEFUL_ASSERT" "MagnumShaderTools_EXPORTS")
if(BUILD_STATIC_PIC)
if(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumShaderToolsTestLib PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumShaderToolsTestLib PUBLIC

4
src/Magnum/ShaderTools/shaderconverter.cpp

@ -46,8 +46,8 @@ namespace Magnum {
@m_footernavigation
@m_keywords{magnum-shaderconverter shaderconverter}
This utility is built if `WITH_SHADERCONVERTER` is enabled when building
Magnum. To use this utility with CMake, you need to request the
This utility is built if `MAGNUM_WITH_SHADERCONVERTER` is enabled when
building Magnum. To use this utility with CMake, you need to request the
`shaderconverter` component of the `Magnum` package and use the
`Magnum::shaderconverter` target for example in a custom command:

18
src/Magnum/Shaders/CMakeLists.txt

@ -27,8 +27,8 @@
# property that would have to be set on each target separately.
set(CMAKE_FOLDER "Magnum/Shaders")
if(NOT WITH_GL)
message(SEND_ERROR "Shaders are available only if WITH_GL is enabled")
if(NOT MAGNUM_WITH_GL)
message(SEND_ERROR "Shaders are available only if MAGNUM_WITH_GL is enabled")
endif()
corrade_add_resource(MagnumShaders_RESOURCES_GL resources-gl.conf)
@ -74,7 +74,7 @@ set(MagnumShaders_PRIVATE_HEADERS Implementation/CreateCompatibilityShader.h)
add_library(MagnumShadersObjects OBJECT
${MagnumShaders_SRCS}
${MagnumShaders_HEADERS})
if(BUILD_STATIC)
if(MAGNUM_BUILD_STATIC)
# On the static build we're importing the resources manually, so no need to
# have the implicit initializers as well.
set_property(SOURCE ${MagnumShaders_RCS} APPEND PROPERTY COMPILE_DEFINITIONS
@ -84,10 +84,10 @@ endif()
target_include_directories(MagnumShadersObjects PUBLIC
$<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>
$<TARGET_PROPERTY:MagnumGL,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumShadersObjects PRIVATE "MagnumShadersObjects_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumShadersObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
@ -96,9 +96,9 @@ add_library(MagnumShaders ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumShadersObjects>
${MagnumShaders_GracefulAssert_SRCS})
set_target_properties(MagnumShaders PROPERTIES DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
set_target_properties(MagnumShaders PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION})
elseif(BUILD_STATIC_PIC)
elseif(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumShaders PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumShaders PUBLIC
@ -111,7 +111,7 @@ install(TARGETS MagnumShaders
ARCHIVE DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR})
install(FILES ${MagnumShaders_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/Shaders)
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
# Library with graceful assert for testing
add_library(MagnumShadersTestLib ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumShadersObjects>
@ -119,7 +119,7 @@ if(BUILD_TESTS)
set_target_properties(MagnumShadersTestLib PROPERTIES DEBUG_POSTFIX "-d")
target_compile_definitions(MagnumShadersTestLib PRIVATE
"CORRADE_GRACEFUL_ASSERT" "MagnumShaders_EXPORTS")
if(BUILD_STATIC_PIC)
if(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumShadersTestLib PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumShadersTestLib PUBLIC

74
src/Magnum/Shaders/Test/CMakeLists.txt

@ -44,7 +44,7 @@ corrade_add_test(ShadersPhongGL_Test PhongGL_Test.cpp LIBRARIES MagnumShaders)
corrade_add_test(ShadersVectorGL_Test VectorGL_Test.cpp LIBRARIES MagnumShaders)
corrade_add_test(ShadersVertexColorGL_Test VertexColorGL_Test.cpp LIBRARIES MagnumShaders)
if(BUILD_GL_TESTS)
if(MAGNUM_BUILD_GL_TESTS)
# Otherwise CMake complains that Corrade::PluginManager is not found, wtf
find_package(Corrade REQUIRED PluginManager)
@ -59,11 +59,11 @@ if(BUILD_GL_TESTS)
# Corrade doesn't support dynamic plugins on iOS, this sorta works around
# that. Should be revisited when updating Travis to newer Xcode (xcode7.3
# has CMake 3.6).
if(NOT BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(NOT MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
set(ANYIMAGEIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:AnyImageImporter>)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
set(TGAIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImporter>)
endif()
endif()
@ -99,19 +99,19 @@ if(BUILD_GL_TESTS)
VectorTestFiles/multidraw2D-distancefield.tga
VectorTestFiles/multidraw3D-distancefield.tga)
target_include_directories(ShadersDistanceFieldVectorGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
target_link_libraries(ShadersDistanceFieldVectorGLTest PRIVATE AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(ShadersDistanceFieldVectorGLTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
add_dependencies(ShadersDistanceFieldVectorGLTest AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(ShadersDistanceFieldVectorGLTest TgaImporter)
endif()
endif()
@ -152,19 +152,19 @@ if(BUILD_GL_TESTS)
FlatTestFiles/multidraw-textured2D.tga
FlatTestFiles/multidraw-textured3D.tga)
target_include_directories(ShadersFlatGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
target_link_libraries(ShadersFlatGLTest PRIVATE AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(ShadersFlatGLTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
add_dependencies(ShadersFlatGLTest AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(ShadersFlatGLTest TgaImporter)
endif()
endif()
@ -250,19 +250,19 @@ if(BUILD_GL_TESTS)
MeshVisualizerTestFiles/multidraw-objectidtexture2D.tga
MeshVisualizerTestFiles/multidraw-objectidtexture3D.tga)
target_include_directories(ShadersMeshVisualizerGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
target_link_libraries(ShadersMeshVisualizerGLTest PRIVATE AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(ShadersMeshVisualizerGLTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
add_dependencies(ShadersMeshVisualizerGLTest AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(ShadersMeshVisualizerGLTest TgaImporter)
endif()
endif()
@ -325,19 +325,19 @@ if(BUILD_GL_TESTS)
# For zero lights test (equivalency to Flat3D)
FlatTestFiles/textured3D-alpha-mask0.5.tga)
target_include_directories(ShadersPhongGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
target_link_libraries(ShadersPhongGLTest PRIVATE AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(ShadersPhongGLTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
add_dependencies(ShadersPhongGLTest AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(ShadersPhongGLTest TgaImporter)
endif()
endif()
@ -362,19 +362,19 @@ if(BUILD_GL_TESTS)
VectorTestFiles/multidraw2D.tga
VectorTestFiles/multidraw3D.tga)
target_include_directories(ShadersVectorGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
target_link_libraries(ShadersVectorGLTest PRIVATE AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(ShadersVectorGLTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
add_dependencies(ShadersVectorGLTest AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(ShadersVectorGLTest TgaImporter)
endif()
endif()
@ -398,19 +398,19 @@ if(BUILD_GL_TESTS)
VertexColorTestFiles/multidraw2D.tga
VertexColorTestFiles/multidraw3D.tga)
target_include_directories(ShadersVertexColorGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
target_link_libraries(ShadersVertexColorGLTest PRIVATE AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(ShadersVertexColorGLTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
add_dependencies(ShadersVertexColorGLTest AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(ShadersVertexColorGLTest TgaImporter)
endif()
endif()
@ -425,11 +425,11 @@ if(BUILD_GL_TESTS)
FILES
BenchmarkFiles/trivial.tga)
target_include_directories(ShadersGLBenchmark PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
target_link_libraries(ShadersGLBenchmark PRIVATE AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(ShadersGLBenchmark PRIVATE TgaImporter)
endif()
endif()

28
src/Magnum/Text/CMakeLists.txt

@ -47,7 +47,7 @@ set(MagnumText_HEADERS
visibility.h)
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
list(APPEND MagnumText_SRCS
DistanceFieldGlyphCache.cpp
GlyphCache.cpp
@ -73,13 +73,13 @@ add_library(MagnumTextObjects OBJECT
target_include_directories(MagnumTextObjects PUBLIC
$<TARGET_PROPERTY:Corrade::PluginManager,INTERFACE_INCLUDE_DIRECTORIES>
$<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
target_include_directories(MagnumTextObjects PUBLIC $<TARGET_PROPERTY:MagnumGL,INTERFACE_INCLUDE_DIRECTORIES>)
endif()
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumTextObjects PRIVATE "MagnumTextObjects_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumTextObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
@ -88,16 +88,16 @@ add_library(MagnumText ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumTextObjects>
${MagnumText_GracefulAssert_SRCS})
set_target_properties(MagnumText PROPERTIES DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
set_target_properties(MagnumText PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION})
elseif(BUILD_STATIC_PIC)
elseif(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumText PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumText PUBLIC
Magnum
MagnumTextureTools
Corrade::PluginManager)
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
target_link_libraries(MagnumText PUBLIC MagnumGL)
endif()
@ -107,9 +107,9 @@ install(TARGETS MagnumText
ARCHIVE DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR})
install(FILES ${MagnumText_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/Text)
if(WITH_FONTCONVERTER)
if(NOT TARGET_GL)
message(SEND_ERROR "magnum-fontconverter is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_FONTCONVERTER)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "magnum-fontconverter is available only if MAGNUM_TARGET_GL is enabled")
endif()
add_executable(magnum-fontconverter fontconverter.cpp)
@ -136,7 +136,7 @@ if(WITH_FONTCONVERTER)
target_link_libraries(magnum-fontconverter PRIVATE MagnumWindowlessWglApplication)
endif()
else()
message(FATAL_ERROR "magnum-fontconverter is not available on this platform. Set WITH_FONTCONVERTER to OFF to suppress this warning.")
message(FATAL_ERROR "magnum-fontconverter is not available on this platform. Set MAGNUM_WITH_FONTCONVERTER to OFF to suppress this warning.")
endif()
install(TARGETS magnum-fontconverter DESTINATION ${MAGNUM_BINARY_INSTALL_DIR})
@ -145,7 +145,7 @@ if(WITH_FONTCONVERTER)
add_executable(Magnum::fontconverter ALIAS magnum-fontconverter)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
# Library with graceful assert for testing
add_library(MagnumTextTestLib ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumTextObjects>
@ -153,14 +153,14 @@ if(BUILD_TESTS)
set_target_properties(MagnumTextTestLib PROPERTIES DEBUG_POSTFIX "-d")
target_compile_definitions(MagnumTextTestLib PRIVATE
"CORRADE_GRACEFUL_ASSERT" "MagnumText_EXPORTS")
if(BUILD_STATIC_PIC)
if(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumTextTestLib PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumTextTestLib PUBLIC
Magnum
MagnumTextureTools
Corrade::PluginManager)
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
target_link_libraries(MagnumText PUBLIC MagnumGL)
endif()

2
src/Magnum/Text/Test/CMakeLists.txt

@ -49,7 +49,7 @@ target_include_directories(TextAbstractFontConverterTest PRIVATE ${CMAKE_CURRENT
corrade_add_test(TextAbstractGlyphCacheTest AbstractGlyphCacheTest.cpp LIBRARIES MagnumTextTestLib)
corrade_add_test(TextAbstractLayouterTest AbstractLayouterTest.cpp LIBRARIES Magnum MagnumText)
if(TARGET_GL AND BUILD_GL_TESTS)
if(MAGNUM_TARGET_GL AND MAGNUM_BUILD_GL_TESTS)
corrade_add_test(TextDistanceFieldGlyphCacheGLTest DistanceFieldGlyphCacheGLTest.cpp LIBRARIES MagnumText MagnumOpenGLTester)
corrade_add_test(TextGlyphCacheGLTest GlyphCacheGLTest.cpp LIBRARIES MagnumText MagnumOpenGLTester)
corrade_add_test(TextRendererGLTest RendererGLTest.cpp LIBRARIES MagnumText MagnumOpenGLTester)

4
src/Magnum/Text/fontconverter.cpp

@ -66,8 +66,8 @@ namespace Magnum {
@m_footernavigation
@m_keywords{magnum-fontconverter fontconverter}
This utility is built if `WITH_FONTCONVERTER` is enabled when building Magnum.
To use this utility with CMake, you need to request the `fontconverter`
This utility is built if `MAGNUM_WITH_FONTCONVERTER` is enabled when building
Magnum. To use this utility with CMake, you need to request the `fontconverter`
component of the `Magnum` package and use the `Magnum::fontconverter` target
for example in a custom command:

20
src/Magnum/TextureTools/CMakeLists.txt

@ -35,9 +35,9 @@ set(MagnumTextureTools_HEADERS
visibility.h)
if(TARGET_GL)
if(MAGNUM_TARGET_GL)
corrade_add_resource(MagnumTextureTools_RCS resources.conf)
if(BUILD_STATIC)
if(MAGNUM_BUILD_STATIC)
# On the static build we're importing the resources manually, so no
# need to have the implicit initializers as well.
set_property(SOURCE ${MagnumTextureTools_RCS} APPEND PROPERTY
@ -58,14 +58,14 @@ add_library(MagnumTextureTools ${SHARED_OR_STATIC}
${MagnumTextureTools_SRCS}
${MagnumTextureTools_HEADERS})
set_target_properties(MagnumTextureTools PROPERTIES DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
set_target_properties(MagnumTextureTools PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION})
elseif(BUILD_STATIC_PIC)
elseif(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumTextureTools PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumTextureTools PUBLIC
Magnum)
if(WITH_GL)
if(MAGNUM_WITH_GL)
target_link_libraries(MagnumTextureTools PUBLIC MagnumGL)
endif()
@ -75,9 +75,9 @@ install(TARGETS MagnumTextureTools
ARCHIVE DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR})
install(FILES ${MagnumTextureTools_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/TextureTools)
if(WITH_DISTANCEFIELDCONVERTER)
if(NOT TARGET_GL)
message(SEND_ERROR "magnum-distancefieldconverter is available only if TARGET_GL is enabled")
if(MAGNUM_WITH_DISTANCEFIELDCONVERTER)
if(NOT MAGNUM_TARGET_GL)
message(SEND_ERROR "magnum-distancefieldconverter is available only if MAGNUM_TARGET_GL is enabled")
endif()
add_executable(magnum-distancefieldconverter distancefieldconverter.cpp)
@ -104,7 +104,7 @@ if(WITH_DISTANCEFIELDCONVERTER)
target_link_libraries(magnum-distancefieldconverter PRIVATE MagnumWindowlessWglApplication)
endif()
else()
message(FATAL_ERROR "magnum-distancefieldconverter is not available on this platform. Set WITH_DISTANCEFIELDCONVERTER to OFF to suppress this warning.")
message(FATAL_ERROR "magnum-distancefieldconverter is not available on this platform. Set MAGNUM_WITH_DISTANCEFIELDCONVERTER to OFF to suppress this warning.")
endif()
install(TARGETS magnum-distancefieldconverter DESTINATION ${MAGNUM_BINARY_INSTALL_DIR})
@ -113,7 +113,7 @@ if(WITH_DISTANCEFIELDCONVERTER)
add_executable(Magnum::distancefieldconverter ALIAS magnum-distancefieldconverter)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

18
src/Magnum/TextureTools/Test/CMakeLists.txt

@ -35,7 +35,7 @@ else()
set(DISTANCEFIELDGLTEST_FILES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/DistanceFieldGLTestFiles)
endif()
if(BUILD_GL_TESTS)
if(MAGNUM_BUILD_GL_TESTS)
# Otherwise CMake complains that Corrade::PluginManager is not found, wtf
find_package(Corrade REQUIRED PluginManager)
@ -44,11 +44,11 @@ if(BUILD_GL_TESTS)
# Corrade doesn't support dynamic plugins on iOS, this sorta works around
# that. Should be revisited when updating Travis to newer Xcode (xcode7.3
# has CMake 3.6).
if(NOT BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(NOT MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
set(ANYIMAGEIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:AnyImageImporter>)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
set(TGAIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImporter>)
endif()
endif()
@ -72,19 +72,19 @@ if(BUILD_GL_TESTS)
DistanceFieldGLTestFiles/input.tga
DistanceFieldGLTestFiles/output.tga)
target_include_directories(TextureToolsDistanceFieldGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
target_link_libraries(TextureToolsDistanceFieldGLTest PRIVATE AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(TextureToolsDistanceFieldGLTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
add_dependencies(TextureToolsDistanceFieldGLTest AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(TextureToolsDistanceFieldGLTest TgaImporter)
endif()
endif()

4
src/Magnum/TextureTools/distancefieldconverter.cpp

@ -73,8 +73,8 @@ namespace Magnum {
@m_footernavigation
@m_keywords{magnum-distancefieldconverter distancefieldconverter}
This utility is built if `WITH_DISTANCEFIELDCONVERTER` is enabled when building
Magnum. To use this utility with CMake, you need to request the
This utility is built if `MAGNUM_WITH_DISTANCEFIELDCONVERTER` is enabled when
building Magnum. To use this utility with CMake, you need to request the
`distancefieldconverter` component of the `Magnum` package and use the
`Magnum::distancefieldconverter` target for example in a custom command:

14
src/Magnum/Trade/CMakeLists.txt

@ -123,10 +123,10 @@ add_library(MagnumTradeObjects OBJECT
target_include_directories(MagnumTradeObjects PUBLIC
$<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>
$<TARGET_PROPERTY:Corrade::PluginManager,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumTradeObjects PRIVATE "MagnumTradeObjects_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumTradeObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
@ -135,9 +135,9 @@ add_library(MagnumTrade ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumTradeObjects>
${MagnumTrade_GracefulAssert_SRCS})
set_target_properties(MagnumTrade PROPERTIES DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
set_target_properties(MagnumTrade PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION})
elseif(BUILD_STATIC_PIC)
elseif(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumTrade PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumTrade PUBLIC
@ -150,7 +150,7 @@ install(TARGETS MagnumTrade
ARCHIVE DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR})
install(FILES ${MagnumTrade_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/Trade)
if(WITH_IMAGECONVERTER)
if(MAGNUM_WITH_IMAGECONVERTER)
set(THREADS_PREFER_PTHREAD_FLAG TRUE)
find_package(Threads REQUIRED)
@ -168,7 +168,7 @@ if(WITH_IMAGECONVERTER)
add_executable(Magnum::imageconverter ALIAS magnum-imageconverter)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
# Library with graceful assert for testing
add_library(MagnumTradeTestLib ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumTradeObjects>
@ -176,7 +176,7 @@ if(BUILD_TESTS)
target_compile_definitions(MagnumTradeTestLib PRIVATE
"CORRADE_GRACEFUL_ASSERT" "MagnumTrade_EXPORTS")
set_target_properties(MagnumTradeTestLib PROPERTIES DEBUG_POSTFIX "-d")
if(BUILD_STATIC_PIC)
if(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumTradeTestLib PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumTradeTestLib

8
src/Magnum/Trade/imageconverter.cpp

@ -52,10 +52,10 @@ namespace Magnum {
@m_footernavigation
@m_keywords{magnum-imageconverter imageconverter}
This utility is built if `WITH_IMAGECONVERTER` is enabled when building Magnum.
To use this utility with CMake, you need to request the `imageconverter`
component of the `Magnum` package and use the `Magnum::imageconverter` target
for example in a custom command:
This utility is built if `MAGNUM_WITH_IMAGECONVERTER` is enabled when building
Magnum. To use this utility with CMake, you need to request the
`imageconverter` component of the `Magnum` package and use the
`Magnum::imageconverter` target for example in a custom command:
@code{.cmake}
find_package(Magnum REQUIRED imageconverter)

20
src/Magnum/Vk/CMakeLists.txt

@ -157,10 +157,10 @@ add_library(MagnumVkObjects OBJECT
${MagnumVk_PRIVATE_HEADERS})
target_include_directories(MagnumVkObjects PUBLIC
$<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumVkObjects PRIVATE "MagnumVkObjects_EXPORTS" "FlextVk_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumVkObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
@ -170,10 +170,10 @@ add_library(MagnumVk ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumFlextVkObjects>
${MagnumVk_GracefulAssert_SRCS})
set_target_properties(MagnumVk PROPERTIES DEBUG_POSTFIX "-d")
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumVk PRIVATE "FlextVk_EXPORTS")
set_target_properties(MagnumVk PROPERTIES VERSION ${MAGNUM_LIBRARY_VERSION} SOVERSION ${MAGNUM_LIBRARY_SOVERSION})
elseif(BUILD_STATIC_PIC)
elseif(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumVk PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_include_directories(MagnumVk PUBLIC
@ -189,7 +189,7 @@ install(TARGETS MagnumVk
ARCHIVE DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR})
install(FILES ${MagnumVk_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/Vk)
if(WITH_VK_INFO)
if(MAGNUM_WITH_VK_INFO)
add_executable(magnum-vk-info vk-info.cpp)
target_link_libraries(magnum-vk-info PRIVATE MagnumVk)
@ -199,9 +199,9 @@ if(WITH_VK_INFO)
add_executable(Magnum::vk-info ALIAS magnum-vk-info)
endif()
if(WITH_VULKANTESTER)
if(NOT TARGET_VK)
message(SEND_ERROR "VulkanTester is available only if TARGET_VK is enabled")
if(MAGNUM_WITH_VULKANTESTER)
if(NOT MAGNUM_TARGET_VK)
message(SEND_ERROR "VulkanTester is available only if MAGNUM_TARGET_VK is enabled")
endif()
find_package(Corrade REQUIRED TestSuite)
@ -228,7 +228,7 @@ if(WITH_VULKANTESTER)
add_library(Magnum::VulkanTester ALIAS MagnumVulkanTester)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
# Library with graceful assert for testing
add_library(MagnumVkTestLib ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumVkObjects>
@ -237,7 +237,7 @@ if(BUILD_TESTS)
set_target_properties(MagnumVkTestLib PROPERTIES DEBUG_POSTFIX "-d")
target_compile_definitions(MagnumVkTestLib PRIVATE
"CORRADE_GRACEFUL_ASSERT" "MagnumVk_EXPORTS" "FlextVk_EXPORTS")
if(BUILD_STATIC_PIC)
if(MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumVkTestLib PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumVkTestLib PUBLIC

6
src/Magnum/Vk/Extensions.h

@ -56,9 +56,9 @@ but these structs are better suited for compile-time decisions rather than
@ref Extension instances. See @ref Instance::isExtensionEnabled() for example
usage.
This library is built if `WITH_VK` is enabled when building Magnum. To use this
library with CMake, you need to request the `Vk` component of the `Magnum`
package and link to the `Magnum::Vk` target:
This library is built if `MAGNUM_WITH_VK` is enabled when building Magnum. To
use this library with CMake, you need to request the `Vk` component of the
`Magnum` package and link to the `Magnum::Vk` target:
@code{.cmake}
find_package(Magnum REQUIRED Vk)

22
src/Magnum/Vk/Test/CMakeLists.txt

@ -29,7 +29,7 @@
set(CMAKE_FOLDER "Magnum/Vk/Test")
# Inputs to configure.h needed only by Vulkan tests
if(BUILD_VK_TESTS)
if(MAGNUM_BUILD_VK_TESTS)
# Otherwise CMake complains that Corrade::PluginManager is not found, wtf
find_package(Corrade REQUIRED PluginManager)
@ -44,18 +44,18 @@ if(BUILD_VK_TESTS)
# Corrade doesn't support dynamic plugins on iOS, this sorta works around
# that. Should be revisited when updating Travis to newer Xcode (xcode7.3
# has CMake 3.6).
if(NOT BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(NOT MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
set(ANYIMAGEIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:AnyImageImporter>)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
set(TGAIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImporter>)
endif()
endif()
endif()
# The file is needed by VkShaderTest as well, so it's created always, not just
# for BUILD_VK_TESTS. First replace ${} variables, then $<> generator
# for MAGNUM_BUILD_VK_TESTS. First replace ${} variables, then $<> generator
# expressions.
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
@ -158,7 +158,7 @@ target_compile_definitions(VkAssertStandardDisabledTest PRIVATE
corrade_add_test(VkVersionTest VersionTest.cpp LIBRARIES MagnumVk)
if(BUILD_VK_TESTS)
if(MAGNUM_BUILD_VK_TESTS)
corrade_add_test(VkBufferVkTest BufferVkTest.cpp LIBRARIES MagnumVkTestLib MagnumVulkanTester)
corrade_add_test(VkCommandBufferVkTest CommandBufferVkTest.cpp LIBRARIES MagnumVulkanTester)
corrade_add_test(VkCommandPoolVkTest CommandPoolVkTest.cpp LIBRARIES MagnumVulkanTester)
@ -186,19 +186,19 @@ if(BUILD_VK_TESTS)
MeshTestFiles/vertexcolor.spv
MeshTestFiles/vertexcolor.tga)
target_include_directories(VkMeshVkTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(BUILD_PLUGINS_STATIC)
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_BUILD_PLUGINS_STATIC)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
target_link_libraries(VkMeshVkTest PRIVATE AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(VkMeshVkTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
add_dependencies(VkMeshVkTest AnyImageImporter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(VkMeshVkTest TgaImporter)
endif()
endif()

6
src/Magnum/Vk/VulkanTester.h

@ -50,9 +50,9 @@ benchmarking. Be sure to read its documentation first to have an overview of
the base features.
This class is built into a separate static library and only if
`WITH_VULKANTESTER` is enabled when building Magnum. To use it with CMake,
request the `VulkanTester` component of the `Magnum` package. Derive your test
class from this class instead of @ref Corrade::TestSuite::Tester and
`MAGNUM_WITH_VULKANTESTER` is enabled when building Magnum. To use it with
CMake, request the `VulkanTester` component of the `Magnum` package. Derive
your test class from this class instead of @ref Corrade::TestSuite::Tester and
either link to `Magnum::VulkanTester` target or add it to the `LIBRARIES`
section of the @ref corrade-cmake-add-test "corrade_add_test()" macro:

8
src/Magnum/Vk/vk-info.cpp

@ -43,10 +43,10 @@ namespace Magnum {
@m_footernavigation
@m_keywords{magnum-vk-info vk-info}
This utility is built if `WITH_VK_INFO` is enabled when building Magnum. To use
this utility with CMake, you need to request the `vk-info` component of the
`Magnum` package and use the `Magnum::vk-info` target for example in a custom
command:
This utility is built if `MAGNUM_WITH_VK_INFO` is enabled when building Magnum.
To use this utility with CMake, you need to request the `vk-info` component of
the `Magnum` package and use the `Magnum::vk-info` target for example in a
custom command:
@code{.cmake}
find_package(Magnum REQUIRED vk-info)

6
src/MagnumExternal/CMakeLists.txt vendored

@ -23,12 +23,12 @@
# DEALINGS IN THE SOFTWARE.
#
if(WITH_AUDIO)
if(MAGNUM_WITH_AUDIO)
add_subdirectory(OpenAL)
endif()
if(WITH_GL)
if(MAGNUM_WITH_GL)
add_subdirectory(OpenGL)
endif()
if(WITH_VK)
if(MAGNUM_WITH_VK)
add_subdirectory(Vulkan)
endif()

4
src/MagnumExternal/OpenGL/CMakeLists.txt vendored

@ -25,9 +25,9 @@
add_subdirectory(KHR)
if(NOT TARGET_GLES)
if(NOT MAGNUM_TARGET_GLES)
add_subdirectory(GL)
elseif(TARGET_GLES2)
elseif(MAGNUM_TARGET_GLES2)
add_subdirectory(GLES2)
else()
add_subdirectory(GLES3)

4
src/MagnumExternal/OpenGL/GL/CMakeLists.txt vendored

@ -30,10 +30,10 @@ set(CMAKE_FOLDER "MagnumExternal/OpenGL")
# flextGLPlatform.cpp is compiled as part of Magnum*Context libraries in Platform
add_library(MagnumFlextGLObjects OBJECT flextGL.cpp)
target_include_directories(MagnumFlextGLObjects PUBLIC $<TARGET_PROPERTY:MagnumGL,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumFlextGLObjects PRIVATE "FlextGL_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumFlextGLObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()

4
src/MagnumExternal/OpenGL/GLES2/CMakeLists.txt vendored

@ -49,10 +49,10 @@ if(NOT CORRADE_TARGET_EMSCRIPTEN)
# flextGLPlatform*.cpp is compiled as part of Magnum*Context libraries in Platform
add_library(MagnumFlextGLObjects OBJECT ${MagnumOpenGL_SRCS})
target_include_directories(MagnumFlextGLObjects PUBLIC $<TARGET_PROPERTY:MagnumGL,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumFlextGLObjects PRIVATE "FlextGL_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumFlextGLObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
endif()

4
src/MagnumExternal/OpenGL/GLES3/CMakeLists.txt vendored

@ -49,10 +49,10 @@ if(NOT CORRADE_TARGET_EMSCRIPTEN)
# flextGLPlatform*.cpp is compiled as part of Magnum*Context libraries in Platform
add_library(MagnumFlextGLObjects OBJECT ${MagnumOpenGL_SRCS})
target_include_directories(MagnumFlextGLObjects PUBLIC $<TARGET_PROPERTY:MagnumGL,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumFlextGLObjects PRIVATE "FlextGL_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumFlextGLObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
endif()

4
src/MagnumExternal/Vulkan/CMakeLists.txt vendored

@ -29,10 +29,10 @@ set(CMAKE_FOLDER "MagnumExternal/Vulkan")
add_library(MagnumFlextVkObjects OBJECT flextVk.cpp)
target_include_directories(MagnumFlextVkObjects PUBLIC $<TARGET_PROPERTY:MagnumVk,INTERFACE_INCLUDE_DIRECTORIES>)
if(NOT BUILD_STATIC)
if(NOT MAGNUM_BUILD_STATIC)
target_compile_definitions(MagnumFlextVkObjects PRIVATE "FlextVk_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
if(NOT MAGNUM_BUILD_STATIC OR MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumFlextVkObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()

6
src/MagnumPlugins/AnyAudioImporter/AnyImporter.h

@ -73,14 +73,14 @@ Only loading from files is supported.
@section Audio-AnyImporter-usage Usage
This plugin depends on the @ref Audio library and is built if
`WITH_ANYAUDIOIMPORTER` is enabled when building Magnum. To use as a dynamic
plugin, load @cpp "AnyAudioImporter" @ce via
`MAGNUM_WITH_ANYAUDIOIMPORTER` is enabled when building Magnum. To use as a
dynamic plugin, load @cpp "AnyAudioImporter" @ce via
@ref Corrade::PluginManager::Manager.
Additionally, if you're using Magnum as a CMake subproject, do the following:
@code{.cmake}
set(WITH_ANYAUDIOIMPORTER ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_ANYAUDIOIMPORTER ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
# So the dynamically loaded plugin gets built implicitly

6
src/MagnumPlugins/AnyAudioImporter/CMakeLists.txt

@ -25,7 +25,7 @@
find_package(Corrade REQUIRED PluginManager)
if(BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_ANYAUDIOIMPORTER_BUILD_STATIC)
if(MAGNUM_BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_ANYAUDIOIMPORTER_BUILD_STATIC)
set(MAGNUM_ANYAUDIOIMPORTER_BUILD_STATIC 1)
endif()
@ -39,7 +39,7 @@ add_plugin(AnyAudioImporter
AnyAudioImporter.conf
AnyImporter.cpp
AnyImporter.h)
if(MAGNUM_ANYAUDIOIMPORTER_BUILD_STATIC AND BUILD_STATIC_PIC)
if(MAGNUM_ANYAUDIOIMPORTER_BUILD_STATIC AND MAGNUM_BUILD_STATIC_PIC)
set_target_properties(AnyAudioImporter PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(AnyAudioImporter PUBLIC Magnum MagnumAudio)
@ -60,7 +60,7 @@ if(MAGNUM_ANYAUDIOIMPORTER_BUILD_STATIC)
target_sources(AnyAudioImporter INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/importStaticPlugin.cpp)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

6
src/MagnumPlugins/AnyAudioImporter/Test/CMakeLists.txt

@ -39,7 +39,7 @@ endif()
# be revisited when updating Travis to newer Xcode (xcode7.3 has CMake 3.6).
if(NOT MAGNUM_ANYAUDIOIMPORTER_BUILD_STATIC)
set(ANYAUDIOIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:AnyAudioImporter>)
if(WITH_WAVAUDIOIMPORTER)
if(MAGNUM_WITH_WAVAUDIOIMPORTER)
set(WAVAUDIOIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:WavAudioImporter>)
endif()
endif()
@ -57,13 +57,13 @@ corrade_add_test(AnyAudioImporterTest AnyAudioImporterTest.cpp
target_include_directories(AnyAudioImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(MAGNUM_ANYAUDIOIMPORTER_BUILD_STATIC)
target_link_libraries(AnyAudioImporterTest PRIVATE AnyAudioImporter)
if(WITH_WAVAUDIOIMPORTER)
if(MAGNUM_WITH_WAVAUDIOIMPORTER)
target_link_libraries(AnyAudioImporterTest PRIVATE WavAudioImporter)
endif()
else()
# So the plugins get properly built when building the test
add_dependencies(AnyAudioImporterTest AnyAudioImporter)
if(WITH_WAVAUDIOIMPORTER)
if(MAGNUM_WITH_WAVAUDIOIMPORTER)
add_dependencies(AnyAudioImporterTest WavAudioImporter)
endif()
endif()

6
src/MagnumPlugins/AnyImageConverter/AnyImageConverter.h

@ -85,14 +85,14 @@ is supported.
@section Trade-AnyImageConverter-usage Usage
This plugin depends on the @ref Trade library and is built if
`WITH_ANYIMAGECONVERTER` is enabled when building Magnum. To use as a dynamic
plugin, load @cpp "AnyImageConverter" @ce via
`MAGNUM_WITH_ANYIMAGECONVERTER` is enabled when building Magnum. To use as a
dynamic plugin, load @cpp "AnyImageConverter" @ce via
@ref Corrade::PluginManager::Manager.
Additionally, if you're using Magnum as a CMake subproject, do the following:
@code{.cmake}
set(WITH_ANYIMAGECONVERTER ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_ANYIMAGECONVERTER ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
# So the dynamically loaded plugin gets built implicitly

6
src/MagnumPlugins/AnyImageConverter/CMakeLists.txt

@ -25,7 +25,7 @@
find_package(Corrade REQUIRED PluginManager)
if(BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_ANYIMAGECONVERTER_BUILD_STATIC)
if(MAGNUM_BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_ANYIMAGECONVERTER_BUILD_STATIC)
set(MAGNUM_ANYIMAGECONVERTER_BUILD_STATIC 1)
endif()
@ -39,7 +39,7 @@ add_plugin(AnyImageConverter
AnyImageConverter.conf
AnyImageConverter.cpp
AnyImageConverter.h)
if(MAGNUM_ANYIMAGECONVERTER_BUILD_STATIC AND BUILD_STATIC_PIC)
if(MAGNUM_ANYIMAGECONVERTER_BUILD_STATIC AND MAGNUM_BUILD_STATIC_PIC)
set_target_properties(AnyImageConverter PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(AnyImageConverter PUBLIC MagnumTrade)
@ -60,7 +60,7 @@ if(MAGNUM_ANYIMAGECONVERTER_BUILD_STATIC)
target_sources(AnyImageConverter INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/importStaticPlugin.cpp)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

6
src/MagnumPlugins/AnyImageConverter/Test/CMakeLists.txt

@ -46,7 +46,7 @@ endif()
# be revisited when updating Travis to newer Xcode (xcode7.3 has CMake 3.6).
if(NOT MAGNUM_ANYIMAGECONVERTER_BUILD_STATIC)
set(ANYIMAGECONVERTER_PLUGIN_FILENAME $<TARGET_FILE:AnyImageConverter>)
if(WITH_TGAIMAGECONVERTER)
if(MAGNUM_WITH_TGAIMAGECONVERTER)
set(TGAIMAGECONVERTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImageConverter>)
endif()
endif()
@ -71,13 +71,13 @@ corrade_add_test(AnyImageConverterTest AnyImageConverterTest.cpp
target_include_directories(AnyImageConverterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(MAGNUM_ANYIMAGECONVERTER_BUILD_STATIC)
target_link_libraries(AnyImageConverterTest PRIVATE AnyImageConverter)
if(WITH_TGAIMAGECONVERTER)
if(MAGNUM_WITH_TGAIMAGECONVERTER)
target_link_libraries(AnyImageConverterTest PRIVATE TgaImageConverter)
endif()
else()
# So the plugins get properly built when building the test
add_dependencies(AnyImageConverterTest AnyImageConverter)
if(WITH_TGAIMAGECONVERTER)
if(MAGNUM_WITH_TGAIMAGECONVERTER)
add_dependencies(AnyImageConverterTest TgaImageConverter)
endif()
endif()

6
src/MagnumPlugins/AnyImageImporter/AnyImageImporter.h

@ -111,14 +111,14 @@ formats that are marked as such in the list above.
@section Trade-AnyImageImporter-usage Usage
This plugin depends on the @ref Trade library and is built if
`WITH_ANYIMAGEIMPORTER` is enabled when building Magnum. To use as a dynamic
plugin, load @cpp "AnyImageImporter" @ce via
`MAGNUM_WITH_ANYIMAGEIMPORTER` is enabled when building Magnum. To use as a
dynamic plugin, load @cpp "AnyImageImporter" @ce via
@ref Corrade::PluginManager::Manager.
Additionally, if you're using Magnum as a CMake subproject, do the following:
@code{.cmake}
set(WITH_ANYIMAGEIMPORTER ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_ANYIMAGEIMPORTER ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
# So the dynamically loaded plugin gets built implicitly

6
src/MagnumPlugins/AnyImageImporter/CMakeLists.txt

@ -25,7 +25,7 @@
find_package(Corrade REQUIRED PluginManager)
if(BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_ANYIMAGEIMPORTER_BUILD_STATIC)
if(MAGNUM_BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_ANYIMAGEIMPORTER_BUILD_STATIC)
set(MAGNUM_ANYIMAGEIMPORTER_BUILD_STATIC 1)
endif()
@ -39,7 +39,7 @@ add_plugin(AnyImageImporter
AnyImageImporter.conf
AnyImageImporter.cpp
AnyImageImporter.h)
if(MAGNUM_ANYIMAGEIMPORTER_BUILD_STATIC AND BUILD_STATIC_PIC)
if(MAGNUM_ANYIMAGEIMPORTER_BUILD_STATIC AND MAGNUM_BUILD_STATIC_PIC)
set_target_properties(AnyImageImporter PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(AnyImageImporter PUBLIC MagnumTrade)
@ -60,7 +60,7 @@ if(MAGNUM_ANYIMAGEIMPORTER_BUILD_STATIC)
target_sources(AnyImageImporter INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/importStaticPlugin.cpp)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

6
src/MagnumPlugins/AnyImageImporter/Test/CMakeLists.txt

@ -39,7 +39,7 @@ endif()
# be revisited when updating Travis to newer Xcode (xcode7.3 has CMake 3.6).
if(NOT MAGNUM_ANYIMAGEIMPORTER_BUILD_STATIC)
set(ANYIMAGEIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:AnyImageImporter>)
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
set(TGAIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImporter>)
endif()
endif()
@ -75,13 +75,13 @@ corrade_add_test(AnyImageImporterTest AnyImageImporterTest.cpp
target_include_directories(AnyImageImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(MAGNUM_ANYIMAGEIMPORTER_BUILD_STATIC)
target_link_libraries(AnyImageImporterTest PRIVATE AnyImageImporter)
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(AnyImageImporterTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
add_dependencies(AnyImageImporterTest AnyImageImporter)
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(AnyImageImporterTest TgaImporter)
endif()
endif()

6
src/MagnumPlugins/AnySceneConverter/AnySceneConverter.h

@ -66,14 +66,14 @@ Only converting to files is supported.
@section Trade-AnySceneConverter-usage Usage
This plugin depends on the @ref Trade library and is built if
`WITH_ANYSCENECONVERTER` is enabled when building Magnum. To use as a dynamic
plugin, load @cpp "AnySceneConverter" @ce via
`MAGNUM_WITH_ANYSCENECONVERTER` is enabled when building Magnum. To use as a
dynamic plugin, load @cpp "AnySceneConverter" @ce via
@ref Corrade::PluginManager::Manager.
Additionally, if you're using Magnum as a CMake subproject, do the following:
@code{.cmake}
set(WITH_ANYSCENECONVERTER ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_ANYSCENECONVERTER ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
# So the dynamically loaded plugin gets built implicitly

6
src/MagnumPlugins/AnySceneConverter/CMakeLists.txt

@ -25,7 +25,7 @@
find_package(Corrade REQUIRED PluginManager)
if(BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_ANYSCENECONVERTER_BUILD_STATIC)
if(MAGNUM_BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_ANYSCENECONVERTER_BUILD_STATIC)
set(MAGNUM_ANYSCENECONVERTER_BUILD_STATIC 1)
endif()
@ -39,7 +39,7 @@ add_plugin(AnySceneConverter
AnySceneConverter.conf
AnySceneConverter.cpp
AnySceneConverter.h)
if(MAGNUM_ANYSCENECONVERTER_BUILD_STATIC AND BUILD_STATIC_PIC)
if(MAGNUM_ANYSCENECONVERTER_BUILD_STATIC AND MAGNUM_BUILD_STATIC_PIC)
set_target_properties(AnySceneConverter PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(AnySceneConverter PUBLIC MagnumTrade)
@ -60,7 +60,7 @@ if(MAGNUM_ANYSCENECONVERTER_BUILD_STATIC)
target_sources(AnySceneConverter INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/importStaticPlugin.cpp)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

6
src/MagnumPlugins/AnySceneConverter/Test/CMakeLists.txt

@ -43,7 +43,7 @@ endif()
# be revisited when updating Travis to newer Xcode (xcode7.3 has CMake 3.6).
if(NOT MAGNUM_ANYSCENECONVERTER_BUILD_STATIC)
set(ANYSCENECONVERTER_PLUGIN_FILENAME $<TARGET_FILE:AnySceneConverter>)
if(WITH_TGAIMAGECONVERTER)
if(MAGNUM_WITH_TGAIMAGECONVERTER)
set(TGAIMAGECONVERTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImageConverter>)
endif()
endif()
@ -62,13 +62,13 @@ corrade_add_test(AnySceneConverterTest AnySceneConverterTest.cpp
target_include_directories(AnySceneConverterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(MAGNUM_ANYSCENECONVERTER_BUILD_STATIC)
target_link_libraries(AnySceneConverterTest PRIVATE AnySceneConverter)
if(WITH_TGAIMAGECONVERTER)
if(MAGNUM_WITH_TGAIMAGECONVERTER)
target_link_libraries(AnySceneConverterTest PRIVATE TgaImageConverter)
endif()
else()
# So the plugins get properly built when building the test
add_dependencies(AnySceneConverterTest AnySceneConverter)
if(WITH_TGAIMAGECONVERTER)
if(MAGNUM_WITH_TGAIMAGECONVERTER)
add_dependencies(AnySceneConverterTest TgaImageConverter)
endif()
endif()

6
src/MagnumPlugins/AnySceneImporter/AnySceneImporter.h

@ -103,14 +103,14 @@ format, however @ref ImporterFeature::FileCallback is supported as well.
@section Trade-AnySceneImporter-usage Usage
This plugin depends on the @ref Trade library and is built if
`WITH_ANYSCENEIMPORTER` is enabled when building Magnum. To use as a dynamic
plugin, load @cpp "AnySceneImporter" @ce via
`MAGNUM_WITH_ANYSCENEIMPORTER` is enabled when building Magnum. To use as a
dynamic plugin, load @cpp "AnySceneImporter" @ce via
@ref Corrade::PluginManager::Manager.
Additionally, if you're using Magnum as a CMake subproject, do the following:
@code{.cmake}
set(WITH_ANYSCENEIMPORTER ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_ANYSCENEIMPORTER ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
# So the dynamically loaded plugin gets built implicitly

6
src/MagnumPlugins/AnySceneImporter/CMakeLists.txt

@ -25,7 +25,7 @@
find_package(Corrade REQUIRED PluginManager)
if(BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_ANYSCENEIMPORTER_BUILD_STATIC)
if(MAGNUM_BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_ANYSCENEIMPORTER_BUILD_STATIC)
set(MAGNUM_ANYSCENEIMPORTER_BUILD_STATIC 1)
endif()
@ -39,7 +39,7 @@ add_plugin(AnySceneImporter
AnySceneImporter.conf
AnySceneImporter.cpp
AnySceneImporter.h)
if(MAGNUM_ANYSCENEIMPORTER_BUILD_STATIC AND BUILD_STATIC_PIC)
if(MAGNUM_ANYSCENEIMPORTER_BUILD_STATIC AND MAGNUM_BUILD_STATIC_PIC)
set_target_properties(AnySceneImporter PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(AnySceneImporter PUBLIC MagnumTrade)
@ -60,7 +60,7 @@ if(MAGNUM_ANYSCENEIMPORTER_BUILD_STATIC)
target_sources(AnySceneImporter INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/importStaticPlugin.cpp)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

6
src/MagnumPlugins/AnySceneImporter/Test/CMakeLists.txt

@ -41,7 +41,7 @@ endif()
# be revisited when updating Travis to newer Xcode (xcode7.3 has CMake 3.6).
if(NOT MAGNUM_ANYSCENEIMPORTER_BUILD_STATIC)
set(ANYSCENEIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:AnySceneImporter>)
if(WITH_OBJIMPORTER)
if(MAGNUM_WITH_OBJIMPORTER)
set(OBJIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:ObjImporter>)
endif()
endif()
@ -62,13 +62,13 @@ corrade_add_test(AnySceneImporterTest AnySceneImporterTest.cpp
target_include_directories(AnySceneImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
if(MAGNUM_ANYSCENEIMPORTER_BUILD_STATIC)
target_link_libraries(AnySceneImporterTest PRIVATE AnySceneImporter)
if(WITH_OBJIMPORTER)
if(MAGNUM_WITH_OBJIMPORTER)
target_link_libraries(AnySceneImporterTest PRIVATE ObjImporter)
endif()
else()
# So the plugins get properly built when building the test
add_dependencies(AnySceneImporterTest AnySceneImporter)
if(WITH_OBJIMPORTER)
if(MAGNUM_WITH_OBJIMPORTER)
add_dependencies(AnySceneImporterTest ObjImporter)
endif()
endif()

6
src/MagnumPlugins/AnyShaderConverter/AnyConverter.h

@ -95,14 +95,14 @@ explicitly set.
@section ShaderTools-AnyConverter-usage Usage
This plugin depends on the @ref ShaderTools library and is built if
`WITH_ANYSHADERCONVERTER` is enabled when building Magnum. To use as a dynamic
plugin, load @cpp "AnyShaderConverter" @ce via
`MAGNUM_WITH_ANYSHADERCONVERTER` is enabled when building Magnum. To use as a
dynamic plugin, load @cpp "AnyShaderConverter" @ce via
@ref Corrade::PluginManager::Manager.
Additionally, if you're using Magnum as a CMake subproject, do the following:
@code{.cmake}
set(WITH_ANYSHADERCONVERTER ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_ANYSHADERCONVERTER ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
# So the dynamically loaded plugin gets built implicitly

6
src/MagnumPlugins/AnyShaderConverter/CMakeLists.txt

@ -25,7 +25,7 @@
find_package(Corrade REQUIRED PluginManager)
if(BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_ANYSHADERCONVERTER_BUILD_STATIC)
if(MAGNUM_BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_ANYSHADERCONVERTER_BUILD_STATIC)
set(MAGNUM_ANYSHADERCONVERTER_BUILD_STATIC 1)
endif()
@ -39,7 +39,7 @@ add_plugin(AnyShaderConverter
AnyShaderConverter.conf
AnyConverter.cpp
AnyConverter.h)
if(MAGNUM_ANYSHADERCONVERTER_BUILD_STATIC AND BUILD_STATIC_PIC)
if(MAGNUM_ANYSHADERCONVERTER_BUILD_STATIC AND MAGNUM_BUILD_STATIC_PIC)
set_target_properties(AnyShaderConverter PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(AnyShaderConverter PUBLIC MagnumShaderTools)
@ -60,7 +60,7 @@ if(MAGNUM_ANYSHADERCONVERTER_BUILD_STATIC)
target_sources(AnyShaderConverter INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/importStaticPlugin.cpp)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

24
src/MagnumPlugins/CMakeLists.txt

@ -35,50 +35,50 @@ macro(add_plugin plugin_name debug_install_dirs release_install_dirs metadata_fi
endif()
endmacro()
if(WITH_ANYAUDIOIMPORTER)
if(MAGNUM_WITH_ANYAUDIOIMPORTER)
add_subdirectory(AnyAudioImporter)
endif()
if(WITH_ANYIMAGEIMPORTER)
if(MAGNUM_WITH_ANYIMAGEIMPORTER)
add_subdirectory(AnyImageImporter)
endif()
if(WITH_ANYIMAGECONVERTER)
if(MAGNUM_WITH_ANYIMAGECONVERTER)
add_subdirectory(AnyImageConverter)
endif()
if(WITH_ANYSCENECONVERTER)
if(MAGNUM_WITH_ANYSCENECONVERTER)
add_subdirectory(AnySceneConverter)
endif()
if(WITH_ANYSCENEIMPORTER)
if(MAGNUM_WITH_ANYSCENEIMPORTER)
add_subdirectory(AnySceneImporter)
endif()
if(WITH_ANYSHADERCONVERTER)
if(MAGNUM_WITH_ANYSHADERCONVERTER)
add_subdirectory(AnyShaderConverter)
endif()
if(WITH_MAGNUMFONT)
if(MAGNUM_WITH_MAGNUMFONT)
add_subdirectory(MagnumFont)
endif()
if(WITH_MAGNUMFONTCONVERTER)
if(MAGNUM_WITH_MAGNUMFONTCONVERTER)
add_subdirectory(MagnumFontConverter)
endif()
if(WITH_OBJIMPORTER)
if(MAGNUM_WITH_OBJIMPORTER)
add_subdirectory(ObjImporter)
endif()
if(WITH_TGAIMAGECONVERTER)
if(MAGNUM_WITH_TGAIMAGECONVERTER)
add_subdirectory(TgaImageConverter)
endif()
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_subdirectory(TgaImporter)
endif()
if(WITH_WAVAUDIOIMPORTER)
if(MAGNUM_WITH_WAVAUDIOIMPORTER)
add_subdirectory(WavAudioImporter)
endif()

10
src/MagnumPlugins/MagnumFont/CMakeLists.txt

@ -23,15 +23,15 @@
# DEALINGS IN THE SOFTWARE.
#
if(NOT TARGET_GL)
if(NOT MAGNUM_TARGET_GL)
# TODO: remove (and update all other docs) when we have better
# createGlyphCache() APIs
message(SEND_ERROR "MagnumFont is available only if TARGET_GL is enabled")
message(SEND_ERROR "MagnumFont is available only if MAGNUM_TARGET_GL is enabled")
endif()
find_package(Corrade REQUIRED PluginManager)
if(BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_MAGNUMFONT_BUILD_STATIC)
if(MAGNUM_BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_MAGNUMFONT_BUILD_STATIC)
set(MAGNUM_MAGNUMFONT_BUILD_STATIC 1)
endif()
@ -45,7 +45,7 @@ add_plugin(MagnumFont
MagnumFont.conf
MagnumFont.cpp
MagnumFont.h)
if(MAGNUM_MAGNUMFONT_BUILD_STATIC AND BUILD_STATIC_PIC)
if(MAGNUM_MAGNUMFONT_BUILD_STATIC AND MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumFont PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumFont PUBLIC Magnum MagnumText MagnumTrade)
@ -69,7 +69,7 @@ if(MAGNUM_MAGNUMFONT_BUILD_STATIC)
target_sources(MagnumFont INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/importStaticPlugin.cpp)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

8
src/MagnumPlugins/MagnumFont/MagnumFont.h

@ -119,14 +119,14 @@ rectangle=45 0 44 25
@section Text-MagnumFont-usage Usage
This plugin depends on the @ref Text library and the
@ref Trade::TgaImporter "TgaImporter" plugin. It is built if `WITH_MAGNUMFONT`
is enabled when building Magnum. To use as a dynamic plugin, load
@cpp "MagnumFont" @ce via @ref Corrade::PluginManager::Manager.
@ref Trade::TgaImporter "TgaImporter" plugin. It is built if
`MAGNUM_WITH_MAGNUMFONT` is enabled when building Magnum. To use as a dynamic
plugin, load @cpp "MagnumFont" @ce via @ref Corrade::PluginManager::Manager.
Additionally, if you're using Magnum as a CMake subproject, do the following:
@code{.cmake}
set(WITH_MAGNUMFONT ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_MAGNUMFONT ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
# So the dynamically loaded plugin gets built implicitly

2
src/MagnumPlugins/MagnumFont/Test/CMakeLists.txt

@ -65,7 +65,7 @@ if(CORRADE_BUILD_STATIC AND NOT MAGNUM_MAGNUMFONT_BUILD_STATIC)
set_target_properties(MagnumFontTest PROPERTIES ENABLE_EXPORTS ON)
endif()
if(BUILD_GL_TESTS)
if(MAGNUM_BUILD_GL_TESTS)
corrade_add_test(MagnumFontGLTest MagnumFontGLTest.cpp
LIBRARIES MagnumText MagnumTrade MagnumOpenGLTester
FILES

6
src/MagnumPlugins/MagnumFontConverter/CMakeLists.txt

@ -25,7 +25,7 @@
find_package(Corrade REQUIRED PluginManager)
if(BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_MAGNUMFONTCONVERTER_BUILD_STATIC)
if(MAGNUM_BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_MAGNUMFONTCONVERTER_BUILD_STATIC)
set(MAGNUM_MAGNUMFONTCONVERTER_BUILD_STATIC 1)
endif()
@ -39,7 +39,7 @@ add_plugin(MagnumFontConverter
MagnumFontConverter.conf
MagnumFontConverter.cpp
MagnumFontConverter.h)
if(MAGNUM_MAGNUMFONTCONVERTER_BUILD_STATIC AND BUILD_STATIC_PIC)
if(MAGNUM_MAGNUMFONTCONVERTER_BUILD_STATIC AND MAGNUM_BUILD_STATIC_PIC)
set_target_properties(MagnumFontConverter PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(MagnumFontConverter PUBLIC Magnum MagnumText MagnumTrade)
@ -65,7 +65,7 @@ if(MAGNUM_MAGNUMFONTCONVERTER_BUILD_STATIC)
target_sources(MagnumFontConverter INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/importStaticPlugin.cpp)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

4
src/MagnumPlugins/MagnumFontConverter/MagnumFontConverter.h

@ -62,14 +62,14 @@ passed @ref AbstractGlyphCache to support @ref GlyphCacheFeature::ImageDownload.
This plugin depends on the @ref Text library and the
@ref Trade::TgaImageConverter "TgaImageConverter" plugin. It is built if
`WITH_MAGNUMFONTCONVERTER` is enabled when building Magnum. To use as a
`MAGNUM_WITH_MAGNUMFONTCONVERTER` is enabled when building Magnum. To use as a
dynamic plugin, load @cpp "MagnumFontConverter" @ce via
@ref Corrade::PluginManager::Manager.
Additionally, if you're using Magnum as a CMake subproject, do the following:
@code{.cmake}
set(WITH_MAGNUMFONTCONVERTER ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_MAGNUMFONTCONVERTER ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
# So the dynamically loaded plugin gets built implicitly

6
src/MagnumPlugins/MagnumFontConverter/Test/CMakeLists.txt

@ -42,7 +42,7 @@ endif()
if(NOT MAGNUM_MAGNUMFONTCONVERTER_BUILD_STATIC)
set(MAGNUMFONTCONVERTER_PLUGIN_FILENAME $<TARGET_FILE:MagnumFontConverter>)
set(TGAIMAGECONVERTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImageConverter>)
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
set(TGAIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImporter>)
endif()
endif()
@ -62,13 +62,13 @@ target_include_directories(MagnumFontConverterTest PRIVATE ${CMAKE_CURRENT_BINAR
if(MAGNUM_MAGNUMFONTCONVERTER_BUILD_STATIC)
target_link_libraries(MagnumFontConverterTest PRIVATE
MagnumFontConverter) # TgaImageConverter should get linked transitively
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
target_link_libraries(MagnumFontConverterTest PRIVATE TgaImporter)
endif()
else()
# So the plugins get properly built when building the test
add_dependencies(MagnumFontConverterTest MagnumFontConverter)
if(WITH_TGAIMPORTER)
if(MAGNUM_WITH_TGAIMPORTER)
add_dependencies(MagnumFontConverterTest TgaImporter)
endif()
endif()

6
src/MagnumPlugins/ObjImporter/CMakeLists.txt

@ -25,7 +25,7 @@
find_package(Corrade REQUIRED PluginManager)
if(BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_OBJIMPORTER_BUILD_STATIC)
if(MAGNUM_BUILD_PLUGINS_STATIC AND NOT DEFINED MAGNUM_OBJIMPORTER_BUILD_STATIC)
set(MAGNUM_OBJIMPORTER_BUILD_STATIC 1)
endif()
@ -39,7 +39,7 @@ add_plugin(ObjImporter
ObjImporter.conf
ObjImporter.cpp
ObjImporter.h)
if(MAGNUM_OBJIMPORTER_BUILD_STATIC AND BUILD_STATIC_PIC)
if(MAGNUM_OBJIMPORTER_BUILD_STATIC AND MAGNUM_BUILD_STATIC_PIC)
set_target_properties(ObjImporter PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(ObjImporter PUBLIC MagnumTrade MagnumMeshTools)
@ -67,7 +67,7 @@ if(MAGNUM_OBJIMPORTER_BUILD_STATIC)
target_sources(ObjImporter INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/importStaticPlugin.cpp)
endif()
if(BUILD_TESTS)
if(MAGNUM_BUILD_TESTS)
add_subdirectory(Test)
endif()

8
src/MagnumPlugins/ObjImporter/ObjImporter.h

@ -62,14 +62,14 @@ Loads Wavefront OBJ (`*.obj`) files, with the following supported features:
@section Trade-ObjImporter-usage Usage
This plugin depends on the @ref Trade library and is built if `WITH_OBJIMPORTER`
is enabled when building Magnum. To use as a dynamic plugin, load
@cpp "ObjImporter" @ce via @ref Corrade::PluginManager::Manager.
This plugin depends on the @ref Trade library and is built if
`MAGNUM_WITH_OBJIMPORTER` is enabled when building Magnum. To use as a dynamic
plugin, load @cpp "ObjImporter" @ce via @ref Corrade::PluginManager::Manager.
Additionally, if you're using Magnum as a CMake subproject, do the following:
@code{.cmake}
set(WITH_OBJIMPORTER ON CACHE BOOL "" FORCE)
set(MAGNUM_WITH_OBJIMPORTER ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
# So the dynamically loaded plugin gets built implicitly

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save