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

323 lines
11 KiB
Raw Normal View History Unescape

Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
#
# This file is part of Magnum.
#
Updated copyright year.
7 years ago
# Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
# Vladimír Vondruš <mosra@centrum.cz>
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
#
set(MagnumGL_SRCS
AbstractFramebuffer.cpp
AbstractObject.cpp
AbstractTexture.cpp
AbstractShaderProgram.cpp
Attribute.cpp
Buffer.cpp
CubeMapTexture.cpp
Context.cpp
DefaultFramebuffer.cpp
Framebuffer.cpp
OpenGL.cpp
Renderbuffer.cpp
Renderer.cpp
Shader.cpp
Texture.cpp
Version.cpp
Implementation/BufferState.cpp
Implementation/ContextState.cpp
Implementation/FramebufferState.cpp
Implementation/MeshState.cpp
Implementation/RendererState.cpp
Implementation/ShaderProgramState.cpp
Implementation/ShaderState.cpp
Implementation/State.cpp
Implementation/TextureState.cpp
Implementation/driverSpecific.cpp
Implementation/maxTextureSize.cpp)
Split the OpenGL layer out, pt 9: generic pixel formats. This is quite big, so: * There are new Magnum::PixelFormat and Magnum::CompressedPixelFormat enums, which contain generic API-independent formats. In particular, PixelFormat replaces GL::PixelFormat and GL::PixelType with a single value. * There's GL::pixelFormat(), GL::pixelType(), GL::compressedPixelFormat() to convert the generic enums to GL-specific. The mapping is only in one direction, done with a lookup table (generic enums are indices to that table). * GL classes taking the formats directly (such as GL::BufferImage) have overloads that take both the GL-specific and generic format. * The generic Image, CompressedImage, ImageView, CompressedImageView, and Trade::ImageData classes now accept the generic formats first-class. However, it's also possible to store an implementation-specific value to cover cases where a generic format enum doesn't have support for a particular format. This is done by wrapping the value using pixelFormatWrap() or compressedPixelFormatWrap(). Particular GPU APIs then assume it's their implementation-specific value and extract the value back using pixelFormatUnwrap() or compressedPixelFormatUnwrap(). There's also an isPixelFormatImplementationSpecific() and isCompressedPixelFormatImplementationSpecific() that distinguishes these values. * Many operations need pixel size and in order to have it even for implementation-specific formats, a corresponding pixelSize() overload is found via ADL on construction and the calculated size stored along the format. Previously the pixel size was only calculated on demand, but that's not possible now. In case such overload is not available, it's possible to pass pixel size manually as well. * In order to support the GL format+type pair, Image, ImageView and Trade::ImageData, there's now an additional untyped formatExtra() field that holds the second value. * The CompressedPixelStorage class is now unconditionally available on all targets, including OpenGL ES and WebGL. However, on OpenGL ES the GL APIs expect that it's all at default values. I attempted to preserve backwards compatibility as much as possible: * The PixelFormat and CompressedPixelFormat enum now contains generic API-independent values. The GL-specific formats are present there, but marked as deprecated. Use either the generic values or GL::PixelFormat (togehter with GL::PixelType) and GL::CompressedPixelFormat instead. There's a lot of ugliness caused by this, but seems to work well. * *Image::type() functions are deprecated as they were too GL-specific. Use formatExtra() and cast it to GL::PixelType instead. * Image constructors take templated format or format+extra arguments, so passing GL-specific values to them should still work.
8 years ago
set(MagnumGL_GracefulAssert_SRCS
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
Mesh.cpp
GL: make calls to Mesh::setCount() and MeshView::setCount() mandatory. Helps a lot with black screen of death and should have been here ages ago.
8 years ago
MeshView.cpp
Split the OpenGL layer out, pt 12: generic sampler state. The Sampler class was split into GL::Sampler (which is now mostly just a placeholder for implementing OpenGL sampler objects), pairs of generic / GL-specific SamplerFormat / GL::SamplerFormat, SamplerMipmap / GL::SamplerMipmap, SamplerWrapping / GL::SamplerWrapping enums and the GL-specific GL::SamplerCompareMode, GL::SamplerCompareFunction, GL::SamplerDepthStencilMode enums. The old Sampler class is marked as deprecated and aliases its enum to the generic enums (or to the GL-specific ones in case the generic versions are not available).
8 years ago
PixelFormat.cpp
Sampler.cpp)
Split the OpenGL layer out, pt 9: generic pixel formats. This is quite big, so: * There are new Magnum::PixelFormat and Magnum::CompressedPixelFormat enums, which contain generic API-independent formats. In particular, PixelFormat replaces GL::PixelFormat and GL::PixelType with a single value. * There's GL::pixelFormat(), GL::pixelType(), GL::compressedPixelFormat() to convert the generic enums to GL-specific. The mapping is only in one direction, done with a lookup table (generic enums are indices to that table). * GL classes taking the formats directly (such as GL::BufferImage) have overloads that take both the GL-specific and generic format. * The generic Image, CompressedImage, ImageView, CompressedImageView, and Trade::ImageData classes now accept the generic formats first-class. However, it's also possible to store an implementation-specific value to cover cases where a generic format enum doesn't have support for a particular format. This is done by wrapping the value using pixelFormatWrap() or compressedPixelFormatWrap(). Particular GPU APIs then assume it's their implementation-specific value and extract the value back using pixelFormatUnwrap() or compressedPixelFormatUnwrap(). There's also an isPixelFormatImplementationSpecific() and isCompressedPixelFormatImplementationSpecific() that distinguishes these values. * Many operations need pixel size and in order to have it even for implementation-specific formats, a corresponding pixelSize() overload is found via ADL on construction and the calculated size stored along the format. Previously the pixel size was only calculated on demand, but that's not possible now. In case such overload is not available, it's possible to pass pixel size manually as well. * In order to support the GL format+type pair, Image, ImageView and Trade::ImageData, there's now an additional untyped formatExtra() field that holds the second value. * The CompressedPixelStorage class is now unconditionally available on all targets, including OpenGL ES and WebGL. However, on OpenGL ES the GL APIs expect that it's all at default values. I attempted to preserve backwards compatibility as much as possible: * The PixelFormat and CompressedPixelFormat enum now contains generic API-independent values. The GL-specific formats are present there, but marked as deprecated. Use either the generic values or GL::PixelFormat (togehter with GL::PixelType) and GL::CompressedPixelFormat instead. There's a lot of ugliness caused by this, but seems to work well. * *Image::type() functions are deprecated as they were too GL-specific. Use formatExtra() and cast it to GL::PixelType instead. * Image constructors take templated format or format+extra arguments, so passing GL-specific values to them should still work.
8 years ago
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
set(MagnumGL_HEADERS
AbstractFramebuffer.h
AbstractObject.h
AbstractShaderProgram.h
AbstractTexture.h
Attribute.h
Buffer.h
Context.h
CubeMapTexture.h
DefaultFramebuffer.h
Extensions.h
Framebuffer.h
GL.h
Mesh.h
MeshView.h
OpenGL.h
PixelFormat.h
Renderbuffer.h
RenderbufferFormat.h
Renderer.h
Sampler.h
Shader.h
Texture.h
TextureFormat.h
Version.h
visibility.h)
# Header files to display in project view of IDEs only
set(MagnumGL_PRIVATE_HEADERS
Implementation/BufferState.h
Implementation/ContextState.h
Implementation/FramebufferState.h
Implementation/maxTextureSize.h
Implementation/MeshState.h
Implementation/RendererState.h
Implementation/ShaderProgramState.h
Implementation/ShaderState.h
Implementation/State.h
Implementation/TextureState.h)
# Desktop-only stuff
if(NOT TARGET_GLES)
list(APPEND MagnumGL_SRCS RectangleTexture.cpp)
list(APPEND MagnumGL_HEADERS RectangleTexture.h)
endif()
# OpenGL ES 3.0 and WebGL 2.0 stuff
if(NOT TARGET_GLES2)
list(APPEND MagnumGL_SRCS
PrimitiveQuery.cpp
TextureArray.cpp
TransformFeedback.cpp
Implementation/TransformFeedbackState.cpp)
Split the OpenGL layer out, pt 10: test the new image APIs. With the previous commits the original tests passed (which is desired), but these were using deprecated functionality and not covering the new stuff. These tests are not using the deprecated functionality, which means I don't need to build them as part of the GL library anymore. The GL::BufferImage test is still using the deprecated functionality though, in order to check I didn't break anything by accident.
8 years ago
list(APPEND MagnumGL_GracefulAssert_SRCS
BufferImage.cpp)
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
list(APPEND MagnumGL_HEADERS
BufferImage.h
PrimitiveQuery.h
TextureArray.h
TransformFeedback.h)
list(APPEND MagnumGL_PRIVATE_HEADES
Implementation/TransformFeedbackState.h)
endif()
# Desktop and OpenGL ES stuff that is not available in WebGL
if(NOT TARGET_WEBGL)
list(APPEND MagnumGL_SRCS
DebugOutput.cpp
Implementation/DebugState.cpp)
list(APPEND MagnumGL_HEADERS
DebugOutput.h
TimeQuery.h)
list(APPEND MagnumGL_PRIVATE_HEADERS
Implementation/DebugState.h)
# Desktop and OpenGL ES 3.0 stuff that is not available in ES2 and WebGL
if(NOT TARGET_GLES2)
list(APPEND MagnumGL_SRCS
BufferTexture.cpp
CubeMapTextureArray.cpp
MultisampleTexture.cpp)
list(APPEND MagnumGL_HEADERS
BufferTexture.h
BufferTextureFormat.h
CubeMapTextureArray.h
ImageFormat.h
MultisampleTexture.h)
endif()
endif()
# Desktop, OpenGL ES and WebGL 2.0 stuff that is not available in WebGL 1.0
if(NOT (TARGET_WEBGL AND TARGET_GLES2))
list(APPEND MagnumGL_SRCS
AbstractQuery.cpp
Implementation/QueryState.cpp)
list(APPEND MagnumGL_HEADERS
AbstractQuery.h
SampleQuery.h)
list(APPEND MagnumGL_PRIVATE_HEADERS
Implementation/QueryState.h)
endif()
Split the OpenGL layer out, pt 9: generic pixel formats. This is quite big, so: * There are new Magnum::PixelFormat and Magnum::CompressedPixelFormat enums, which contain generic API-independent formats. In particular, PixelFormat replaces GL::PixelFormat and GL::PixelType with a single value. * There's GL::pixelFormat(), GL::pixelType(), GL::compressedPixelFormat() to convert the generic enums to GL-specific. The mapping is only in one direction, done with a lookup table (generic enums are indices to that table). * GL classes taking the formats directly (such as GL::BufferImage) have overloads that take both the GL-specific and generic format. * The generic Image, CompressedImage, ImageView, CompressedImageView, and Trade::ImageData classes now accept the generic formats first-class. However, it's also possible to store an implementation-specific value to cover cases where a generic format enum doesn't have support for a particular format. This is done by wrapping the value using pixelFormatWrap() or compressedPixelFormatWrap(). Particular GPU APIs then assume it's their implementation-specific value and extract the value back using pixelFormatUnwrap() or compressedPixelFormatUnwrap(). There's also an isPixelFormatImplementationSpecific() and isCompressedPixelFormatImplementationSpecific() that distinguishes these values. * Many operations need pixel size and in order to have it even for implementation-specific formats, a corresponding pixelSize() overload is found via ADL on construction and the calculated size stored along the format. Previously the pixel size was only calculated on demand, but that's not possible now. In case such overload is not available, it's possible to pass pixel size manually as well. * In order to support the GL format+type pair, Image, ImageView and Trade::ImageData, there's now an additional untyped formatExtra() field that holds the second value. * The CompressedPixelStorage class is now unconditionally available on all targets, including OpenGL ES and WebGL. However, on OpenGL ES the GL APIs expect that it's all at default values. I attempted to preserve backwards compatibility as much as possible: * The PixelFormat and CompressedPixelFormat enum now contains generic API-independent values. The GL-specific formats are present there, but marked as deprecated. Use either the generic values or GL::PixelFormat (togehter with GL::PixelType) and GL::CompressedPixelFormat instead. There's a lot of ugliness caused by this, but seems to work well. * *Image::type() functions are deprecated as they were too GL-specific. Use formatExtra() and cast it to GL::PixelType instead. * Image constructors take templated format or format+extra arguments, so passing GL-specific values to them should still work.
8 years ago
# Objects shared between main and test library
add_library(MagnumGLObjects OBJECT
${MagnumGL_SRCS}
${MagnumGL_HEADERS}
${MagnumGL_PRIVATE_HEADERS})
# We can use both implicit include path (GLES2/gl2.h) where our headers can
# be overriden with system ones or explicit (MagnumExternal/OpenGL/GLES2/gl2ext.h)
# where only our headers will be used
target_include_directories(MagnumGLObjects PUBLIC
$<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>
${PROJECT_SOURCE_DIR}/src/MagnumExternal/OpenGL)
if(NOT BUILD_STATIC)
target_compile_definitions(MagnumGLObjects PRIVATE "MagnumGLObjects_EXPORTS" "FlextGL_EXPORTS")
endif()
if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
set_target_properties(MagnumGLObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
set_target_properties(MagnumGLObjects PROPERTIES FOLDER "Magnum/GL")
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
# Link in GL function pointer variables on platforms that support it
if(NOT CORRADE_TARGET_EMSCRIPTEN)
Split the OpenGL layer out, pt 9: generic pixel formats. This is quite big, so: * There are new Magnum::PixelFormat and Magnum::CompressedPixelFormat enums, which contain generic API-independent formats. In particular, PixelFormat replaces GL::PixelFormat and GL::PixelType with a single value. * There's GL::pixelFormat(), GL::pixelType(), GL::compressedPixelFormat() to convert the generic enums to GL-specific. The mapping is only in one direction, done with a lookup table (generic enums are indices to that table). * GL classes taking the formats directly (such as GL::BufferImage) have overloads that take both the GL-specific and generic format. * The generic Image, CompressedImage, ImageView, CompressedImageView, and Trade::ImageData classes now accept the generic formats first-class. However, it's also possible to store an implementation-specific value to cover cases where a generic format enum doesn't have support for a particular format. This is done by wrapping the value using pixelFormatWrap() or compressedPixelFormatWrap(). Particular GPU APIs then assume it's their implementation-specific value and extract the value back using pixelFormatUnwrap() or compressedPixelFormatUnwrap(). There's also an isPixelFormatImplementationSpecific() and isCompressedPixelFormatImplementationSpecific() that distinguishes these values. * Many operations need pixel size and in order to have it even for implementation-specific formats, a corresponding pixelSize() overload is found via ADL on construction and the calculated size stored along the format. Previously the pixel size was only calculated on demand, but that's not possible now. In case such overload is not available, it's possible to pass pixel size manually as well. * In order to support the GL format+type pair, Image, ImageView and Trade::ImageData, there's now an additional untyped formatExtra() field that holds the second value. * The CompressedPixelStorage class is now unconditionally available on all targets, including OpenGL ES and WebGL. However, on OpenGL ES the GL APIs expect that it's all at default values. I attempted to preserve backwards compatibility as much as possible: * The PixelFormat and CompressedPixelFormat enum now contains generic API-independent values. The GL-specific formats are present there, but marked as deprecated. Use either the generic values or GL::PixelFormat (togehter with GL::PixelType) and GL::CompressedPixelFormat instead. There's a lot of ugliness caused by this, but seems to work well. * *Image::type() functions are deprecated as they were too GL-specific. Use formatExtra() and cast it to GL::PixelType instead. * Image constructors take templated format or format+extra arguments, so passing GL-specific values to them should still work.
8 years ago
set(MagnumGL_FlextGL_SRCS $<TARGET_OBJECTS:MagnumFlextGLObjects>)
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
endif()
# GL library
add_library(MagnumGL ${SHARED_OR_STATIC}
Split the OpenGL layer out, pt 9: generic pixel formats. This is quite big, so: * There are new Magnum::PixelFormat and Magnum::CompressedPixelFormat enums, which contain generic API-independent formats. In particular, PixelFormat replaces GL::PixelFormat and GL::PixelType with a single value. * There's GL::pixelFormat(), GL::pixelType(), GL::compressedPixelFormat() to convert the generic enums to GL-specific. The mapping is only in one direction, done with a lookup table (generic enums are indices to that table). * GL classes taking the formats directly (such as GL::BufferImage) have overloads that take both the GL-specific and generic format. * The generic Image, CompressedImage, ImageView, CompressedImageView, and Trade::ImageData classes now accept the generic formats first-class. However, it's also possible to store an implementation-specific value to cover cases where a generic format enum doesn't have support for a particular format. This is done by wrapping the value using pixelFormatWrap() or compressedPixelFormatWrap(). Particular GPU APIs then assume it's their implementation-specific value and extract the value back using pixelFormatUnwrap() or compressedPixelFormatUnwrap(). There's also an isPixelFormatImplementationSpecific() and isCompressedPixelFormatImplementationSpecific() that distinguishes these values. * Many operations need pixel size and in order to have it even for implementation-specific formats, a corresponding pixelSize() overload is found via ADL on construction and the calculated size stored along the format. Previously the pixel size was only calculated on demand, but that's not possible now. In case such overload is not available, it's possible to pass pixel size manually as well. * In order to support the GL format+type pair, Image, ImageView and Trade::ImageData, there's now an additional untyped formatExtra() field that holds the second value. * The CompressedPixelStorage class is now unconditionally available on all targets, including OpenGL ES and WebGL. However, on OpenGL ES the GL APIs expect that it's all at default values. I attempted to preserve backwards compatibility as much as possible: * The PixelFormat and CompressedPixelFormat enum now contains generic API-independent values. The GL-specific formats are present there, but marked as deprecated. Use either the generic values or GL::PixelFormat (togehter with GL::PixelType) and GL::CompressedPixelFormat instead. There's a lot of ugliness caused by this, but seems to work well. * *Image::type() functions are deprecated as they were too GL-specific. Use formatExtra() and cast it to GL::PixelType instead. * Image constructors take templated format or format+extra arguments, so passing GL-specific values to them should still work.
8 years ago
$<TARGET_OBJECTS:MagnumGLObjects>
${MagnumGL_FlextGL_SRCS}
${MagnumGL_GracefulAssert_SRCS})
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
set_target_properties(MagnumGL PROPERTIES
DEBUG_POSTFIX "-d"
FOLDER "Magnum/GL")
if(NOT 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)
set_target_properties(MagnumGL PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()
# We can use both implicit include path (GLES2/gl2.h) where our headers can
# be overriden with system ones or explicit (MagnumExternal/OpenGL/GLES2/gl2ext.h)
# where only our headers will be used
target_include_directories(MagnumGL PUBLIC
${PROJECT_SOURCE_DIR}/src/MagnumExternal/OpenGL)
target_link_libraries(MagnumGL PUBLIC Magnum)
if(NOT TARGET_GLES OR TARGET_DESKTOP_GLES)
CMake: prefer GLVND if on CMake 3.11. This *did not* make things simpler. At all. Ugh. Can I follow Apple and deprecate GL too?
8 years ago
# If the GLVND library (CMake 3.11+) was found, link to the imported
# target. Otherwise (and also on all systems except Linux) link to the
# classic libGL. Can't use OpenGL_OpenGL_FOUND, because that one is set
# also if GLVND is *not* found. WTF.
if(OPENGL_opengl_LIBRARY)
target_link_libraries(MagnumGL PUBLIC OpenGL::OpenGL)
else()
target_link_libraries(MagnumGL PUBLIC ${OPENGL_gl_LIBRARY})
endif()
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
elseif(TARGET_GLES2)
target_link_libraries(MagnumGL PUBLIC OpenGLES2::OpenGLES2)
else()
target_link_libraries(MagnumGL PUBLIC OpenGLES3::OpenGLES3)
endif()
install(TARGETS MagnumGL
RUNTIME DESTINATION ${MAGNUM_BINARY_INSTALL_DIR}
LIBRARY DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR}
ARCHIVE DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR})
install(FILES ${MagnumGL_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/GL)
# OpenGLTester class
if(WITH_OPENGLTESTER)
Document and print helpful error messages for GL-dependent features.
7 years ago
if(NOT TARGET_GL)
message(SEND_ERROR "OpenGLTester is available only if TARGET_GL is enabled")
endif()
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
find_package(Corrade REQUIRED TestSuite)
set(MagnumOpenGLTester_SRCS OpenGLTester.cpp)
set(MagnumOpenGLTester_HEADERS OpenGLTester.h)
add_library(MagnumOpenGLTester STATIC
${MagnumOpenGLTester_SRCS}
Removed deprecated Test/AbstractOpenGLTester.h header, Deprecated in fb454d8a3f3884396b6fd7dbed29ef9e9a1e27ce (Jan 2017).
8 years ago
${MagnumOpenGLTester_HEADERS})
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
set_target_properties(MagnumOpenGLTester PROPERTIES
DEBUG_POSTFIX "-d"
FOLDER "Magnum/GL")
# Assuming that PIC is not needed because the Tester lib is always linked
# to the executable and not to any intermediate shared lib
# OPENGLTESTER_APPLICATION defined in the root CMakeLists, because it also
# enables the application library dependencies
target_link_libraries(MagnumOpenGLTester Magnum Corrade::TestSuite ${OPENGLTESTER_APPLICATION})
install(FILES ${MagnumOpenGLTester_HEADERS} DESTINATION ${MAGNUM_INCLUDE_INSTALL_DIR}/GL)
install(TARGETS MagnumOpenGLTester
RUNTIME DESTINATION ${MAGNUM_BINARY_INSTALL_DIR}
LIBRARY DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR}
ARCHIVE DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR})
# Magnum OpenGLTester target alias for superprojects
add_library(Magnum::OpenGLTester ALIAS MagnumOpenGLTester)
endif()
if(BUILD_TESTS)
Split the OpenGL layer out, pt 9: generic pixel formats. This is quite big, so: * There are new Magnum::PixelFormat and Magnum::CompressedPixelFormat enums, which contain generic API-independent formats. In particular, PixelFormat replaces GL::PixelFormat and GL::PixelType with a single value. * There's GL::pixelFormat(), GL::pixelType(), GL::compressedPixelFormat() to convert the generic enums to GL-specific. The mapping is only in one direction, done with a lookup table (generic enums are indices to that table). * GL classes taking the formats directly (such as GL::BufferImage) have overloads that take both the GL-specific and generic format. * The generic Image, CompressedImage, ImageView, CompressedImageView, and Trade::ImageData classes now accept the generic formats first-class. However, it's also possible to store an implementation-specific value to cover cases where a generic format enum doesn't have support for a particular format. This is done by wrapping the value using pixelFormatWrap() or compressedPixelFormatWrap(). Particular GPU APIs then assume it's their implementation-specific value and extract the value back using pixelFormatUnwrap() or compressedPixelFormatUnwrap(). There's also an isPixelFormatImplementationSpecific() and isCompressedPixelFormatImplementationSpecific() that distinguishes these values. * Many operations need pixel size and in order to have it even for implementation-specific formats, a corresponding pixelSize() overload is found via ADL on construction and the calculated size stored along the format. Previously the pixel size was only calculated on demand, but that's not possible now. In case such overload is not available, it's possible to pass pixel size manually as well. * In order to support the GL format+type pair, Image, ImageView and Trade::ImageData, there's now an additional untyped formatExtra() field that holds the second value. * The CompressedPixelStorage class is now unconditionally available on all targets, including OpenGL ES and WebGL. However, on OpenGL ES the GL APIs expect that it's all at default values. I attempted to preserve backwards compatibility as much as possible: * The PixelFormat and CompressedPixelFormat enum now contains generic API-independent values. The GL-specific formats are present there, but marked as deprecated. Use either the generic values or GL::PixelFormat (togehter with GL::PixelType) and GL::CompressedPixelFormat instead. There's a lot of ugliness caused by this, but seems to work well. * *Image::type() functions are deprecated as they were too GL-specific. Use formatExtra() and cast it to GL::PixelType instead. * Image constructors take templated format or format+extra arguments, so passing GL-specific values to them should still work.
8 years ago
# Library with graceful assert for testing
add_library(MagnumGLTestLib ${SHARED_OR_STATIC}
$<TARGET_OBJECTS:MagnumGLObjects>
${MagnumGL_FlextGL_SRCS}
${MagnumGL_GracefulAssert_SRCS})
target_include_directories(MagnumGLTestLib PUBLIC
${PROJECT_SOURCE_DIR}/src/MagnumExternal/OpenGL)
set_target_properties(MagnumGLTestLib PROPERTIES
DEBUG_POSTFIX "-d"
FOLDER "Magnum/GL")
target_compile_definitions(MagnumGLTestLib PRIVATE
"CORRADE_GRACEFUL_ASSERT" "MagnumGL_EXPORTS" "FlextGL_EXPORTS")
if(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)
CMake: prefer GLVND if on CMake 3.11. This *did not* make things simpler. At all. Ugh. Can I follow Apple and deprecate GL too?
8 years ago
# If the GLVND library (CMake 3.11+) was found, link to the imported
# target. Otherwise (and also on all systems except Linux) link to the
# classic libGL. Can't use OpenGL_OpenGL_FOUND, because that one is set
# also if GLVND is *not* found. WTF.
if(OPENGL_opengl_LIBRARY)
target_link_libraries(MagnumGLTestLib PUBLIC OpenGL::OpenGL)
else()
target_link_libraries(MagnumGLTestLib PUBLIC ${OPENGL_gl_LIBRARY})
endif()
Split the OpenGL layer out, pt 9: generic pixel formats. This is quite big, so: * There are new Magnum::PixelFormat and Magnum::CompressedPixelFormat enums, which contain generic API-independent formats. In particular, PixelFormat replaces GL::PixelFormat and GL::PixelType with a single value. * There's GL::pixelFormat(), GL::pixelType(), GL::compressedPixelFormat() to convert the generic enums to GL-specific. The mapping is only in one direction, done with a lookup table (generic enums are indices to that table). * GL classes taking the formats directly (such as GL::BufferImage) have overloads that take both the GL-specific and generic format. * The generic Image, CompressedImage, ImageView, CompressedImageView, and Trade::ImageData classes now accept the generic formats first-class. However, it's also possible to store an implementation-specific value to cover cases where a generic format enum doesn't have support for a particular format. This is done by wrapping the value using pixelFormatWrap() or compressedPixelFormatWrap(). Particular GPU APIs then assume it's their implementation-specific value and extract the value back using pixelFormatUnwrap() or compressedPixelFormatUnwrap(). There's also an isPixelFormatImplementationSpecific() and isCompressedPixelFormatImplementationSpecific() that distinguishes these values. * Many operations need pixel size and in order to have it even for implementation-specific formats, a corresponding pixelSize() overload is found via ADL on construction and the calculated size stored along the format. Previously the pixel size was only calculated on demand, but that's not possible now. In case such overload is not available, it's possible to pass pixel size manually as well. * In order to support the GL format+type pair, Image, ImageView and Trade::ImageData, there's now an additional untyped formatExtra() field that holds the second value. * The CompressedPixelStorage class is now unconditionally available on all targets, including OpenGL ES and WebGL. However, on OpenGL ES the GL APIs expect that it's all at default values. I attempted to preserve backwards compatibility as much as possible: * The PixelFormat and CompressedPixelFormat enum now contains generic API-independent values. The GL-specific formats are present there, but marked as deprecated. Use either the generic values or GL::PixelFormat (togehter with GL::PixelType) and GL::CompressedPixelFormat instead. There's a lot of ugliness caused by this, but seems to work well. * *Image::type() functions are deprecated as they were too GL-specific. Use formatExtra() and cast it to GL::PixelType instead. * Image constructors take templated format or format+extra arguments, so passing GL-specific values to them should still work.
8 years ago
elseif(TARGET_GLES2)
target_link_libraries(MagnumGLTestLib PUBLIC OpenGLES2::OpenGLES2)
else()
target_link_libraries(MagnumGLTestLib PUBLIC OpenGLES3::OpenGLES3)
endif()
# On Windows we need to install first and then run the tests to avoid "DLL
# not found" hell, thus we need to install this too
if(CORRADE_TARGET_WINDOWS AND NOT CMAKE_CROSSCOMPILING AND NOT BUILD_STATIC)
install(TARGETS MagnumGLTestLib
RUNTIME DESTINATION ${MAGNUM_BINARY_INSTALL_DIR}
LIBRARY DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR}
ARCHIVE DESTINATION ${MAGNUM_LIBRARY_INSTALL_DIR})
endif()
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
add_subdirectory(Test)
endif()
# Magnum GL library target alias for superprojects
add_library(Magnum::GL ALIAS MagnumGL)