ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Convert all argument / return SFINAE into template argument SFINAE. 

Similarly as done in Aug 2024 in Corrade. When these were a part of the
function signature, they ended up being encoded into the exported
symbol. There are still cases of StridedArrayView slice() having
enable_if in the signature, which amounts to about 18 kB symbols in all
libMagnum*-d.so libraries, but apart from that this is the state before:

    $ strings libMagnum*-d.so | grep enable_if | grep -v slice | wc -c
    29591

And this is after. All of those are coming from STL, thus from
old or deprecated APIs that still use std::vector, std::tuple and such,
and from the few std::sort() uses.

    $ strings libMagnum*-d.so | grep enable_if | grep -v slice | wc -c
    4103

In a non-deprecated build it's just this, which is a 10x reduction.
Can't really do much about these maybe exceút for implementing my own
swap() specializations (sigh?), but I think it's fine.

    $ strings libMagnum*-d.so | grep enable_if | grep -v slice | wc -c
    2904

I also made it consistently use

    typename std::enable_if<..., int>::type = 0

instead of

    class = typename std::enable_if<...>::type

because the former works correctly also in presence of overloads and
having it used consistently everywhere makes it easier to grep & change
later. All SFINAE is now also excluded from Doxygen output, because it
doesn't make much sense there. It's better to just explain the
restriction in words than with this nasty hack.
pull/674/head
Vladimír Vondruš 1 year ago
parent
0ee9c0b8e6
commit
02a0960d12
37 changed files with 601 additions and 459 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 12
      src/Magnum/AbstractResourceLoader.h
  2. 6
      src/Magnum/Animation/Track.h
  3. 13
      src/Magnum/Array.h
  4. 6
      src/Magnum/GL/Attribute.h
  5. 6
      src/Magnum/GL/Context.h
  6. 14
      src/Magnum/GL/Mesh.h
  7. 10
      src/Magnum/GL/MultisampleTexture.h
  8. 3
      src/Magnum/GL/Shader.h
  9. 12
      src/Magnum/GL/Texture.h
  10. 4
      src/Magnum/GL/TextureArray.h
  11. 4
      src/Magnum/Image.h
  12. 40
      src/Magnum/ImageView.h
  13. 6
      src/Magnum/Math/Bezier.h
  14. 27
      src/Magnum/Math/BitVector.h
  15. 64
      src/Magnum/Math/Color.h
  16. 17
      src/Magnum/Math/CubicHermite.h
  17. 31
      src/Magnum/Math/Dual.h
  18. 116
      src/Magnum/Math/Functions.h
  19. 2
      src/Magnum/Math/FunctionsBatch.h
  20. 10
      src/Magnum/Math/Packing.h
  21. 8
      src/Magnum/Math/Range.h
  22. 4
      src/Magnum/Math/Test/TypeTraitsTest.cpp
  23. 12
      src/Magnum/Math/TypeTraits.h
  24. 73
      src/Magnum/Math/Unit.h
  25. 342
      src/Magnum/Math/Vector.h
  26. 16
      src/Magnum/Math/Vector2.h
  27. 8
      src/Magnum/MeshTools/Interleave.h
  28. 4
      src/Magnum/Platform/ScreenedApplication.h
  29. 2
      src/Magnum/SceneGraph/AbstractFeature.h
  30. 2
      src/Magnum/SceneGraph/Animable.h
  31. 2
      src/Magnum/SceneGraph/Camera.h
  32. 2
      src/Magnum/SceneGraph/Drawable.h
  33. 30
      src/Magnum/Trade/MaterialData.h
  34. 72
      src/Magnum/Trade/MeshData.h
  35. 66
      src/Magnum/Trade/SceneData.h
  36. 12
      src/Magnum/Vk/Extensions.h
  37. 2
      src/Magnum/Vk/Implementation/structureHelpers.h

12
src/Magnum/AbstractResourceLoader.h
Unescape View File

@ -152,7 +152,11 @@ template<class T> class AbstractResourceLoader {
} }
/** @overload */ /** @overload */
template<class U, class = typename std::enable_if<!std::is_same<typename std::decay<U>::type, std::nullptr_t>::value>::type> void set(ResourceKey key, U&& data, ResourceDataState state, ResourcePolicy policy) { template<class U
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<!std::is_same<typename std::decay<U>::type, std::nullptr_t>::value, int>::type = 0
#endif
> void set(ResourceKey key, U&& data, ResourceDataState state, ResourcePolicy policy) {
set(key, new typename std::decay<U>::type(std::forward<U>(data)), state, policy); set(key, new typename std::decay<U>::type(std::forward<U>(data)), state, policy);
} }
@ -172,7 +176,11 @@ template<class T> class AbstractResourceLoader {
} }
/** @overload */ /** @overload */
template<class U, class = typename std::enable_if<!std::is_same<typename std::decay<U>::type, std::nullptr_t>::value>::type> void set(ResourceKey key, U&& data) { template<class U
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<!std::is_same<typename std::decay<U>::type, std::nullptr_t>::value, int>::type = 0
#endif
> void set(ResourceKey key, U&& data) {
set(key, new typename std::decay<U>::type(std::forward<U>(data))); set(key, new typename std::decay<U>::type(std::forward<U>(data)));
} }

6
src/Magnum/Animation/Track.h
Unescape View File

@ -734,7 +734,11 @@ template<class K, class V, class R
/** @brief Convert a mutable view to a const one */ /** @brief Convert a mutable view to a const one */
/* This is the only variant that works on MSVC 2015, std::remove_const /* This is the only variant that works on MSVC 2015, std::remove_const
in the signature didn't work there */ in the signature didn't work there */
template<class K2, class V2, class = typename std::enable_if<std::is_same<const K2, K>::value && std::is_same<const V2, V>::value>::type> /*implicit*/ TrackView(const TrackView<K2, V2, R>& other) noexcept: TrackViewStorage<K>{other._keys, other._values, other._interpolation, other._interpolator, other._before, other._after} {} template<class K2, class V2
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<std::is_same<const K2, K>::value && std::is_same<const V2, V>::value, int>::type = 0
#endif
> /*implicit*/ TrackView(const TrackView<K2, V2, R>& other) noexcept: TrackViewStorage<K>{other._keys, other._values, other._interpolation, other._interpolator, other._before, other._after} {}
/** /**
* @brief Interpolation function * @brief Interpolation function

13
src/Magnum/Array.h
Unescape View File

@ -82,11 +82,11 @@ template<UnsignedInt dimensions, class T> class CORRADE_DEPRECATED("use Math::Ve
* @param first First value * @param first First value
* @param next Next values * @param next Next values
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class ...U
template<class ...U> constexpr /*implicit*/ Array(T first, U... next); #ifndef DOXYGEN_GENERATING_OUTPUT
#else , typename std::enable_if<sizeof...(U)+1 == dimensions, int>::type = 0
template<class ...U, class V = typename std::enable_if<sizeof...(U)+1 == dimensions, T>::type> constexpr /*implicit*/ Array(T first, U... next): _data{first, next...} {} #endif
#endif > constexpr /*implicit*/ Array(T first, U... next): _data{first, next...} {}
/** @brief Construct array with one value for all fields */ /** @brief Construct array with one value for all fields */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifdef DOXYGEN_GENERATING_OUTPUT
@ -95,8 +95,7 @@ template<UnsignedInt dimensions, class T> class CORRADE_DEPRECATED("use Math::Ve
#ifdef CORRADE_TARGET_MSVC /* MSVC warns for the constructor delegation */ #ifdef CORRADE_TARGET_MSVC /* MSVC warns for the constructor delegation */
CORRADE_IGNORE_DEPRECATED_PUSH CORRADE_IGNORE_DEPRECATED_PUSH
#endif #endif
template<class U, class V = typename std::enable_if<std::is_same<T, U>::value && dimensions != 1, T>::type> template<class U, typename std::enable_if<std::is_same<T, U>::value && dimensions != 1, int>::type = 0> constexpr /*implicit*/ Array(U value): Array(typename Containers::Implementation::GenerateSequence<dimensions>::Type{}, value) {}
constexpr /*implicit*/ Array(U value): Array(typename Containers::Implementation::GenerateSequence<dimensions>::Type{}, value) {}
#ifdef CORRADE_TARGET_MSVC #ifdef CORRADE_TARGET_MSVC
CORRADE_IGNORE_DEPRECATED_POP CORRADE_IGNORE_DEPRECATED_POP
#endif #endif

6
src/Magnum/GL/Attribute.h
Unescape View File

@ -786,18 +786,18 @@ MAGNUM_GL_EXPORT bool hasVertexFormat(Magnum::VertexFormat format);
namespace Implementation { namespace Implementation {
template<UnsignedInt location, class T> constexpr DynamicAttribute::Kind kindFor(typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Float>::value, typename GL::Attribute<location, T>::DataOptions>::type options) { template<UnsignedInt location, class T, typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Float>::value, int>::type = 0> constexpr DynamicAttribute::Kind kindFor(typename GL::Attribute<location, T>::DataOptions options) {
return options & GL::Attribute<location, T>::DataOption::Normalized ? return options & GL::Attribute<location, T>::DataOption::Normalized ?
DynamicAttribute::Kind::GenericNormalized : DynamicAttribute::Kind::Generic; DynamicAttribute::Kind::GenericNormalized : DynamicAttribute::Kind::Generic;
} }
#ifndef MAGNUM_TARGET_GLES2 #ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt location, class T> constexpr DynamicAttribute::Kind kindFor(typename std::enable_if<std::is_integral<typename Implementation::Attribute<T>::ScalarType>::value, typename GL::Attribute<location, T>::DataOptions>::type) { template<UnsignedInt location, class T, typename std::enable_if<std::is_integral<typename Implementation::Attribute<T>::ScalarType>::value, int>::type = 0> constexpr DynamicAttribute::Kind kindFor(typename GL::Attribute<location, T>::DataOptions) {
return DynamicAttribute::Kind::Integral; return DynamicAttribute::Kind::Integral;
} }
#ifndef MAGNUM_TARGET_GLES #ifndef MAGNUM_TARGET_GLES
template<UnsignedInt location, class T> constexpr DynamicAttribute::Kind kindFor(typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Double>::value, typename GL::Attribute<location, T>::DataOptions>::type) { template<UnsignedInt location, class T, typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Double>::value, int>::type = 0> constexpr DynamicAttribute::Kind kindFor(typename GL::Attribute<location, T>::DataOptions) {
return DynamicAttribute::Kind::Long; return DynamicAttribute::Kind::Long;
} }
#endif #endif

6
src/Magnum/GL/Context.h
Unescape View File

@ -109,7 +109,11 @@ class MAGNUM_GL_EXPORT Extension {
constexpr const char* string() const { return _string; } constexpr const char* string() const { return _string; }
/** @brief Construct from a compile-time extension */ /** @brief Construct from a compile-time extension */
template<class E, class = typename std::enable_if<Implementation::IsExtension<E>::value>::type> constexpr /*implicit*/ Extension(const E&): _index{E::Index}, _requiredVersion{E::requiredVersion()}, _coreVersion{E::coreVersion()}, _string{E::string()} {} template<class E
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<Implementation::IsExtension<E>::value, int>::type = 0
#endif
> constexpr /*implicit*/ Extension(const E&): _index{E::Index}, _requiredVersion{E::requiredVersion()}, _coreVersion{E::coreVersion()}, _string{E::string()} {}
private: private:
std::size_t _index; std::size_t _index;

14
src/Magnum/GL/Mesh.h
Unescape View File

@ -911,7 +911,7 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
template<class ...T template<class ...T
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
/* So it doesn't clash with the DynamicAttribute overload */ /* So it doesn't clash with the DynamicAttribute overload */
, class = typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value>::type , typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value, int>::type = 0
#endif #endif
> Mesh& addVertexBuffer(Buffer& buffer, GLintptr offset, const T&... attributes) { > Mesh& addVertexBuffer(Buffer& buffer, GLintptr offset, const T&... attributes) {
addVertexBufferInternal(buffer, offset, strideOfInterleaved(attributes...), 0, attributes...); addVertexBufferInternal(buffer, offset, strideOfInterleaved(attributes...), 0, attributes...);
@ -952,7 +952,7 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
template<class ...T template<class ...T
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
/* So it doesn't clash with the DynamicAttribute overload */ /* So it doesn't clash with the DynamicAttribute overload */
, class = typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value>::type , typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value, int>::type = 0
#endif #endif
> Mesh& addVertexBufferInstanced(Buffer& buffer, UnsignedInt divisor, GLintptr offset, const T&... attributes) { > Mesh& addVertexBufferInstanced(Buffer& buffer, UnsignedInt divisor, GLintptr offset, const T&... attributes) {
addVertexBufferInternal(buffer, offset, strideOfInterleaved(attributes...), divisor, attributes...); addVertexBufferInternal(buffer, offset, strideOfInterleaved(attributes...), divisor, attributes...);
@ -996,7 +996,7 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
template<class ...T template<class ...T
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
/* So it doesn't clash with the DynamicAttribute overload */ /* So it doesn't clash with the DynamicAttribute overload */
, class = typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value>::type , typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value, int>::type = 0
#endif #endif
> Mesh& addVertexBuffer(Buffer&& buffer, GLintptr offset, const T&... attributes) { > Mesh& addVertexBuffer(Buffer&& buffer, GLintptr offset, const T&... attributes) {
addVertexBuffer<T...>(buffer, offset, attributes...); addVertexBuffer<T...>(buffer, offset, attributes...);
@ -1015,7 +1015,7 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
template<class ...T template<class ...T
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
/* So it doesn't clash with the DynamicAttribute overload */ /* So it doesn't clash with the DynamicAttribute overload */
, class = typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value>::type , typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value, int>::type = 0
#endif #endif
> Mesh& addVertexBufferInstanced(Buffer&& buffer, UnsignedInt divisor, GLintptr offset, const T&... attributes) { > Mesh& addVertexBufferInstanced(Buffer&& buffer, UnsignedInt divisor, GLintptr offset, const T&... attributes) {
addVertexBufferInstanced<T...>(buffer, divisor, offset, attributes...); addVertexBufferInstanced<T...>(buffer, divisor, offset, attributes...);
@ -1224,7 +1224,7 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
} }
void addVertexBufferInternal(Buffer&, GLintptr, GLsizei, GLuint) {} void addVertexBufferInternal(Buffer&, GLintptr, GLsizei, GLuint) {}
template<UnsignedInt location, class T> void addVertexAttribute(typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Float>::value, Buffer&>::type buffer, const Attribute<location, T>& attribute, GLintptr offset, GLsizei stride, GLuint divisor) { template<UnsignedInt location, class T, typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Float>::value, int>::type = 0> void addVertexAttribute(Buffer& buffer, const Attribute<location, T>& attribute, GLintptr offset, GLsizei stride, GLuint divisor) {
for(UnsignedInt i = 0; i != Attribute<location, T>::Vectors; ++i) for(UnsignedInt i = 0; i != Attribute<location, T>::Vectors; ++i)
attributePointerInternal(buffer, attributePointerInternal(buffer,
location+i, location+i,
@ -1237,7 +1237,7 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
} }
#ifndef MAGNUM_TARGET_GLES2 #ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt location, class T> void addVertexAttribute(typename std::enable_if<std::is_integral<typename Implementation::Attribute<T>::ScalarType>::value, Buffer&>::type buffer, const Attribute<location, T>& attribute, GLintptr offset, GLsizei stride, GLuint divisor) { template<UnsignedInt location, class T, typename std::enable_if<std::is_integral<typename Implementation::Attribute<T>::ScalarType>::value, int>::type = 0> void addVertexAttribute(Buffer& buffer, const Attribute<location, T>& attribute, GLintptr offset, GLsizei stride, GLuint divisor) {
attributePointerInternal(buffer, attributePointerInternal(buffer,
location, location,
GLint(attribute.components()), GLint(attribute.components()),
@ -1249,7 +1249,7 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
} }
#ifndef MAGNUM_TARGET_GLES #ifndef MAGNUM_TARGET_GLES
template<UnsignedInt location, class T> void addVertexAttribute(typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Double>::value, Buffer&>::type buffer, const Attribute<location, T>& attribute, GLintptr offset, GLsizei stride, GLuint divisor) { template<UnsignedInt location, class T, typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Double>::value, int>::type = 0> void addVertexAttribute(Buffer& buffer, const Attribute<location, T>& attribute, GLintptr offset, GLsizei stride, GLuint divisor) {
for(UnsignedInt i = 0; i != Attribute<location, T>::Vectors; ++i) for(UnsignedInt i = 0; i != Attribute<location, T>::Vectors; ++i)
attributePointerInternal(buffer, attributePointerInternal(buffer,
location+i, location+i,

10
src/Magnum/GL/MultisampleTexture.h
Unescape View File

@ -165,7 +165,7 @@ MultisampleTexture: public AbstractTexture {
* @gl_extension{EXT,texture_view} * @gl_extension{EXT,texture_view}
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 2>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d == 2, int>::type = 0>
#endif #endif
static MultisampleTexture<dimensions> view(MultisampleTexture2DArray& original, TextureFormat internalFormat, Int layer); static MultisampleTexture<dimensions> view(MultisampleTexture2DArray& original, TextureFormat internalFormat, Int layer);
@ -186,7 +186,7 @@ MultisampleTexture: public AbstractTexture {
* @gl_extension{EXT,texture_view} * @gl_extension{EXT,texture_view}
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 3>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d == 3, int>::type = 0>
#endif #endif
static MultisampleTexture<dimensions> view(MultisampleTexture2DArray& original, TextureFormat internalFormat, Int layerOffset, Int layerCount); static MultisampleTexture<dimensions> view(MultisampleTexture2DArray& original, TextureFormat internalFormat, Int layerOffset, Int layerCount);
@ -252,7 +252,7 @@ MultisampleTexture: public AbstractTexture {
* @requires_gl42 Extension @gl_extension{ARB,shader_image_load_store} * @requires_gl42 Extension @gl_extension{ARB,shader_image_load_store}
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 2>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d == 2, int>::type = 0>
#endif #endif
void bindImage(Int imageUnit, ImageAccess access, ImageFormat format) { void bindImage(Int imageUnit, ImageAccess access, ImageFormat format) {
bindImageInternal(imageUnit, 0, false, 0, access, format); bindImageInternal(imageUnit, 0, false, 0, access, format);
@ -279,7 +279,7 @@ MultisampleTexture: public AbstractTexture {
* multisample 2D array textures. * multisample 2D array textures.
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 3>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d == 3, int>::type = 0>
#endif #endif
void bindImage(Int imageUnit, Int layer, ImageAccess access, ImageFormat format) { void bindImage(Int imageUnit, Int layer, ImageAccess access, ImageFormat format) {
bindImageInternal(imageUnit, 0, false, layer, access, format); bindImageInternal(imageUnit, 0, false, layer, access, format);
@ -305,7 +305,7 @@ MultisampleTexture: public AbstractTexture {
* multisample 2D array textures. * multisample 2D array textures.
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 3>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d == 3, int>::type = 0>
#endif #endif
void bindImageLayered(Int imageUnit, ImageAccess access, ImageFormat format) { void bindImageLayered(Int imageUnit, ImageAccess access, ImageFormat format) {
bindImageInternal(imageUnit, 0, true, 0, access, format); bindImageInternal(imageUnit, 0, true, 0, access, format);

3
src/Magnum/GL/Shader.h
Unescape View File

@ -716,8 +716,7 @@ class MAGNUM_GL_EXPORT Shader: public AbstractObject {
#else #else
/* Otherwise passing a char* is ambiguous between this and the /* Otherwise passing a char* is ambiguous between this and the
StringView overload. Sigh, C++. */ StringView overload. Sigh, C++. */
template<class U, class = typename std::enable_if<std::is_same<U&&, Containers::String&&>::value>::type> template<class U, typename std::enable_if<std::is_same<U&&, Containers::String&&>::value, int>::type = 0> Shader& addSource(U&& source) {
Shader& addSource(U&& source) {
return addSourceInternal(Utility::move(source)); return addSourceInternal(Utility::move(source));
} }
#endif #endif

12
src/Magnum/GL/Texture.h
Unescape View File

@ -196,7 +196,7 @@ Texture: public AbstractTexture {
* @requires_gles Texture views are not available in WebGL. * @requires_gles Texture views are not available in WebGL.
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d <= 2>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d <= 2, int>::type = 0>
#endif #endif
static Texture<dimensions> view(TextureArray<dimensions>& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layer); static Texture<dimensions> view(TextureArray<dimensions>& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layer);
@ -217,7 +217,7 @@ Texture: public AbstractTexture {
* @requires_gles Texture views are not available in WebGL. * @requires_gles Texture views are not available in WebGL.
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 2>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d == 2, int>::type = 0>
#endif #endif
static Texture<dimensions> view(CubeMapTexture& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layer); static Texture<dimensions> view(CubeMapTexture& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layer);
@ -238,7 +238,7 @@ Texture: public AbstractTexture {
* @requires_gles Texture views are not available in WebGL. * @requires_gles Texture views are not available in WebGL.
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 2>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d == 2, int>::type = 0>
#endif #endif
static Texture<dimensions> view(CubeMapTextureArray& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layer); static Texture<dimensions> view(CubeMapTextureArray& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layer);
#endif #endif
@ -320,7 +320,7 @@ Texture: public AbstractTexture {
* @requires_gles Shader image load/store is not available in WebGL. * @requires_gles Shader image load/store is not available in WebGL.
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 1 || d == 2>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d == 1 || d == 2, int>::type = 0>
#endif #endif
void bindImage(Int imageUnit, Int level, ImageAccess access, ImageFormat format) { void bindImage(Int imageUnit, Int level, ImageAccess access, ImageFormat format) {
bindImageInternal(imageUnit, level, false, 0, access, format); bindImageInternal(imageUnit, level, false, 0, access, format);
@ -348,7 +348,7 @@ Texture: public AbstractTexture {
* @requires_gles Shader image load/store is not available in WebGL. * @requires_gles Shader image load/store is not available in WebGL.
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 3>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d == 3, int>::type = 0>
#endif #endif
void bindImage(Int imageUnit, Int level, Int layer, ImageAccess access, ImageFormat format) { void bindImage(Int imageUnit, Int level, Int layer, ImageAccess access, ImageFormat format) {
bindImageInternal(imageUnit, level, false, layer, access, format); bindImageInternal(imageUnit, level, false, layer, access, format);
@ -375,7 +375,7 @@ Texture: public AbstractTexture {
* @requires_gles Shader image load/store is not available in WebGL. * @requires_gles Shader image load/store is not available in WebGL.
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 3>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d == 3, int>::type = 0>
#endif #endif
void bindImageLayered(Int imageUnit, Int level, ImageAccess access, ImageFormat format) { void bindImageLayered(Int imageUnit, Int level, ImageAccess access, ImageFormat format) {
bindImageInternal(imageUnit, level, true, 0, access, format); bindImageInternal(imageUnit, level, true, 0, access, format);

4
src/Magnum/GL/TextureArray.h
Unescape View File

@ -199,7 +199,7 @@ TextureArray: public AbstractTexture {
* @requires_gles Texture views are not available in WebGL. * @requires_gles Texture views are not available in WebGL.
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 2>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d == 2, int>::type = 0>
#endif #endif
static TextureArray<dimensions> view(CubeMapTexture& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layerOffset, Int layerCount); static TextureArray<dimensions> view(CubeMapTexture& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layerOffset, Int layerCount);
@ -220,7 +220,7 @@ TextureArray: public AbstractTexture {
* @requires_gles Texture views are not available in WebGL. * @requires_gles Texture views are not available in WebGL.
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 2>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d == 2, int>::type = 0>
#endif #endif
static TextureArray<dimensions> view(CubeMapTextureArray& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layerOffset, Int layerCount); static TextureArray<dimensions> view(CubeMapTextureArray& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layerOffset, Int layerCount);
#endif #endif

4
src/Magnum/Image.h
Unescape View File

@ -358,9 +358,9 @@ template<UnsignedInt dimensions> class Image {
template<class T template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
/* Otherwise this catches too much, resulting in weird errors */ /* Otherwise this catches too much, resulting in weird errors */
, class = typename std::enable_if<std::is_enum<T>::value || std::is_integral<T>::value>::type , typename std::enable_if<std::is_enum<T>::value || std::is_integral<T>::value, int>::type = 0
#endif #endif
> /*implicit*/ Image(T format) noexcept: Image{{}, format} {} > /*implicit*/ Image(T format) noexcept: Image{{}, format} {}
/** @brief Copying is not allowed */ /** @brief Copying is not allowed */
Image(const Image<dimensions>&) = delete; Image(const Image<dimensions>&) = delete;

40
src/Magnum/ImageView.h
Unescape View File

@ -424,13 +424,21 @@ template<UnsignedInt dimensions, class T> class ImageView {
* there's no concept of 2D arrays of 1D images. Use the @p flags * there's no concept of 2D arrays of 1D images. Use the @p flags
* parameter to add arbitrary other flags. * parameter to add arbitrary other flags.
*/ */
template<UnsignedInt otherDimensions, class = typename std::enable_if<(otherDimensions < dimensions)>::type> /*implicit*/ ImageView(const ImageView<otherDimensions, T>& other, ImageFlags<dimensions> flags = {}) noexcept; template<UnsignedInt otherDimensions
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<(otherDimensions < dimensions), int>::type = 0
#endif
> /*implicit*/ ImageView(const ImageView<otherDimensions, T>& other, ImageFlags<dimensions> flags = {}) noexcept;
/** /**
* @brief Convert a mutable view to a const one * @brief Convert a mutable view to a const one
* @m_since{2019,10} * @m_since{2019,10}
*/ */
template<class U, class = typename std::enable_if<std::is_const<T>::value && !std::is_const<U>::value>::type> /*implicit*/ ImageView(const ImageView<dimensions, U>& other) noexcept; template<class U
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<std::is_const<T>::value && !std::is_const<U>::value, int>::type = 0
#endif
> /*implicit*/ ImageView(const ImageView<dimensions, U>& other) noexcept;
/** /**
* @brief Layout flags * @brief Layout flags
@ -830,13 +838,21 @@ template<UnsignedInt dimensions, class T> class CompressedImageView {
* there's no concept of 2D arrays of 1D images. Use the @p flags * there's no concept of 2D arrays of 1D images. Use the @p flags
* parameter to add arbitrary other flags. * parameter to add arbitrary other flags.
*/ */
template<UnsignedInt otherDimensions, class = typename std::enable_if<(otherDimensions < dimensions)>::type> /*implicit*/ CompressedImageView(const CompressedImageView<otherDimensions, T>& other, ImageFlags<dimensions> flags = {}) noexcept; template<UnsignedInt otherDimensions
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<(otherDimensions < dimensions), int>::type = 0
#endif
> /*implicit*/ CompressedImageView(const CompressedImageView<otherDimensions, T>& other, ImageFlags<dimensions> flags = {}) noexcept;
/** /**
* @brief Convert a mutable view to a const one * @brief Convert a mutable view to a const one
* @m_since{2019,10} * @m_since{2019,10}
*/ */
template<class U, class = typename std::enable_if<std::is_const<T>::value && !std::is_const<U>::value>::type> /*implicit*/ CompressedImageView(const CompressedImageView<dimensions, U>& other) noexcept; template<class U
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<std::is_const<T>::value && !std::is_const<U>::value, int>::type = 0
#endif
> /*implicit*/ CompressedImageView(const CompressedImageView<dimensions, U>& other) noexcept;
/** /**
* @brief Layout flags * @brief Layout flags
@ -994,8 +1010,8 @@ template<UnsignedInt dimensions, class T> template<class U> inline ImageView<dim
"format types larger than 32bits are not supported"); "format types larger than 32bits are not supported");
} }
#ifndef DOXYGEN_GENERATING_OUTPUT /* it complains otherwise. why? don't know, don't want to know */ #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt dimensions, class T> template<UnsignedInt otherDimensions, class> ImageView<dimensions, T>::ImageView(const ImageView<otherDimensions, T>& other, const ImageFlags<dimensions> flags) noexcept: template<UnsignedInt dimensions, class T> template<UnsignedInt otherDimensions, typename std::enable_if<(otherDimensions < dimensions), int>::type> ImageView<dimensions, T>::ImageView(const ImageView<otherDimensions, T>& other, const ImageFlags<dimensions> flags) noexcept:
_storage{other._storage}, _storage{other._storage},
_format{other._format}, _format{other._format},
_formatExtra{other._formatExtra}, _formatExtra{other._formatExtra},
@ -1004,9 +1020,9 @@ template<UnsignedInt dimensions, class T> template<UnsignedInt otherDimensions,
_flags{ImageFlag<dimensions>(UnsignedShort(other._flags)&~UnsignedShort(ImageFlag2D::Array))|flags}, _flags{ImageFlag<dimensions>(UnsignedShort(other._flags)&~UnsignedShort(ImageFlag2D::Array))|flags},
_size{Math::Vector<dimensions, Int>::pad(other._size, 1)}, _size{Math::Vector<dimensions, Int>::pad(other._size, 1)},
_data{other._data} {} _data{other._data} {}
#endif
template<UnsignedInt dimensions, class T> template<class U, class> ImageView<dimensions, T>::ImageView(const ImageView<dimensions, U>& other) noexcept: _storage{other._storage}, _format{other._format}, _formatExtra{other._formatExtra}, _pixelSize{other._pixelSize}, _flags{other._flags}, _size{other._size}, _data{other._data} {} template<UnsignedInt dimensions, class T> template<class U, typename std::enable_if<std::is_const<T>::value && !std::is_const<U>::value, int>::type> ImageView<dimensions, T>::ImageView(const ImageView<dimensions, U>& other) noexcept: _storage{other._storage}, _format{other._format}, _formatExtra{other._formatExtra}, _pixelSize{other._pixelSize}, _flags{other._flags}, _size{other._size}, _data{other._data} {}
#endif
template<UnsignedInt dimensions, class T> template<class U> inline CompressedImageView<dimensions, T>::CompressedImageView(const CompressedPixelStorage storage, const U format, const VectorTypeFor<dimensions, Int>& size, const Containers::ArrayView<ErasedType> data, const ImageFlags<dimensions> flags) noexcept: CompressedImageView{storage, UnsignedInt(format), size, data, flags} { template<UnsignedInt dimensions, class T> template<class U> inline CompressedImageView<dimensions, T>::CompressedImageView(const CompressedPixelStorage storage, const U format, const VectorTypeFor<dimensions, Int>& size, const Containers::ArrayView<ErasedType> data, const ImageFlags<dimensions> flags) noexcept: CompressedImageView{storage, UnsignedInt(format), size, data, flags} {
static_assert(sizeof(U) <= 4, static_assert(sizeof(U) <= 4,
@ -1018,17 +1034,17 @@ template<UnsignedInt dimensions, class T> template<class U> inline CompressedIma
"format types larger than 32bits are not supported"); "format types larger than 32bits are not supported");
} }
#ifndef DOXYGEN_GENERATING_OUTPUT /* it complains otherwise. why? don't know, don't want to know */ #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt dimensions, class T> template<UnsignedInt otherDimensions, class> CompressedImageView<dimensions, T>::CompressedImageView(const CompressedImageView<otherDimensions, T>& other, const ImageFlags<dimensions> flags) noexcept: template<UnsignedInt dimensions, class T> template<UnsignedInt otherDimensions, typename std::enable_if<(otherDimensions < dimensions), int>::type> CompressedImageView<dimensions, T>::CompressedImageView(const CompressedImageView<otherDimensions, T>& other, const ImageFlags<dimensions> flags) noexcept:
_storage{other._storage}, _storage{other._storage},
_format{other._format}, _format{other._format},
/* Removing the Array bit and transferring the rest, as documented */ /* Removing the Array bit and transferring the rest, as documented */
_flags{ImageFlag<dimensions>(UnsignedShort(other._flags)&~UnsignedShort(ImageFlag2D::Array))|flags}, _flags{ImageFlag<dimensions>(UnsignedShort(other._flags)&~UnsignedShort(ImageFlag2D::Array))|flags},
_size{Math::Vector<dimensions, Int>::pad(other._size, 1)}, _size{Math::Vector<dimensions, Int>::pad(other._size, 1)},
_data{other._data} {} _data{other._data} {}
#endif
template<UnsignedInt dimensions, class T> template<class U, class> CompressedImageView<dimensions, T>::CompressedImageView(const CompressedImageView<dimensions, U>& other) noexcept: _storage{other._storage}, _format{other._format}, _flags{other._flags}, _size{other._size}, _data{other._data} {} template<UnsignedInt dimensions, class T> template<class U, typename std::enable_if<std::is_const<T>::value && !std::is_const<U>::value, int>::type> CompressedImageView<dimensions, T>::CompressedImageView(const CompressedImageView<dimensions, U>& other) noexcept: _storage{other._storage}, _format{other._format}, _flags{other._flags}, _size{other._size}, _data{other._data} {}
#endif
} }

6
src/Magnum/Math/Bezier.h
Unescape View File

@ -119,11 +119,9 @@ template<UnsignedInt order, UnsignedInt dimensions, class T> class Bezier {
* inverse operation. * inverse operation.
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt order_ = order> static typename std::enable_if<order_ == 3, Bezier<order, dimensions, T>>::type template<UnsignedInt order_ = order, typename std::enable_if<order_ == 3, int>::type = 0>
#else
static Bezier<order, dimensions, T>
#endif #endif
fromCubicHermite(const CubicHermite<VectorType>& a, const CubicHermite<VectorType>& b) { static Bezier<order, dimensions, T> fromCubicHermite(const CubicHermite<VectorType>& a, const CubicHermite<VectorType>& b) {
return {a.point(), a.outTangent()/T(3) - a.point(), b.point() - b.inTangent()/T(3), b.point()}; return {a.point(), a.outTangent()/T(3) - a.point(), b.point() - b.inTangent()/T(3), b.point()};
} }

27
src/Magnum/Math/BitVector.h
Unescape View File

@ -112,18 +112,25 @@ template<std::size_t size> class BitVector {
* @param first Value for first 8bit segment * @param first Value for first 8bit segment
* @param next Values for next Bbit segments * @param next Values for next Bbit segments
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class ...T
template<class ...T> constexpr /*implicit*/ BitVector(UnsignedByte first, T... next) noexcept; #ifndef DOXYGEN_GENERATING_OUTPUT
#else /* For some reason MSVC 2015 and 2017 doesn't understand the value
template<class ...T, class U = typename std::enable_if<sizeof...(T)+1 == DataSize, bool>::type> constexpr /*implicit*/ BitVector(UnsignedByte first, T... next) noexcept: _data{first, UnsignedByte(next)...} {} parameter here, only a type parameter. Don't need to prevent any
#endif ambiguity with this constructor so it's fine. */
#ifndef CORRADE_MSVC2017_COMPATIBILITY
, typename std::enable_if<sizeof...(T)+1 == DataSize, int>::type = 0
#else
, class = typename std::enable_if<sizeof...(T)+1 == DataSize>::type
#endif
#endif
> constexpr /*implicit*/ BitVector(UnsignedByte first, T... next) noexcept: _data{first, UnsignedByte(next)...} {}
/** @brief Construct a bit vector with one value for all fields */ /** @brief Construct a bit vector with one value for all fields */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class T
explicit BitVector(T value) noexcept; #ifndef DOXYGEN_GENERATING_OUTPUT
#else , typename std::enable_if<std::is_same<bool, T>::value && size != 1, int>::type = 0
template<class T, class U = typename std::enable_if<std::is_same<bool, T>::value && size != 1, bool>::type> constexpr explicit BitVector(T value) noexcept: BitVector(typename Containers::Implementation::GenerateSequence<DataSize>::Type{}, value ? FullSegmentMask : 0) {} #endif
#endif > constexpr explicit BitVector(T value) noexcept: BitVector(typename Containers::Implementation::GenerateSequence<DataSize>::Type{}, value ? FullSegmentMask : 0) {}
/** @brief Construct a bit vector from external representation */ /** @brief Construct a bit vector from external representation */
template<class U, class = decltype(Implementation::BitVectorConverter<size, U>::from(std::declval<U>()))> constexpr explicit BitVector(const U& other) noexcept: BitVector{Implementation::BitVectorConverter<size, U>::from(other)} {} template<class U, class = decltype(Implementation::BitVectorConverter<size, U>::from(std::declval<U>()))> constexpr explicit BitVector(const U& other) noexcept: BitVector{Implementation::BitVectorConverter<size, U>::from(other)} {}

64
src/Magnum/Math/Color.h
Unescape View File

@ -48,7 +48,7 @@ namespace Magnum { namespace Math {
namespace Implementation { namespace Implementation {
/* Convert color from HSV */ /* Convert color from HSV */
template<class T> typename std::enable_if<IsFloatingPoint<T>::value, Color3<T>>::type fromHsv(ColorHsv<T> hsv) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> Color3<T> fromHsv(ColorHsv<T> hsv) {
/* Remove repeats */ /* Remove repeats */
hsv.hue -= floor(T(hsv.hue)/T(360))*Deg<T>(360); hsv.hue -= floor(T(hsv.hue)/T(360))*Deg<T>(360);
if(hsv.hue < Deg<T>(0)) hsv.hue += Deg<T>(360); if(hsv.hue < Deg<T>(0)) hsv.hue += Deg<T>(360);
@ -70,7 +70,7 @@ template<class T> typename std::enable_if<IsFloatingPoint<T>::value, Color3<T>>:
default: CORRADE_INTERNAL_DEBUG_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */ default: CORRADE_INTERNAL_DEBUG_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
} }
} }
template<class T> inline typename std::enable_if<IsIntegral<T>::value, Color3<T>>::type fromHsv(const ColorHsv<typename TypeTraits<T>::FloatingPointType>& hsv) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Color3<T> fromHsv(const ColorHsv<typename TypeTraits<T>::FloatingPointType>& hsv) {
return pack<Color3<T>>(fromHsv<typename TypeTraits<T>::FloatingPointType>(hsv)); return pack<Color3<T>>(fromHsv<typename TypeTraits<T>::FloatingPointType>(hsv));
} }
@ -92,54 +92,54 @@ template<class T> Deg<T> hue(const Color3<T>& color, T max, T delta) {
} }
/* Hue, saturation, value for floating-point types */ /* Hue, saturation, value for floating-point types */
template<class T> inline Deg<T> hue(typename std::enable_if<IsFloatingPoint<T>::value, const Color3<T>&>::type color) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline Deg<T> hue(const Color3<T>& color) {
T max = color.max(); T max = color.max();
T delta = max - color.min(); T delta = max - color.min();
return hue(color, max, delta); return hue(color, max, delta);
} }
template<class T> inline T saturation(typename std::enable_if<IsFloatingPoint<T>::value, const Color3<T>&>::type color) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline T saturation(const Color3<T>& color) {
T max = color.max(); T max = color.max();
T delta = max - color.min(); T delta = max - color.min();
return max != T(0) ? delta/max : T(0); return max != T(0) ? delta/max : T(0);
} }
template<class T> inline T value(typename std::enable_if<IsFloatingPoint<T>::value, const Color3<T>&>::type color) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline T value(const Color3<T>& color) {
return color.max(); return color.max();
} }
/* Hue, saturation, value for integral types */ /* Hue, saturation, value for integral types */
template<class T> inline Deg<typename Color3<T>::FloatingPointType> hue(typename std::enable_if<IsIntegral<T>::value, const Color3<T>&>::type color) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Deg<typename Color3<T>::FloatingPointType> hue(const Color3<T>& color) {
return hue<typename Color3<T>::FloatingPointType>(unpack<Color3<typename Color3<T>::FloatingPointType>>(color)); return hue<typename Color3<T>::FloatingPointType>(unpack<Color3<typename Color3<T>::FloatingPointType>>(color));
} }
template<class T> inline typename Color3<T>::FloatingPointType saturation(typename std::enable_if<IsIntegral<T>::value, const Color3<T>&>::type& color) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline typename Color3<T>::FloatingPointType saturation(const Color3<T>& color) {
return saturation<typename Color3<T>::FloatingPointType>(unpack<Color3<typename Color3<T>::FloatingPointType>>(color)); return saturation<typename Color3<T>::FloatingPointType>(unpack<Color3<typename Color3<T>::FloatingPointType>>(color));
} }
template<class T> inline typename Color3<T>::FloatingPointType value(typename std::enable_if<IsIntegral<T>::value, const Color3<T>&>::type color) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline typename Color3<T>::FloatingPointType value(const Color3<T>& color) {
return unpack<typename Color3<T>::FloatingPointType>(color.max()); return unpack<typename Color3<T>::FloatingPointType>(color.max());
} }
/* Convert color to HSV */ /* Convert color to HSV */
template<class T> inline ColorHsv<T> toHsv(typename std::enable_if<IsFloatingPoint<T>::value, const Color3<T>&>::type color) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline ColorHsv<T> toHsv(const Color3<T>& color) {
T max = color.max(); T max = color.max();
T delta = max - color.min(); T delta = max - color.min();
return ColorHsv<T>{hue<typename Color3<T>::FloatingPointType>(color, max, delta), max != T(0) ? delta/max : T(0), max}; return ColorHsv<T>{hue<typename Color3<T>::FloatingPointType>(color, max, delta), max != T(0) ? delta/max : T(0), max};
} }
template<class T> inline ColorHsv<typename TypeTraits<T>::FloatingPointType> toHsv(typename std::enable_if<IsIntegral<T>::value, const Color3<T>&>::type color) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline ColorHsv<typename TypeTraits<T>::FloatingPointType> toHsv(const Color3<T>& color) {
return toHsv<typename TypeTraits<T>::FloatingPointType>(unpack<Color3<typename TypeTraits<T>::FloatingPointType>>(color)); return toHsv<typename TypeTraits<T>::FloatingPointType>(unpack<Color3<typename TypeTraits<T>::FloatingPointType>>(color));
} }
/* sRGB -> RGB conversion */ /* sRGB -> RGB conversion */
template<class T> typename std::enable_if<IsFloatingPoint<T>::value, Color3<T>>::type fromSrgb(const Vector3<T>& srgb) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline Color3<T> fromSrgb(const Vector3<T>& srgb) {
constexpr const T a(T(0.055)); constexpr const T a(T(0.055));
return lerp(srgb/T(12.92), pow((srgb + Vector3<T>{a})/(T(1.0) + a), T(2.4)), srgb > Vector3<T>(T(0.04045))); return lerp(srgb/T(12.92), pow((srgb + Vector3<T>{a})/(T(1.0) + a), T(2.4)), srgb > Vector3<T>(T(0.04045)));
} }
template<class T> typename std::enable_if<IsFloatingPoint<T>::value, Color4<T>>::type fromSrgbAlpha(const Vector4<T>& srgbAlpha) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline Color4<T> fromSrgbAlpha(const Vector4<T>& srgbAlpha) {
return {fromSrgb<T>(srgbAlpha.rgb()), srgbAlpha.a()}; return {fromSrgb<T>(srgbAlpha.rgb()), srgbAlpha.a()};
} }
template<class T> inline typename std::enable_if<IsIntegral<T>::value, Color3<T>>::type fromSrgb(const Vector3<typename Color3<T>::FloatingPointType>& srgb) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Color3<T> fromSrgb(const Vector3<typename Color3<T>::FloatingPointType>& srgb) {
return pack<Color3<T>>(fromSrgb<typename Color3<T>::FloatingPointType>(srgb)); return pack<Color3<T>>(fromSrgb<typename Color3<T>::FloatingPointType>(srgb));
} }
template<class T> inline typename std::enable_if<IsIntegral<T>::value, Color4<T>>::type fromSrgbAlpha(const Vector4<typename Color4<T>::FloatingPointType>& srgbAlpha) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Color4<T> fromSrgbAlpha(const Vector4<typename Color4<T>::FloatingPointType>& srgbAlpha) {
return {fromSrgb<T>(srgbAlpha.rgb()), pack<T>(srgbAlpha.a())}; return {fromSrgb<T>(srgbAlpha.rgb()), pack<T>(srgbAlpha.a())};
} }
template<class T, class Integral> inline Color3<T> fromSrgbIntegral(const Vector3<Integral>& srgb) { template<class T, class Integral> inline Color3<T> fromSrgbIntegral(const Vector3<Integral>& srgb) {
@ -152,23 +152,23 @@ template<class T, class Integral> inline Color4<T> fromSrgbAlphaIntegral(const V
} }
/* Integer linear RGB -> linear RGB conversion */ /* Integer linear RGB -> linear RGB conversion */
template<class T> inline typename std::enable_if<IsFloatingPoint<T>::value, Color3<T>>::type fromLinearRgbInt(UnsignedInt linear) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline Color3<T> fromLinearRgbInt(UnsignedInt linear) {
return {unpack<T>(UnsignedByte(linear >> 16)), return {unpack<T>(UnsignedByte(linear >> 16)),
unpack<T>(UnsignedByte(linear >> 8)), unpack<T>(UnsignedByte(linear >> 8)),
unpack<T>(UnsignedByte(linear))}; unpack<T>(UnsignedByte(linear))};
} }
template<class T> inline typename std::enable_if<IsFloatingPoint<T>::value, Color4<T>>::type fromLinearRgbaInt(UnsignedInt linear) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline Color4<T> fromLinearRgbaInt(UnsignedInt linear) {
return {unpack<T>(UnsignedByte(linear >> 24)), return {unpack<T>(UnsignedByte(linear >> 24)),
unpack<T>(UnsignedByte(linear >> 16)), unpack<T>(UnsignedByte(linear >> 16)),
unpack<T>(UnsignedByte(linear >> 8)), unpack<T>(UnsignedByte(linear >> 8)),
unpack<T>(UnsignedByte(linear))}; unpack<T>(UnsignedByte(linear))};
} }
template<class T> inline typename std::enable_if<IsIntegral<T>::value, Color3<T>>::type fromLinearRgbInt(UnsignedInt linear) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Color3<T> fromLinearRgbInt(UnsignedInt linear) {
return {pack<T>(unpack<Float>(UnsignedByte(linear >> 16))), return {pack<T>(unpack<Float>(UnsignedByte(linear >> 16))),
pack<T>(unpack<Float>(UnsignedByte(linear >> 8))), pack<T>(unpack<Float>(UnsignedByte(linear >> 8))),
pack<T>(unpack<Float>(UnsignedByte(linear)))}; pack<T>(unpack<Float>(UnsignedByte(linear)))};
} }
template<class T> inline typename std::enable_if<IsIntegral<T>::value, Color4<T>>::type fromLinearRgbaInt(UnsignedInt linear) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Color4<T> fromLinearRgbaInt(UnsignedInt linear) {
return {pack<T>(unpack<Float>(UnsignedByte(linear >> 24))), return {pack<T>(unpack<Float>(UnsignedByte(linear >> 24))),
pack<T>(unpack<Float>(UnsignedByte(linear >> 16))), pack<T>(unpack<Float>(UnsignedByte(linear >> 16))),
pack<T>(unpack<Float>(UnsignedByte(linear >> 8))), pack<T>(unpack<Float>(UnsignedByte(linear >> 8))),
@ -176,17 +176,17 @@ template<class T> inline typename std::enable_if<IsIntegral<T>::value, Color4<T>
} }
/* RGB -> sRGB conversion */ /* RGB -> sRGB conversion */
template<class T> Vector3<typename Color3<T>::FloatingPointType> toSrgb(typename std::enable_if<IsFloatingPoint<T>::value, const Color3<T>&>::type rgb) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> Vector3<typename Color3<T>::FloatingPointType> toSrgb(const Color3<T>& rgb) {
constexpr const T a = T(0.055); constexpr const T a = T(0.055);
return lerp(rgb*T(12.92), (T(1.0) + a)*pow(rgb, T(1.0)/T(2.4)) - Vector3<T>{a}, rgb > Vector3<T>(T(0.0031308))); return lerp(rgb*T(12.92), (T(1.0) + a)*pow(rgb, T(1.0)/T(2.4)) - Vector3<T>{a}, rgb > Vector3<T>(T(0.0031308)));
} }
template<class T> Vector4<typename Color4<T>::FloatingPointType> toSrgbAlpha(typename std::enable_if<IsFloatingPoint<T>::value, const Color4<T>&>::type rgba) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> Vector4<typename Color4<T>::FloatingPointType> toSrgbAlpha(const Color4<T>& rgba) {
return {toSrgb<T>(rgba.rgb()), rgba.a()}; return {toSrgb<T>(rgba.rgb()), rgba.a()};
} }
template<class T> inline Vector3<typename Color3<T>::FloatingPointType> toSrgb(typename std::enable_if<IsIntegral<T>::value, const Color3<T>&>::type rgb) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Vector3<typename Color3<T>::FloatingPointType> toSrgb(const Color3<T>& rgb) {
return toSrgb<typename Color3<T>::FloatingPointType>(unpack<Color3<typename Color3<T>::FloatingPointType>>(rgb)); return toSrgb<typename Color3<T>::FloatingPointType>(unpack<Color3<typename Color3<T>::FloatingPointType>>(rgb));
} }
template<class T> inline Vector4<typename Color4<T>::FloatingPointType> toSrgbAlpha(typename std::enable_if<IsIntegral<T>::value, const Color4<T>&>::type rgba) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Vector4<typename Color4<T>::FloatingPointType> toSrgbAlpha(const Color4<T>& rgba) {
return {toSrgb<T>(rgba.rgb()), unpack<typename Color3<T>::FloatingPointType>(rgba.a())}; return {toSrgb<T>(rgba.rgb()), unpack<typename Color3<T>::FloatingPointType>(rgba.a())};
} }
template<class T, class Integral> inline Vector3<Integral> toSrgbIntegral(const Color3<T>& rgb) { template<class T, class Integral> inline Vector3<Integral> toSrgbIntegral(const Color3<T>& rgb) {
@ -199,23 +199,23 @@ template<class T, class Integral> inline Vector4<Integral> toSrgbAlphaIntegral(c
} }
/* Linear RGB -> integer linear RGB conversion */ /* Linear RGB -> integer linear RGB conversion */
template<class T> inline typename std::enable_if<IsFloatingPoint<T>::value, UnsignedInt>::type toLinearRgbInt(const Color3<T>& linear) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline UnsignedInt toLinearRgbInt(const Color3<T>& linear) {
return (pack<UnsignedByte>(linear[0]) << 16) | return (pack<UnsignedByte>(linear[0]) << 16) |
(pack<UnsignedByte>(linear[1]) << 8) | (pack<UnsignedByte>(linear[1]) << 8) |
pack<UnsignedByte>(linear[2]); pack<UnsignedByte>(linear[2]);
} }
template<class T> inline typename std::enable_if<IsFloatingPoint<T>::value, UnsignedInt>::type toLinearRgbaInt(const Color4<T>& linear) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline UnsignedInt toLinearRgbaInt(const Color4<T>& linear) {
return (pack<UnsignedByte>(linear[0]) << 24) | return (pack<UnsignedByte>(linear[0]) << 24) |
(pack<UnsignedByte>(linear[1]) << 16) | (pack<UnsignedByte>(linear[1]) << 16) |
(pack<UnsignedByte>(linear[2]) << 8) | (pack<UnsignedByte>(linear[2]) << 8) |
pack<UnsignedByte>(linear[3]); pack<UnsignedByte>(linear[3]);
} }
template<class T> inline typename std::enable_if<IsIntegral<T>::value, UnsignedInt>::type toLinearRgbInt(const Color3<T>& linear) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline UnsignedInt toLinearRgbInt(const Color3<T>& linear) {
return (pack<UnsignedByte>(unpack<Float>(linear[0])) << 16) | return (pack<UnsignedByte>(unpack<Float>(linear[0])) << 16) |
(pack<UnsignedByte>(unpack<Float>(linear[1])) << 8) | (pack<UnsignedByte>(unpack<Float>(linear[1])) << 8) |
pack<UnsignedByte>(unpack<Float>(linear[2])); pack<UnsignedByte>(unpack<Float>(linear[2]));
} }
template<class T> inline typename std::enable_if<IsIntegral<T>::value, UnsignedInt>::type toLinearRgbaInt(const Color4<T>& linear) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline UnsignedInt toLinearRgbaInt(const Color4<T>& linear) {
return (pack<UnsignedByte>(unpack<Float>(linear[0])) << 24) | return (pack<UnsignedByte>(unpack<Float>(linear[0])) << 24) |
(pack<UnsignedByte>(unpack<Float>(linear[1])) << 16) | (pack<UnsignedByte>(unpack<Float>(linear[1])) << 16) |
(pack<UnsignedByte>(unpack<Float>(linear[2])) << 8) | (pack<UnsignedByte>(unpack<Float>(linear[2])) << 8) |
@ -223,7 +223,7 @@ template<class T> inline typename std::enable_if<IsIntegral<T>::value, UnsignedI
} }
/* CIE XYZ -> RGB conversion */ /* CIE XYZ -> RGB conversion */
template<class T> typename std::enable_if<IsFloatingPoint<T>::value, Color3<T>>::type fromXyz(const Vector3<T>& xyz) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> Color3<T> fromXyz(const Vector3<T>& xyz) {
/* Taken from https://en.wikipedia.org/wiki/Talk:SRGB#Rounded_vs._Exact, /* Taken from https://en.wikipedia.org/wiki/Talk:SRGB#Rounded_vs._Exact,
the rounded matrices from the main article don't round-trip perfectly */ the rounded matrices from the main article don't round-trip perfectly */
return Matrix3x3<T>{ return Matrix3x3<T>{
@ -231,12 +231,12 @@ template<class T> typename std::enable_if<IsFloatingPoint<T>::value, Color3<T>>:
Vector3<T>{T(-329)/T(214), T(1648619)/T(878810), T(-2585)/T(12673)}, Vector3<T>{T(-329)/T(214), T(1648619)/T(878810), T(-2585)/T(12673)},
Vector3<T>{T(-1974)/T(3959), T(36519)/T(878810), T(705)/T(667)}}*xyz; Vector3<T>{T(-1974)/T(3959), T(36519)/T(878810), T(705)/T(667)}}*xyz;
} }
template<class T> inline typename std::enable_if<IsIntegral<T>::value, Color3<T>>::type fromXyz(const Vector3<typename Color3<T>::FloatingPointType>& xyz) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Color3<T> fromXyz(const Vector3<typename Color3<T>::FloatingPointType>& xyz) {
return pack<Color3<T>>(fromXyz<typename Color3<T>::FloatingPointType>(xyz)); return pack<Color3<T>>(fromXyz<typename Color3<T>::FloatingPointType>(xyz));
} }
/* RGB -> CIE XYZ conversion */ /* RGB -> CIE XYZ conversion */
template<class T> Vector3<typename Color3<T>::FloatingPointType> toXyz(typename std::enable_if<IsFloatingPoint<T>::value, const Color3<T>&>::type rgb) { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> Vector3<typename Color3<T>::FloatingPointType> toXyz(const Color3<T>& rgb) {
/* Taken from https://en.wikipedia.org/wiki/Talk:SRGB#Rounded_vs._Exact, /* Taken from https://en.wikipedia.org/wiki/Talk:SRGB#Rounded_vs._Exact,
the rounded matrices from the main article don't round-trip perfectly */ the rounded matrices from the main article don't round-trip perfectly */
return (Matrix3x3<T>{ return (Matrix3x3<T>{
@ -244,7 +244,7 @@ template<class T> Vector3<typename Color3<T>::FloatingPointType> toXyz(typename
Vector3<T>{T(87881)/T(245763), T(175762)/T(245763), T(87881)/T(737289)}, Vector3<T>{T(87881)/T(245763), T(175762)/T(245763), T(87881)/T(737289)},
Vector3<T>{T(12673)/T(70218), T(12673)/T(175545), T(1001167)/T(1053270)}})*rgb; Vector3<T>{T(12673)/T(70218), T(12673)/T(175545), T(1001167)/T(1053270)}})*rgb;
} }
template<class T> inline Vector3<typename Color3<T>::FloatingPointType> toXyz(typename std::enable_if<IsIntegral<T>::value, const Color3<T>&>::type rgb) { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Vector3<typename Color3<T>::FloatingPointType> toXyz(const Color3<T>& rgb) {
return toXyz<typename Color3<T>::FloatingPointType>(unpack<Color3<typename Color3<T>::FloatingPointType>>(rgb)); return toXyz<typename Color3<T>::FloatingPointType>(unpack<Color3<typename Color3<T>::FloatingPointType>>(rgb));
} }
@ -256,10 +256,10 @@ template<class T> inline Vector3<typename Color3<T>::FloatingPointType> toXyz(ty
projects created directly using VS (enabled by default since 15.5) but not projects created directly using VS (enabled by default since 15.5) but not
projects using CMake. Not using SFINAE in this case makes it work. Minimal projects using CMake. Not using SFINAE in this case makes it work. Minimal
repro case here: https://twitter.com/czmosra/status/1039446378248896513 */ repro case here: https://twitter.com/czmosra/status/1039446378248896513 */
template<class T> constexpr typename std::enable_if<IsFloatingPoint<T>::value, T>::type fullChannel() { template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> constexpr T fullChannel() {
return T(1.0); return T(1.0);
} }
template<class T> constexpr typename std::enable_if<IsIntegral<T>::value, T>::type fullChannel() { template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> constexpr T fullChannel() {
return Implementation::bitMax<T>(); return Implementation::bitMax<T>();
} }
#else #else

17
src/Magnum/Math/CubicHermite.h
Unescape View File

@ -88,13 +88,11 @@ template<class T> class CubicHermite {
* Enabled only on vector underlying types. See * Enabled only on vector underlying types. See
* @ref Bezier::fromCubicHermite() for the inverse operation. * @ref Bezier::fromCubicHermite() for the inverse operation.
*/ */
template<UnsignedInt dimensions, class U> static template<UnsignedInt dimensions, class U
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
CubicHermite<T> , typename std::enable_if<std::is_base_of<Vector<dimensions, U>, T>::value, int>::type = 0
#else #endif
typename std::enable_if<std::is_base_of<Vector<dimensions, U>, T>::value, CubicHermite<T>>::type > static CubicHermite<T> fromBezier(const CubicBezier<dimensions, U>& a, const CubicBezier<dimensions, U>& b) {
#endif
fromBezier(const CubicBezier<dimensions, U>& a, const CubicBezier<dimensions, U>& b) {
return CORRADE_CONSTEXPR_DEBUG_ASSERT(a[3] == b[0], return CORRADE_CONSTEXPR_DEBUG_ASSERT(a[3] == b[0],
"Math::CubicHermite::fromBezier(): segments are not adjacent"), "Math::CubicHermite::fromBezier(): segments are not adjacent"),
CubicHermite<T>{3*(a[3] - a[2]), a[3], 3*(b[1] - a[3])}; CubicHermite<T>{3*(a[3] - a[2]), a[3], 3*(b[1] - a[3])};
@ -124,7 +122,10 @@ template<class T> class CubicHermite {
* @ref outTangent() is constructed as zero. Enabled only for complex * @ref outTangent() is constructed as zero. Enabled only for complex
* and quaternion types. * and quaternion types.
*/ */
template<class U = T, class = typename std::enable_if<std::is_constructible<U, IdentityInitT>::value>::type> constexpr explicit CubicHermite(IdentityInitT) noexcept: _inTangent{ZeroInit}, _point{IdentityInit}, _outTangent{ZeroInit} {} #ifndef DOXYGEN_GENERATING_OUTPUT
template<class U = T, typename std::enable_if<std::is_constructible<U, IdentityInitT>::value, int>::type = 0>
#endif
constexpr explicit CubicHermite(IdentityInitT) noexcept: _inTangent{ZeroInit}, _point{IdentityInit}, _outTangent{ZeroInit} {}
/** @brief Construct a cubic Hermite spline point without initializing its contents */ /** @brief Construct a cubic Hermite spline point without initializing its contents */
explicit CubicHermite(Magnum::NoInitT) noexcept: CubicHermite{Magnum::NoInit, typename std::conditional<std::is_constructible<T, Magnum::NoInitT>::value, Magnum::NoInitT*, void*>::type{}} {} explicit CubicHermite(Magnum::NoInitT) noexcept: CubicHermite{Magnum::NoInit, typename std::conditional<std::is_constructible<T, Magnum::NoInitT>::value, Magnum::NoInitT*, void*>::type{}} {}

31
src/Magnum/Math/Dual.h
Unescape View File

@ -81,18 +81,17 @@ template<class T> class Dual {
#ifdef DOXYGEN_GENERATING_OUTPUT #ifdef DOXYGEN_GENERATING_OUTPUT
constexpr explicit Dual(ZeroInitT) noexcept; constexpr explicit Dual(ZeroInitT) noexcept;
#else #else
/* MSVC 2015 can't handle {} instead of ::value */ template<class U = T, typename std::enable_if<std::is_standard_layout<U>::value && std::is_trivial<U>::value, int>::type = 0> constexpr explicit Dual(ZeroInitT) noexcept: _real{}, _dual{} {}
template<class U = T, class = typename std::enable_if<std::is_standard_layout<U>::value && std::is_trivial<U>::value>::type> constexpr explicit Dual(ZeroInitT) noexcept: _real{}, _dual{} {} template<class U = T, typename std::enable_if<std::is_constructible<U, ZeroInitT>::value, int>::type = 0>
template<class U = T, class V = T, class = typename std::enable_if<std::is_constructible<U, ZeroInitT>::value>::type> constexpr explicit Dual(ZeroInitT) noexcept: _real{ZeroInit}, _dual{ZeroInit} {} constexpr explicit Dual(ZeroInitT) noexcept: _real{ZeroInit}, _dual{ZeroInit} {}
#endif #endif
/** @brief Construct without initializing the contents */ /** @brief Construct without initializing the contents */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifdef DOXYGEN_GENERATING_OUTPUT
explicit Dual(NoInitT) noexcept; explicit Dual(NoInitT) noexcept;
#else #else
/* MSVC 2015 can't handle {} instead of ::value */ template<class U = T, typename std::enable_if<std::is_standard_layout<U>::value && std::is_trivial<U>::value, int>::type = 0> explicit Dual(Magnum::NoInitT) noexcept {}
template<class U = T, class = typename std::enable_if<std::is_standard_layout<U>::value && std::is_trivial<U>::value>::type> explicit Dual(Magnum::NoInitT) noexcept {} template<class U = T, typename std::enable_if<std::is_constructible<U, Magnum::NoInitT>::value, int>::type = 0> explicit Dual(Magnum::NoInitT) noexcept: _real{Magnum::NoInit}, _dual{Magnum::NoInit} {}
template<class U = T, class V = T, class = typename std::enable_if<std::is_constructible<U, Magnum::NoInitT>::value>::type> explicit Dual(Magnum::NoInitT) noexcept: _real{Magnum::NoInit}, _dual{Magnum::NoInit} {}
#endif #endif
/** /**
@ -275,7 +274,11 @@ template<class T> class Dual {
* @see @ref operator*(const Dual<U>&) const, * @see @ref operator*(const Dual<U>&) const,
* @ref operator*(const T&, const Dual<U>&) * @ref operator*(const T&, const Dual<U>&)
*/ */
template<class U, class V = typename std::enable_if<!Implementation::IsDual<U>::value, void>::type> Dual<decltype(std::declval<T>()*std::declval<U>())> operator*(const U& other) const { template<class U
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<!Implementation::IsDual<U>::value, int>::type = 0
#endif
> Dual<decltype(std::declval<T>()*std::declval<U>())> operator*(const U& other) const {
return {_real*other, _dual*other}; return {_real*other, _dual*other};
} }
@ -287,7 +290,7 @@ template<class T> class Dual {
* @f] * @f]
* @see @ref operator/(const U&) const * @see @ref operator/(const U&) const
*/ */
template<class U> auto operator/(const Dual<U>& other) const -> Dual<decltype(std::declval<T>()/std::declval<U>())> { template<class U> Dual<decltype(std::declval<T>()/std::declval<U>())> operator/(const Dual<U>& other) const {
return {_real/other._real, (_dual*other._real - _real*other._dual)/(other._real*other._real)}; return {_real/other._real, (_dual*other._real - _real*other._dual)/(other._real*other._real)};
} }
@ -300,7 +303,11 @@ template<class T> class Dual {
* @f] * @f]
* @see @ref operator/(const Dual<U>&) const * @see @ref operator/(const Dual<U>&) const
*/ */
template<class U, class V = typename std::enable_if<!Implementation::IsDual<U>::value, Dual<decltype(std::declval<T>()/std::declval<U>())>>::type> V operator/(const U& other) const { template<class U,
#ifndef DOXYGEN_GENERATING_OUTPUT
typename std::enable_if<!Implementation::IsDual<U>::value, int>::type = 0
#endif
> Dual<decltype(std::declval<T>()/std::declval<U>())> operator/(const U& other) const {
return {_real/other, _dual/other}; return {_real/other, _dual/other};
} }
@ -328,7 +335,11 @@ Equivalent to @ref Dual::operator*(const Dual<U>&) const assuming that
\hat a \hat b = a_0 b_0 + \epsilon (a_0 b_\epsilon + a_\epsilon b_0) = a_0 b_0 + \epsilon a_0 b_\epsilon \hat a \hat b = a_0 b_0 + \epsilon (a_0 b_\epsilon + a_\epsilon b_0) = a_0 b_0 + \epsilon a_0 b_\epsilon
@f] @f]
*/ */
template<class T, class U, class V = typename std::enable_if<!Implementation::IsDual<T>::value, Dual<decltype(std::declval<T>()*std::declval<U>())>>::type> inline V operator*(const T& a, const Dual<U>& b) { template<class T, class U
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<!Implementation::IsDual<T>::value, int>::type = 0
#endif
> inline Dual<decltype(std::declval<T>()*std::declval<U>())> operator*(const T& a, const Dual<U>& b) {
return {a*b.real(), a*b.dual()}; return {a*b.real(), a*b.dual()};
} }

116
src/Magnum/Math/Functions.h
Unescape View File

@ -252,7 +252,11 @@ the operations component-wise.
@see @ref isNan(), @ref Constants::inf(), @see @ref isNan(), @ref Constants::inf(),
@ref isInf(const Containers::StridedArrayView1D<const T>&) @ref isInf(const Containers::StridedArrayView1D<const T>&)
*/ */
template<class T> inline typename std::enable_if<IsScalar<T>::value, bool>::type isInf(T value) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline bool isInf(T value) {
return std::isinf(UnderlyingTypeOf<T>(value)); return std::isinf(UnderlyingTypeOf<T>(value));
} }
@ -276,7 +280,11 @@ Equivalent to @cpp value != value @ce.
@ref isNan(const Containers::StridedArrayView1D<const T>&) @ref isNan(const Containers::StridedArrayView1D<const T>&)
*/ */
/* defined in Vector.h */ /* defined in Vector.h */
template<class T> typename std::enable_if<IsScalar<T>::value, bool>::type isNan(T value); template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type
#endif
> bool isNan(T value);
/** /**
@overload @overload
@ -298,7 +306,11 @@ template<std::size_t size, class T> inline BitVector<size> isNan(const Vector<si
@ref Vector::min(), @ref Utility::min() @ref Vector::min(), @ref Utility::min()
*/ */
/* defined in Vector.h */ /* defined in Vector.h */
template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type min(T value, T min); template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type
#endif
> constexpr T min(T value, T min);
/** @overload */ /** @overload */
template<std::size_t size, class T> inline Vector<size, T> min(const Vector<size, T>& value, const Vector<size, T>& min) { template<std::size_t size, class T> inline Vector<size, T> min(const Vector<size, T>& value, const Vector<size, T>& min) {
@ -325,7 +337,11 @@ template<std::size_t size, class T> inline Vector<size, T> min(const Vector<size
@ref Vector::max(), @ref Utility::max() @ref Vector::max(), @ref Utility::max()
*/ */
/* defined in Vector.h */ /* defined in Vector.h */
template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type max(T a, T b); template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type
#endif
> constexpr T max(T a, T b);
/** @overload */ /** @overload */
template<std::size_t size, class T> Vector<size, T> max(const Vector<size, T>& value, const Vector<size, T>& max) { template<std::size_t size, class T> Vector<size, T> max(const Vector<size, T>& value, const Vector<size, T>& max) {
@ -351,7 +367,11 @@ template<std::size_t size, class T> inline Vector<size, T> max(const Vector<size
@ref Vector::minmax(), @ref Vector::minmax(),
@ref Range::Range(const Containers::Pair<VectorType, VectorType>&) @ref Range::Range(const Containers::Pair<VectorType, VectorType>&)
*/ */
template<class T> inline typename std::enable_if<IsScalar<T>::value, Containers::Pair<T, T>>::type minmax(T a, T b) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline Containers::Pair<T, T> minmax(T a, T b) {
return a < b ? Containers::pair(a, b) : Containers::pair(b, a); return a < b ? Containers::pair(a, b) : Containers::pair(b, a);
} }
@ -376,7 +396,11 @@ set to @p max. Equivalent to:
@see @ref min(), @ref max() @see @ref min(), @ref max()
*/ */
/* defined in Vector.h */ /* defined in Vector.h */
template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type clamp(T value, T min, T max); template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type
#endif
> constexpr T clamp(T value, T min, T max);
/** @overload */ /** @overload */
template<std::size_t size, class T> inline Vector<size, T> clamp(const Vector<size, T>& value, const Vector<size, T>& min, const Vector<size, T>& max) { template<std::size_t size, class T> inline Vector<size, T> clamp(const Vector<size, T>& value, const Vector<size, T>& min, const Vector<size, T>& max) {
@ -399,7 +423,11 @@ template<std::size_t size, class T> inline Vector<size, T> clamp(const Vector<si
Returns `1` if @p x > 0, `0` if @p x = 0 and `-1` if @p x < 0. Returns `1` if @p x > 0, `0` if @p x = 0 and `-1` if @p x < 0.
*/ */
template<class T> inline typename std::enable_if<IsScalar<T>::value, UnderlyingTypeOf<T>>::type sign(T scalar) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline UnderlyingTypeOf<T> sign(T scalar) {
if(scalar > T(0)) return UnderlyingTypeOf<T>(1); if(scalar > T(0)) return UnderlyingTypeOf<T>(1);
if(scalar < T(0)) return UnderlyingTypeOf<T>(-1); if(scalar < T(0)) return UnderlyingTypeOf<T>(-1);
return UnderlyingTypeOf<T>(0); return UnderlyingTypeOf<T>(0);
@ -414,7 +442,11 @@ template<std::size_t size, class T> inline Vector<size, UnderlyingTypeOf<T>> sig
} }
/** @brief Absolute value */ /** @brief Absolute value */
template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type abs(T a) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline T abs(T a) {
return T(std::abs(UnderlyingTypeOf<T>(a))); return T(std::abs(UnderlyingTypeOf<T>(a)));
} }
@ -427,7 +459,11 @@ template<std::size_t size, class T> inline Vector<size, T> abs(const Vector<size
} }
/** @brief Nearest not larger integer */ /** @brief Nearest not larger integer */
template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type floor(T a) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline T floor(T a) {
return T(std::floor(UnderlyingTypeOf<T>(a))); return T(std::floor(UnderlyingTypeOf<T>(a)));
} }
@ -440,7 +476,11 @@ template<std::size_t size, class T> inline Vector<size, T> floor(const Vector<si
} }
/** @brief Round value to nearest integer */ /** @brief Round value to nearest integer */
template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type round(T a) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline T round(T a) {
return T(std::round(UnderlyingTypeOf<T>(a))); return T(std::round(UnderlyingTypeOf<T>(a)));
} }
@ -453,7 +493,11 @@ template<std::size_t size, class T> inline Vector<size, T> round(const Vector<si
} }
/** @brief Nearest not smaller integer */ /** @brief Nearest not smaller integer */
template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type ceil(T a) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline T ceil(T a) {
return T(std::ceil(UnderlyingTypeOf<T>(a))); return T(std::ceil(UnderlyingTypeOf<T>(a)));
} }
@ -481,7 +525,11 @@ Calculates the remainder @f$ r @f$ of a floating point division: @f[
@m_keyword{mod(),GLSL mod(),} @m_keyword{mod(),GLSL mod(),}
*/ */
template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type fmod(T a, T b) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline T fmod(T a, T b) {
return T(std::fmod(UnderlyingTypeOf<T>(a), UnderlyingTypeOf<T>(b))); return T(std::fmod(UnderlyingTypeOf<T>(a), UnderlyingTypeOf<T>(b)));
} }
@ -526,13 +574,11 @@ See @ref select() for constant interpolation using the same API and
@ref lerp(const CubicHermiteQuaternion<T>&, const CubicHermiteQuaternion<T>&, T) @ref lerp(const CubicHermiteQuaternion<T>&, const CubicHermiteQuaternion<T>&, T)
@m_keyword{mix(),GLSL mix(),} @m_keyword{mix(),GLSL mix(),}
*/ */
template<class T, class U> inline template<class T, class U
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
typename std::enable_if<(IsVector<T>::value || IsScalar<T>::value) && !Implementation::IsBitVectorOrScalar<U>::value, T>::type , typename std::enable_if<(IsVector<T>::value || IsScalar<T>::value) && !Implementation::IsBitVectorOrScalar<U>::value, int>::type = 0
#else
T
#endif #endif
lerp(const T& a, const T& b, U t) { > inline T lerp(const T& a, const T& b, U t) {
return Implementation::lerp(a, b, t); return Implementation::lerp(a, b, t);
} }
@ -587,7 +633,11 @@ expression combines that with @ref clamp() to ensure the value is in bounds:
@see @ref select() @see @ref select()
*/ */
template<class T> inline UnderlyingTypeOf<typename std::enable_if<IsScalar<T>::value, T>::type> lerpInverted(T a, T b, T lerp) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline UnderlyingTypeOf<T> lerpInverted(T a, T b, T lerp) {
return (lerp - a)/(b - a); return (lerp - a)/(b - a);
} }
@ -623,7 +673,11 @@ Computes and returns @f$ ab + c @f$. On some architectures might be faster than
doing the computation manually. Works only on types that satisfy doing the computation manually. Works only on types that satisfy
@ref IsUnitless. @ref IsUnitless.
*/ */
template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type fma(T a, T b, T c) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline T fma(T a, T b, T c) {
static_assert(IsUnitless<T>::value, "expecting a unitless type"); static_assert(IsUnitless<T>::value, "expecting a unitless type");
/* On Emscripten it works with -O2 but not with -O1 (function not defined). /* On Emscripten it works with -O2 but not with -O1 (function not defined).
I guess that's only because -O2 optimizes it out, so disabling it there. */ I guess that's only because -O2 optimizes it out, so disabling it there. */
@ -693,7 +747,11 @@ Returns integral power of base to the exponent. Works only on types that
satisfy @ref IsUnitless. satisfy @ref IsUnitless.
@see @ref pow(T, T) @see @ref pow(T, T)
*/ */
template<UnsignedInt exponent, class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type pow(T base) { template<UnsignedInt exponent, class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> constexpr T pow(T base) {
static_assert(IsUnitless<T>::value, "expected a unitless type"); static_assert(IsUnitless<T>::value, "expected a unitless type");
return Implementation::Pow<exponent>::pow(base); return Implementation::Pow<exponent>::pow(base);
} }
@ -713,7 +771,11 @@ Returns power of @p base to the @p exponent. Works only on types that satisfy
@ref IsUnitless. @ref IsUnitless.
@see @ref pow(T), @ref exp() @see @ref pow(T), @ref exp()
*/ */
template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type pow(T base, T exponent) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline T pow(T base, T exponent) {
static_assert(IsUnitless<T>::value, "expected a unitless type"); static_assert(IsUnitless<T>::value, "expected a unitless type");
return std::pow(base, exponent); return std::pow(base, exponent);
} }
@ -732,7 +794,11 @@ template<std::size_t size, class T> inline Vector<size, T> pow(const Vector<size
Works only on types that satisfy @ref IsUnitless. Works only on types that satisfy @ref IsUnitless.
@see @ref sqrtInverted(), @ref Vector::length(), @ref sqrt(const Dual<T>&) @see @ref sqrtInverted(), @ref Vector::length(), @ref sqrt(const Dual<T>&)
*/ */
template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type sqrt(T a) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline T sqrt(T a) {
static_assert(IsUnitless<T>::value, "expecting a unitless type"); static_assert(IsUnitless<T>::value, "expecting a unitless type");
return std::sqrt(a); return std::sqrt(a);
} }
@ -752,7 +818,11 @@ Works only on types that satisfy @ref IsUnitless.
@see @ref sqrt(), @ref Vector::lengthInverted() @see @ref sqrt(), @ref Vector::lengthInverted()
@m_keyword{inversesqrt(),GLSL inversesqrt(),} @m_keyword{inversesqrt(),GLSL inversesqrt(),}
*/ */
template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type sqrtInverted(T a) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline T sqrtInverted(T a) {
static_assert(IsUnitless<T>::value, "expecting a unitless type"); static_assert(IsUnitless<T>::value, "expecting a unitless type");
return T(1)/std::sqrt(a); return T(1)/std::sqrt(a);
} }

2
src/Magnum/Math/FunctionsBatch.h
Unescape View File

@ -292,7 +292,7 @@ template<class T, std::size_t size> inline T max(const T(&array)[size]) {
} }
namespace Implementation { namespace Implementation {
template<class T> inline typename std::enable_if<IsScalar<T>::value, void>::type minmax(T& min, T& max, T value) { template<class T, typename std::enable_if<IsScalar<T>::value, int>::type = 0> inline void minmax(T& min, T& max, T value) {
if(value < min) if(value < min)
min = value; min = value;
else if(value > max) else if(value > max)

10
src/Magnum/Math/Packing.h
Unescape View File

@ -82,14 +82,14 @@ representation to use. Example usage:
*/ */
template<class FloatingPoint, class Integral, UnsignedInt bits> inline FloatingPoint unpack(const Integral& value); template<class FloatingPoint, class Integral, UnsignedInt bits> inline FloatingPoint unpack(const Integral& value);
#else #else
template<class FloatingPoint, class Integral, UnsignedInt bits = sizeof(Integral)*8> inline typename std::enable_if<IsScalar<Integral>::value && std::is_unsigned<Integral>::value, FloatingPoint>::type unpack(const Integral& value) { template<class FloatingPoint, class Integral, UnsignedInt bits = sizeof(Integral)*8, typename std::enable_if<IsScalar<Integral>::value && std::is_unsigned<Integral>::value, int>::type = 0> inline FloatingPoint unpack(const Integral& value) {
static_assert(IsFloatingPoint<FloatingPoint>::value && IsIntegral<Integral>::value, static_assert(IsFloatingPoint<FloatingPoint>::value && IsIntegral<Integral>::value,
"unpacking must be done from integral to floating-point type"); "unpacking must be done from integral to floating-point type");
static_assert(bits <= sizeof(Integral)*8, static_assert(bits <= sizeof(Integral)*8,
"bit count larger than size of the integral type"); "bit count larger than size of the integral type");
return FloatingPoint(value/UnderlyingTypeOf<FloatingPoint>(Implementation::bitMax<Integral, bits>())); return FloatingPoint(value/UnderlyingTypeOf<FloatingPoint>(Implementation::bitMax<Integral, bits>()));
} }
template<class FloatingPoint, class Integral, UnsignedInt bits = sizeof(Integral)*8> inline typename std::enable_if<IsScalar<Integral>::value && std::is_signed<Integral>::value, FloatingPoint>::type unpack(const Integral& value) { template<class FloatingPoint, class Integral, UnsignedInt bits = sizeof(Integral)*8, typename std::enable_if<IsScalar<Integral>::value && std::is_signed<Integral>::value, int>::type = 0> inline FloatingPoint unpack(const Integral& value) {
static_assert(IsFloatingPoint<FloatingPoint>::value && IsIntegral<Integral>::value, static_assert(IsFloatingPoint<FloatingPoint>::value && IsIntegral<Integral>::value,
"unpacking must be done from integral to floating-point type"); "unpacking must be done from integral to floating-point type");
static_assert(bits <= sizeof(Integral)*8, static_assert(bits <= sizeof(Integral)*8,
@ -111,7 +111,7 @@ template<class FloatingPoint, std::size_t size, class Integral, UnsignedInt bits
#ifdef DOXYGEN_GENERATING_OUTPUT #ifdef DOXYGEN_GENERATING_OUTPUT
template<class FloatingPoint, UnsignedInt bits, class Integral> inline FloatingPoint unpack(const Integral& value); template<class FloatingPoint, UnsignedInt bits, class Integral> inline FloatingPoint unpack(const Integral& value);
#else #else
template<class FloatingPoint, UnsignedInt bits, class Integral> inline typename std::enable_if<IsScalar<Integral>::value, FloatingPoint>::type unpack(const Integral& value) { template<class FloatingPoint, UnsignedInt bits, class Integral, typename std::enable_if<IsScalar<Integral>::value, int>::type = 0> inline FloatingPoint unpack(const Integral& value) {
return unpack<FloatingPoint, Integral, bits>(value); return unpack<FloatingPoint, Integral, bits>(value);
} }
template<class FloatingPoint, UnsignedInt bits, std::size_t size, class Integral> inline FloatingPoint unpack(const Vector<size, Integral>& value) { template<class FloatingPoint, UnsignedInt bits, std::size_t size, class Integral> inline FloatingPoint unpack(const Vector<size, Integral>& value) {
@ -139,7 +139,7 @@ given *signed* integral type.
#ifdef DOXYGEN_GENERATING_OUTPUT #ifdef DOXYGEN_GENERATING_OUTPUT
template<class Integral, class FloatingPoint> inline Integral pack(const FloatingPoint& value); template<class Integral, class FloatingPoint> inline Integral pack(const FloatingPoint& value);
#else #else
template<class Integral, class FloatingPoint, UnsignedInt bits = sizeof(Integral)*8> inline typename std::enable_if<IsScalar<FloatingPoint>::value, Integral>::type pack(FloatingPoint value) { template<class Integral, class FloatingPoint, UnsignedInt bits = sizeof(Integral)*8, typename std::enable_if<IsScalar<FloatingPoint>::value, int>::type = 0> inline Integral pack(FloatingPoint value) {
static_assert(IsFloatingPoint<FloatingPoint>::value && IsIntegral<Integral>::value, static_assert(IsFloatingPoint<FloatingPoint>::value && IsIntegral<Integral>::value,
"packing must be done from floating-point to integral type"); "packing must be done from floating-point to integral type");
static_assert(bits <= sizeof(Integral)*8, static_assert(bits <= sizeof(Integral)*8,
@ -167,7 +167,7 @@ representation to use. Example usage:
#ifdef DOXYGEN_GENERATING_OUTPUT #ifdef DOXYGEN_GENERATING_OUTPUT
template<class Integral, UnsignedInt bits, class FloatingPoint> inline Integral pack(FloatingPoint value); template<class Integral, UnsignedInt bits, class FloatingPoint> inline Integral pack(FloatingPoint value);
#else #else
template<class Integral, UnsignedInt bits, class FloatingPoint> inline typename std::enable_if<IsScalar<FloatingPoint>::value, Integral>::type pack(FloatingPoint value) { template<class Integral, UnsignedInt bits, class FloatingPoint, typename std::enable_if<IsScalar<FloatingPoint>::value, int>::type = 0> inline Integral pack(FloatingPoint value) {
return pack<Integral, FloatingPoint, bits>(value); return pack<Integral, FloatingPoint, bits>(value);
} }
template<class Integral, UnsignedInt bits, std::size_t size, class FloatingPoint> inline Integral pack(const Vector<size, FloatingPoint>& value) { template<class Integral, UnsignedInt bits, std::size_t size, class FloatingPoint> inline Integral pack(const Vector<size, FloatingPoint>& value) {

8
src/Magnum/Math/Range.h
Unescape View File

@ -144,7 +144,7 @@ template<UnsignedInt dimensions, class T> class Range {
constexpr /*implicit*/ Range(const VectorType& min, const VectorType& max) noexcept: _min{min}, _max{max} {} constexpr /*implicit*/ Range(const VectorType& min, const VectorType& max) noexcept: _min{min}, _max{max} {}
/** @overload */ /** @overload */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 1>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d == 1, int>::type = 0>
#endif #endif
constexpr /*implicit*/ Range(const Vector<dimensions, T>& min, const Vector<dimensions, T>& max) noexcept: _min{Implementation::RangeTraits<dimensions, T>::fromVector(min)}, _max{Implementation::RangeTraits<dimensions, T>::fromVector(max)} {} constexpr /*implicit*/ Range(const Vector<dimensions, T>& min, const Vector<dimensions, T>& max) noexcept: _min{Implementation::RangeTraits<dimensions, T>::fromVector(min)}, _max{Implementation::RangeTraits<dimensions, T>::fromVector(max)} {}
@ -161,7 +161,7 @@ template<UnsignedInt dimensions, class T> class Range {
/** @overload */ /** @overload */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d != 1>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d != 1, int>::type = 0>
#endif #endif
constexpr /*implicit*/ Range(const Containers::Pair<Vector<dimensions, T>, Vector<dimensions, T>>& minmax) noexcept: _min{minmax.first()}, _max{minmax.second()} {} constexpr /*implicit*/ Range(const Containers::Pair<Vector<dimensions, T>, Vector<dimensions, T>>& minmax) noexcept: _min{minmax.first()}, _max{minmax.second()} {}
@ -311,7 +311,7 @@ template<UnsignedInt dimensions, class T> class Range {
* @m_since_latest * @m_since_latest
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d != 1>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d != 1, int>::type = 0>
#endif #endif
Range<dimensions, T> scaled(T scaling) const { Range<dimensions, T> scaled(T scaling) const {
return {_min*scaling, _max*scaling}; return {_min*scaling, _max*scaling};
@ -334,7 +334,7 @@ template<UnsignedInt dimensions, class T> class Range {
* @m_since_latest * @m_since_latest
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<UnsignedInt d = dimensions, class = typename std::enable_if<d != 1>::type> template<UnsignedInt d = dimensions, typename std::enable_if<d != 1, int>::type = 0>
#endif #endif
Range<dimensions, T> scaledFromCenter(T scaling) const { Range<dimensions, T> scaledFromCenter(T scaling) const {
/* Can't use *T(0.5) because that won't work for integers */ /* Can't use *T(0.5) because that won't work for integers */

4
src/Magnum/Math/Test/TypeTraitsTest.cpp
Unescape View File

@ -359,10 +359,10 @@ template<class T> void TypeTraitsTest::equalsFloatingPointNaN() {
} }
/* Argh! Why there is no standard std::abs() for unsigned types? */ /* Argh! Why there is no standard std::abs() for unsigned types? */
template<class T, class U = typename std::enable_if<std::is_unsigned<T>::value>::type> T abs(T value) { template<class T, typename std::enable_if<std::is_unsigned<T>::value, int>::type = 0> T abs(T value) {
return value; return value;
} }
template<class T, class U = T, class V = typename std::enable_if<!std::is_unsigned<T>::value>::type> T abs(T value) { template<class T, typename std::enable_if<!std::is_unsigned<T>::value, int>::type = 0> T abs(T value) {
return std::abs(value); return std::abs(value);
} }

12
src/Magnum/Math/TypeTraits.h
Unescape View File

@ -405,7 +405,11 @@ Calls @ref TypeTraits<T>::equals() --- using fuzzy compare for floating-point
types and doing equality comparison on integral types. Scalar complement to types and doing equality comparison on integral types. Scalar complement to
@ref equal(const Vector<size, T>& a, const Vector<size, T>&). @ref equal(const Vector<size, T>& a, const Vector<size, T>&).
*/ */
template<class T> inline typename std::enable_if<IsScalar<T>::value, bool>::type equal(T a, T b) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline bool equal(T a, T b) {
return TypeTraits<T>::equals(a, b); return TypeTraits<T>::equals(a, b);
} }
@ -417,7 +421,11 @@ Calls @ref TypeTraits<T>::equals() --- using fuzzy compare for floating-point
types and doing equality comparison on integral types. Scalar complement to types and doing equality comparison on integral types. Scalar complement to
@ref notEqual(const Vector<size, T>& a, const Vector<size, T>&). @ref notEqual(const Vector<size, T>& a, const Vector<size, T>&).
*/ */
template<class T> inline typename std::enable_if<IsScalar<T>::value, bool>::type notEqual(T a, T b) { template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<IsScalar<T>::value, int>::type = 0
#endif
> inline bool notEqual(T a, T b) {
return !TypeTraits<T>::equals(a, b); return !TypeTraits<T>::equals(a, b);
} }

73
src/Magnum/Math/Unit.h
Unescape View File

@ -178,12 +178,11 @@ template<template<class> class Derived, class T> class Unit {
* Similar to @ref operator*=(T), except that the multiplication is * Similar to @ref operator*=(T), except that the multiplication is
* done in floating-point. * done in floating-point.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class FloatingPoint
template<class FloatingPoint> Unit<Derived, T>& #ifndef DOXYGEN_GENERATING_OUTPUT
#else , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Unit<Derived, T>&>::type #endif
#endif > Unit<Derived, T>& operator*=(FloatingPoint number) {
operator*=(FloatingPoint number) {
_value = T(_value*number); _value = T(_value*number);
return *this; return *this;
} }
@ -199,12 +198,11 @@ template<template<class> class Derived, class T> class Unit {
an out-of-class overload wrapped in CORRADE_MSVC2015_COMPATIBILITY an out-of-class overload wrapped in CORRADE_MSVC2015_COMPATIBILITY
which is (and the two don't conflict, apparently, so both are which is (and the two don't conflict, apparently, so both are
present) */ present) */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class FloatingPoint, class Integral = T
template<class FloatingPoint> constexpr Unit<Derived, T> #ifndef DOXYGEN_GENERATING_OUTPUT
#else , typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Unit<Derived, T>>::type #endif
#endif > constexpr Unit<Derived, T> operator*(FloatingPoint number) const {
operator*(FloatingPoint number) const {
return Unit<Derived, T>{T(_value*number)}; return Unit<Derived, T>{T(_value*number)};
} }
@ -214,12 +212,11 @@ template<template<class> class Derived, class T> class Unit {
* *
* Same as @ref operator*(FloatingPoint) const. * Same as @ref operator*(FloatingPoint) const.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class FloatingPoint
template<class FloatingPoint> friend constexpr Unit<Derived, T> #ifndef DOXYGEN_GENERATING_OUTPUT
#else , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
template<class FloatingPoint, class Integral = T> friend constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Unit<Derived, T>>::type #endif
#endif > friend constexpr Unit<Derived, T> operator*(FloatingPoint number, const Unit<Derived, T>& value) {
operator*(FloatingPoint number, const Unit<Derived, T>& value) {
return Unit<Derived, T>{T(value._value*number)}; return Unit<Derived, T>{T(value._value*number)};
} }
@ -241,12 +238,11 @@ template<template<class> class Derived, class T> class Unit {
* Similar to @ref operator/=(T), except that the division is done in * Similar to @ref operator/=(T), except that the division is done in
* floating-point. * floating-point.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class FloatingPoint
template<class FloatingPoint> Unit<Derived, T>& #ifndef DOXYGEN_GENERATING_OUTPUT
#else , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Unit<Derived, T>&>::type #endif
#endif > Unit<Derived, T>& operator/=(FloatingPoint number) {
operator/=(FloatingPoint number) {
_value = T(_value/number); _value = T(_value/number);
return *this; return *this;
} }
@ -258,12 +254,11 @@ template<template<class> class Derived, class T> class Unit {
* Similar to @ref operator/(T) const, except that the division is done * Similar to @ref operator/(T) const, except that the division is done
* in floating-point. * in floating-point.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class FloatingPoint
template<class FloatingPoint> constexpr Unit<Derived, T> #ifndef DOXYGEN_GENERATING_OUTPUT
#else , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Unit<Derived, T>>::type #endif
#endif > constexpr Unit<Derived, T> operator/(FloatingPoint number) const {
operator/(FloatingPoint number) const {
return Unit<Derived, T>{T(_value/number)}; return Unit<Derived, T>{T(_value/number)};
} }
@ -278,12 +273,10 @@ template<template<class> class Derived, class T> class Unit {
* *
* Enabled only for integral types. * Enabled only for integral types.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
Unit<Derived, T>& template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
#else
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Unit<Derived, T>&>::type
#endif #endif
operator%=(Unit<Derived, T> other) { Unit<Derived, T>& operator%=(Unit<Derived, T> other) {
_value %= other._value; _value %= other._value;
return *this; return *this;
} }
@ -294,12 +287,10 @@ template<template<class> class Derived, class T> class Unit {
* *
* Enabled only for integral types. * Enabled only for integral types.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
constexpr Unit<Derived, T> template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
#else
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Unit<Derived, T>>::type
#endif #endif
operator%(Unit<Derived, T> other) const { constexpr Unit<Derived, T> operator%(Unit<Derived, T> other) const {
return Unit<Derived, T>{_value%other._value}; return Unit<Derived, T>{_value%other._value};
} }
@ -314,7 +305,7 @@ template<template<class> class Derived, class T> class Unit {
picked up correctly (and doesn't conflict with the in-class one). See picked up correctly (and doesn't conflict with the in-class one). See
UnitTest::multiplyDivideIntegral() for regression tests, the same issue and UnitTest::multiplyDivideIntegral() for regression tests, the same issue and
a matching workaround is done in Vector as well. */ a matching workaround is done in Vector as well. */
template<template<class> class Derived, class FloatingPoint, class Integral> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Unit<Derived, Integral>>::type operator*(FloatingPoint number, const Unit<Derived, Integral>& value) { template<template<class> class Derived, class FloatingPoint, class Integral, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Unit<Derived, Integral> operator*(FloatingPoint number, const Unit<Derived, Integral>& value) {
return value*number; return value*number;
} }
#endif #endif

342
src/Magnum/Math/Vector.h
Unescape View File

@ -55,18 +55,18 @@ namespace Magnum { namespace Math {
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
/* Documented in Functions.h, defined here because Vector needs them */ /* Documented in Functions.h, defined here because Vector needs them */
template<class T> inline typename std::enable_if<IsScalar<T>::value, bool>::type isNan(T value) { template<class T, typename std::enable_if<IsScalar<T>::value, int>::type = 0> inline bool isNan(T value) {
return std::isnan(UnderlyingTypeOf<T>(value)); return std::isnan(UnderlyingTypeOf<T>(value));
} }
/* Keeping the same parameter names as in Functions.h so the note about /* Keeping the same parameter names as in Functions.h so the note about
NaN propagation works here too */ NaN propagation works here too */
template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type min(T value, T min) { template<class T, typename std::enable_if<IsScalar<T>::value, int>::type = 0> constexpr T min(T value, T min) {
return min < value ? min : value; return min < value ? min : value;
} }
template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type max(T value, T max) { template<class T, typename std::enable_if<IsScalar<T>::value, int>::type = 0> constexpr T max(T value, T max) {
return value < max ? max : value; return value < max ? max : value;
} }
template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type clamp(T value, T min, T max) { template<class T, typename std::enable_if<IsScalar<T>::value, int>::type = 0> constexpr T clamp(T value, T min, T max) {
return Math::min(Math::max(value, min), max); return Math::min(Math::max(value, min), max);
} }
#endif #endif
@ -139,13 +139,11 @@ dot product is clamped to the @f$ [-1, +1] @f$ range before being passed to
@ref angle(const Complex<T>&, const Complex<T>&), @ref angle(const Complex<T>&, const Complex<T>&),
@ref angle(const Quaternion<T>&, const Quaternion<T>&) @ref angle(const Quaternion<T>&, const Quaternion<T>&)
*/ */
template<std::size_t size, class FloatingPoint> inline template<std::size_t size, class FloatingPoint
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
Rad<FloatingPoint> , typename std::enable_if<std::is_floating_point<FloatingPoint>::value, int>::type = 0
#else #endif
typename std::enable_if<std::is_floating_point<FloatingPoint>::value, Rad<FloatingPoint>>::type > inline Rad<FloatingPoint> angle(const Vector<size, FloatingPoint>& normalizedA, const Vector<size, FloatingPoint>& normalizedB) {
#endif
angle(const Vector<size, FloatingPoint>& normalizedA, const Vector<size, FloatingPoint>& normalizedB) {
CORRADE_DEBUG_ASSERT(normalizedA.isNormalized() && normalizedB.isNormalized(), CORRADE_DEBUG_ASSERT(normalizedA.isNormalized() && normalizedB.isNormalized(),
"Math::angle(): vectors" << normalizedA << "and" << normalizedB << "are not normalized", {}); "Math::angle(): vectors" << normalizedA << "and" << normalizedB << "are not normalized", {});
return Rad<FloatingPoint>(std::acos(clamp(dot(normalizedA, normalizedB), FloatingPoint(-1), FloatingPoint(1)))); return Rad<FloatingPoint>(std::acos(clamp(dot(normalizedA, normalizedB), FloatingPoint(-1), FloatingPoint(1))));
@ -217,11 +215,11 @@ template<std::size_t size, class T> class Vector {
explicit Vector(Magnum::NoInitT) noexcept {} explicit Vector(Magnum::NoInitT) noexcept {}
/** @brief Construct a vector from components */ /** @brief Construct a vector from components */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class ...U
template<class ...U> constexpr /*implicit*/ Vector(T first, U... next) noexcept; #ifndef DOXYGEN_GENERATING_OUTPUT
#else , typename std::enable_if<sizeof...(U)+1 == size, int>::type = 0
template<class ...U, class V = typename std::enable_if<sizeof...(U)+1 == size, T>::type> constexpr /*implicit*/ Vector(T first, U... next) noexcept: _data{first, next...} {} #endif
#endif > constexpr /*implicit*/ Vector(T first, U... next) noexcept: _data{first, next...} {}
/** /**
* @brief Construct a vector from a fixed-size array * @brief Construct a vector from a fixed-size array
@ -243,9 +241,9 @@ template<std::size_t size, class T> class Vector {
/** @brief Construct a vector with one value for all components */ /** @brief Construct a vector with one value for all components */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifdef DOXYGEN_GENERATING_OUTPUT
constexpr explicit Vector(T value) noexcept; constexpr explicit Vector(T value) noexcept; /* showing T instead of U */
#else #else
template<class U, class V = typename std::enable_if<std::is_same<T, U>::value && size != 1, T>::type> constexpr explicit Vector(U value) noexcept: Vector(typename Containers::Implementation::GenerateSequence<size>::Type{}, value) {} template<class U, typename std::enable_if<std::is_same<T, U>::value && size != 1, int>::type = 0> constexpr explicit Vector(U value) noexcept: Vector(typename Containers::Implementation::GenerateSequence<size>::Type{}, value) {}
#endif #endif
/** /**
@ -399,12 +397,10 @@ template<std::size_t size, class T> class Vector {
* @f] * @f]
* @see @ref flipped(), @ref Vector2::perpendicular() * @see @ref flipped(), @ref Vector2::perpendicular()
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
constexpr Vector<size, T> template<class U = T, typename std::enable_if<std::is_signed<U>::value, int>::type = 0>
#else
template<class U = T> constexpr typename std::enable_if<std::is_signed<U>::value, Vector<size, T>>::type
#endif #endif
operator-() const { constexpr Vector<size, T> operator-() const {
return negateInternal(typename Containers::Implementation::GenerateSequence<size>::Type{}); return negateInternal(typename Containers::Implementation::GenerateSequence<size>::Type{});
} }
@ -503,12 +499,11 @@ template<std::size_t size, class T> class Vector {
* Similar to @ref operator*=(T), except that the multiplication is * Similar to @ref operator*=(T), except that the multiplication is
* done in floating-point. The computation is done in-place. * done in floating-point. The computation is done in-place.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class FloatingPoint
template<class FloatingPoint> Vector<size, T>& #ifndef DOXYGEN_GENERATING_OUTPUT
#else , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>&>::type #endif
#endif > Vector<size, T>& operator*=(FloatingPoint scalar) {
operator*=(FloatingPoint scalar) {
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
_data[i] = T(_data[i]*scalar); _data[i] = T(_data[i]*scalar);
@ -521,12 +516,11 @@ template<std::size_t size, class T> class Vector {
* Similar to @ref operator*(T) const, except that the multiplication * Similar to @ref operator*(T) const, except that the multiplication
* is done in floating-point. * is done in floating-point.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class FloatingPoint
template<class FloatingPoint> constexpr Vector<size, T> #ifndef DOXYGEN_GENERATING_OUTPUT
#else , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>>::type #endif
#endif > constexpr Vector<size, T> operator*(FloatingPoint scalar) const {
operator*(FloatingPoint scalar) const {
return multiplyIntegerInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{}); return multiplyIntegerInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{});
} }
@ -539,11 +533,11 @@ template<std::size_t size, class T> class Vector {
an out-of-class overload wrapped in CORRADE_MSVC2015_COMPATIBILITY an out-of-class overload wrapped in CORRADE_MSVC2015_COMPATIBILITY
which is (and the two don't conflict, apparently, so both are which is (and the two don't conflict, apparently, so both are
present) */ present) */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class FloatingPoint
template<class FloatingPoint> friend constexpr Vector<size, T> #ifndef DOXYGEN_GENERATING_OUTPUT
#else , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
template<class FloatingPoint, class Integral = T> friend constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>>::type #endif
#endif > friend constexpr Vector<size, T>
operator*(FloatingPoint scalar, const Vector<size, T>& vector) { operator*(FloatingPoint scalar, const Vector<size, T>& vector) {
return vector*scalar; return vector*scalar;
} }
@ -600,12 +594,11 @@ template<std::size_t size, class T> class Vector {
* Similar to @ref operator/=(T), except that the division is done in * Similar to @ref operator/=(T), except that the division is done in
* floating-point. The computation is done in-place. * floating-point. The computation is done in-place.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class FloatingPoint
template<class FloatingPoint> Vector<size, Integral>& #ifndef DOXYGEN_GENERATING_OUTPUT
#else , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>&>::type #endif
#endif > Vector<size, T>& operator/=(FloatingPoint scalar) {
operator/=(FloatingPoint scalar) {
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
_data[i] = T(_data[i]/scalar); _data[i] = T(_data[i]/scalar);
@ -618,12 +611,11 @@ template<std::size_t size, class T> class Vector {
* Similar to @ref operator/(T) const, except that the division is done * Similar to @ref operator/(T) const, except that the division is done
* in floating-point. * in floating-point.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class FloatingPoint
template<class FloatingPoint> Vector<size, T> constexpr #ifndef DOXYGEN_GENERATING_OUTPUT
#else , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>>::type #endif
#endif > constexpr Vector<size, T> operator/(FloatingPoint scalar) const {
operator/(FloatingPoint scalar) const {
return divideIntegerInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{}); return divideIntegerInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{});
} }
@ -661,12 +653,11 @@ template<std::size_t size, class T> class Vector {
* multiplication is done in floating-point. The computation is done * multiplication is done in floating-point. The computation is done
* in-place. * in-place.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class FloatingPoint
template<class FloatingPoint> Vector<size, T>& #ifndef DOXYGEN_GENERATING_OUTPUT
#else , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>&>::type #endif
#endif > Vector<size, T>& operator*=(const Vector<size, FloatingPoint>& other) {
operator*=(const Vector<size, FloatingPoint>& other) {
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
_data[i] = T(_data[i]*other._data[i]); _data[i] = T(_data[i]*other._data[i]);
@ -683,7 +674,7 @@ template<std::size_t size, class T> class Vector {
*/ */
template<class FloatingPoint template<class FloatingPoint
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value>::type* = nullptr , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
#endif #endif
> constexpr Vector<size, T> operator*(const Vector<size, FloatingPoint>& other) const { > constexpr Vector<size, T> operator*(const Vector<size, FloatingPoint>& other) const {
return multiplyIntegerInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); return multiplyIntegerInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{});
@ -701,7 +692,7 @@ template<std::size_t size, class T> class Vector {
Integral*FloatingPoint variant above */ Integral*FloatingPoint variant above */
template<class Integral template<class Integral
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
, class FloatingPoint = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value>::type* = nullptr , class FloatingPoint = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
#endif #endif
> constexpr Vector<size, Integral> operator*(const Vector<size, Integral>& other) const { > constexpr Vector<size, Integral> operator*(const Vector<size, Integral>& other) const {
return other**this; return other**this;
@ -740,12 +731,11 @@ template<std::size_t size, class T> class Vector {
* division is done in floating-point. The computation is done * division is done in floating-point. The computation is done
* in-place. * in-place.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class FloatingPoint
template<class FloatingPoint> Vector<size, T>& #ifndef DOXYGEN_GENERATING_OUTPUT
#else , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>&>::type #endif
#endif > Vector<size, T>& operator/=(const Vector<size, FloatingPoint>& other) {
operator/=(const Vector<size, FloatingPoint>& other) {
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
_data[i] = T(_data[i]/other._data[i]); _data[i] = T(_data[i]/other._data[i]);
@ -760,12 +750,11 @@ template<std::size_t size, class T> class Vector {
* always an integral vector, convert both arguments to the same * always an integral vector, convert both arguments to the same
* floating-point type to have a floating-point result. * floating-point type to have a floating-point result.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT template<class FloatingPoint
template<class FloatingPoint> constexpr Vector<size, T> #ifndef DOXYGEN_GENERATING_OUTPUT
#else , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>>::type #endif
#endif > constexpr Vector<size, T> operator/(const Vector<size, FloatingPoint>& other) const {
operator/(const Vector<size, FloatingPoint>& other) const {
return divideIntegerInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); return divideIntegerInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{});
} }
@ -774,12 +763,10 @@ template<std::size_t size, class T> class Vector {
* *
* Enabled only for integral types. The computation is done in-place. * Enabled only for integral types. The computation is done in-place.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
Vector<size, T>& template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
#else
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>&>::type
#endif #endif
operator%=(T scalar) { Vector<size, T>& operator%=(T scalar) {
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
_data[i] %= scalar; _data[i] %= scalar;
@ -791,12 +778,10 @@ template<std::size_t size, class T> class Vector {
* *
* Enabled only for integral types. * Enabled only for integral types.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
constexpr Vector<size, T> template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
#else
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type
#endif #endif
operator%(T scalar) const { constexpr Vector<size, T> operator%(T scalar) const {
return moduloInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{}); return moduloInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{});
} }
@ -805,12 +790,10 @@ template<std::size_t size, class T> class Vector {
* *
* Enabled only for integral types. The computation is done in-place. * Enabled only for integral types. The computation is done in-place.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
Vector<size, T>& template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
#else
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>&>::type
#endif #endif
operator%=(const Vector<size, T>& other) { Vector<size, T>& operator%=(const Vector<size, T>& other) {
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
_data[i] %= other._data[i]; _data[i] %= other._data[i];
@ -822,12 +805,10 @@ template<std::size_t size, class T> class Vector {
* *
* Enabled only for integral types. * Enabled only for integral types.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
constexpr Vector<size, T> template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
#else
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type
#endif #endif
operator%(const Vector<size, T>& other) const { constexpr Vector<size, T> operator%(const Vector<size, T>& other) const {
return moduloInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); return moduloInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{});
} }
@ -836,12 +817,10 @@ template<std::size_t size, class T> class Vector {
* *
* Enabled only for integral types. * Enabled only for integral types.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
constexpr Vector<size, T> template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
#else
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type
#endif #endif
operator~() const { constexpr Vector<size, T> operator~() const {
return invertInternal(typename Containers::Implementation::GenerateSequence<size>::Type{}); return invertInternal(typename Containers::Implementation::GenerateSequence<size>::Type{});
} }
@ -850,12 +829,10 @@ template<std::size_t size, class T> class Vector {
* *
* Enabled only for integral types. The computation is done in-place. * Enabled only for integral types. The computation is done in-place.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
Vector<size, T>& template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
#else
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>&>::type
#endif #endif
operator&=(const Vector<size, T>& other) { Vector<size, T>& operator&=(const Vector<size, T>& other) {
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
_data[i] &= other._data[i]; _data[i] &= other._data[i];
@ -867,12 +844,10 @@ template<std::size_t size, class T> class Vector {
* *
* Enabled only for integral types. * Enabled only for integral types.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
constexpr Vector<size, T> template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
#else
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type
#endif #endif
operator&(const Vector<size, T>& other) const { constexpr Vector<size, T> operator&(const Vector<size, T>& other) const {
return andInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); return andInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{});
} }
@ -881,12 +856,10 @@ template<std::size_t size, class T> class Vector {
* *
* Enabled only for integral types. The computation is done in-place. * Enabled only for integral types. The computation is done in-place.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
Vector<size, T>& template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
#else
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>&>::type
#endif #endif
operator|=(const Vector<size, T>& other) { Vector<size, T>& operator|=(const Vector<size, T>& other) {
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
_data[i] |= other._data[i]; _data[i] |= other._data[i];
@ -898,12 +871,10 @@ template<std::size_t size, class T> class Vector {
* *
* Enabled only for integral types. * Enabled only for integral types.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
constexpr Vector<size, T> template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
#else
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type
#endif #endif
operator|(const Vector<size, T>& other) const { constexpr Vector<size, T> operator|(const Vector<size, T>& other) const {
return orInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); return orInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{});
} }
@ -912,12 +883,10 @@ template<std::size_t size, class T> class Vector {
* *
* Enabled only for integral types. The computation is done in-place. * Enabled only for integral types. The computation is done in-place.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
Vector<size, T>& template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
#else
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>&>::type
#endif #endif
operator^=(const Vector<size, T>& other) { Vector<size, T>& operator^=(const Vector<size, T>& other) {
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
_data[i] ^= other._data[i]; _data[i] ^= other._data[i];
@ -929,12 +898,10 @@ template<std::size_t size, class T> class Vector {
* *
* Enabled only for integral types. * Enabled only for integral types.
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
constexpr Vector<size, T> template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
#else
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type
#endif #endif
operator^(const Vector<size, T>& other) const { constexpr Vector<size, T> operator^(const Vector<size, T>& other) const {
return xorInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); return xorInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{});
} }
@ -946,7 +913,7 @@ template<std::size_t size, class T> class Vector {
#ifdef DOXYGEN_GENERATING_OUTPUT #ifdef DOXYGEN_GENERATING_OUTPUT
Vector<size, T>& operator<<=(T shift) Vector<size, T>& operator<<=(T shift)
#else #else
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>&>::type operator<<=(typename std::common_type<T>::type shift) template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Vector<size, T>& operator<<=(typename std::common_type<T>::type shift)
#endif #endif
{ {
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
@ -963,8 +930,7 @@ template<std::size_t size, class T> class Vector {
#ifdef DOXYGEN_GENERATING_OUTPUT #ifdef DOXYGEN_GENERATING_OUTPUT
constexpr Vector<size, T> operator<<(T shift) const constexpr Vector<size, T> operator<<(T shift) const
#else #else
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Vector<size, T> operator<<(typename std::common_type<T>::type shift) const
operator<<(typename std::common_type<T>::type shift) const
#endif #endif
{ {
return shiftLeftInternal(shift, typename Containers::Implementation::GenerateSequence<size>::Type{}); return shiftLeftInternal(shift, typename Containers::Implementation::GenerateSequence<size>::Type{});
@ -978,7 +944,7 @@ template<std::size_t size, class T> class Vector {
#ifdef DOXYGEN_GENERATING_OUTPUT #ifdef DOXYGEN_GENERATING_OUTPUT
Vector<size, T>& operator>>=(T shift) Vector<size, T>& operator>>=(T shift)
#else #else
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>&>::type operator>>=(typename std::common_type<T>::type shift) template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Vector<size, T>& operator>>=(typename std::common_type<T>::type shift)
#endif #endif
{ {
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
@ -995,8 +961,8 @@ template<std::size_t size, class T> class Vector {
#ifdef DOXYGEN_GENERATING_OUTPUT #ifdef DOXYGEN_GENERATING_OUTPUT
constexpr Vector<size, T> operator>>(T shift) const constexpr Vector<size, T> operator>>(T shift) const
#else #else
template<class Integral = T> template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type operator>>(typename std::common_type<T>::type shift) const constexpr Vector<size, T> operator>>(typename std::common_type<T>::type shift) const
#endif #endif
{ {
return shiftRightInternal(shift, typename Containers::Implementation::GenerateSequence<size>::Type{}); return shiftRightInternal(shift, typename Containers::Implementation::GenerateSequence<size>::Type{});
@ -1051,12 +1017,10 @@ template<std::size_t size, class T> class Vector {
* @see @ref length(), @ref Math::sqrtInverted(), @ref normalized(), * @see @ref length(), @ref Math::sqrtInverted(), @ref normalized(),
* @ref resized() * @ref resized()
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
T template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0>
#else
template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, T>::type
#endif #endif
lengthInverted() const { return T(1)/length(); } T lengthInverted() const { return T(1)/length(); }
/** /**
* @brief Normalized vector (of unit length) * @brief Normalized vector (of unit length)
@ -1065,12 +1029,10 @@ template<std::size_t size, class T> class Vector {
* @see @ref isNormalized(), @ref lengthInverted(), @ref resized() * @see @ref isNormalized(), @ref lengthInverted(), @ref resized()
* @m_keyword{normalize(),GLSL normalize(),} * @m_keyword{normalize(),GLSL normalize(),}
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
Vector<size, T> template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0>
#else
template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Vector<size, T>>::type
#endif #endif
normalized() const { return *this*lengthInverted(); } Vector<size, T> normalized() const { return *this*lengthInverted(); }
/** /**
* @brief Resized vector * @brief Resized vector
@ -1083,12 +1045,10 @@ template<std::size_t size, class T> class Vector {
* *
* @see @ref normalized() * @see @ref normalized()
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
Vector<size, T> template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0>
#else
template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Vector<size, T>>::type
#endif #endif
resized(T length) const { Vector<size, T> resized(T length) const {
return *this*(lengthInverted()*length); return *this*(lengthInverted()*length);
} }
@ -1101,12 +1061,10 @@ template<std::size_t size, class T> class Vector {
* @f] * @f]
* @see @ref Math::dot(), @ref projectedOntoNormalized() * @see @ref Math::dot(), @ref projectedOntoNormalized()
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
Vector<size, T> template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0>
#else
template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Vector<size, T>>::type
#endif #endif
projected(const Vector<size, T>& line) const { Vector<size, T> projected(const Vector<size, T>& line) const {
return line*Math::dot(*this, line)/line.dot(); return line*Math::dot(*this, line)/line.dot();
} }
@ -1121,11 +1079,10 @@ template<std::size_t size, class T> class Vector {
* @see @ref Math::dot() * @see @ref Math::dot()
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifdef DOXYGEN_GENERATING_OUTPUT
Vector<size, T>
#else #else
template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Vector<size, T>>::type template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0>
#endif #endif
projectedOntoNormalized(const Vector<size, T>& line) const; Vector<size, T> projectedOntoNormalized(const Vector<size, T>& line) const;
/** /**
* @brief Flipped vector * @brief Flipped vector
@ -1398,8 +1355,7 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const Vector<4, Double>&
constexpr Type_<T> operator+() const { \ constexpr Type_<T> operator+() const { \
return Math::Vector<size, T>::operator+(); \ return Math::Vector<size, T>::operator+(); \
} \ } \
template<class U = T> constexpr typename std::enable_if<std::is_signed<U>::value, Type_<T>>::type \ template<class U = T, typename std::enable_if<std::is_signed<U>::value, int>::type = 0> constexpr Type_<T> operator-() const { \
operator-() const { \
return Math::Vector<size, T>::negateInternal(typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::negateInternal(typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
Type_<T>& operator+=(const Math::Vector<size, T>& other) { \ Type_<T>& operator+=(const Math::Vector<size, T>& other) { \
@ -1427,14 +1383,14 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const Vector<4, Double>&
friend constexpr Type_<T> operator*(typename std::common_type<T>::type scalar, const Type_<T>& vector) { \ friend constexpr Type_<T> operator*(typename std::common_type<T>::type scalar, const Type_<T>& vector) { \
return scalar*static_cast<const Math::Vector<size, T>&>(vector); \ return scalar*static_cast<const Math::Vector<size, T>&>(vector); \
} \ } \
template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>&>::type operator*=(FloatingPoint scalar) { \ template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> Type_<T>& operator*=(FloatingPoint scalar) { \
Math::Vector<size, T>::operator*=(scalar); \ Math::Vector<size, T>::operator*=(scalar); \
return *this; \ return *this; \
} \ } \
template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>>::type operator*(FloatingPoint scalar) const { \ template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Type_<T> operator*(FloatingPoint scalar) const { \
return Math::Vector<size, T>::multiplyIntegerInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::multiplyIntegerInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
template<class FloatingPoint, class Integral = T> friend constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>>::type operator*(FloatingPoint scalar, const Type_<T>& vector) { \ template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> friend constexpr Type_<T> operator*(FloatingPoint scalar, const Type_<T>& vector) { \
return scalar*static_cast<const Math::Vector<size, T>&>(vector); \ return scalar*static_cast<const Math::Vector<size, T>&>(vector); \
} \ } \
\ \
@ -1448,11 +1404,11 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const Vector<4, Double>&
friend constexpr Type_<T> operator/(typename std::common_type<T>::type scalar, const Type_<T>& vector) { \ friend constexpr Type_<T> operator/(typename std::common_type<T>::type scalar, const Type_<T>& vector) { \
return scalar/static_cast<const Math::Vector<size, T>&>(vector); \ return scalar/static_cast<const Math::Vector<size, T>&>(vector); \
} \ } \
template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>&>::type operator/=(FloatingPoint scalar) { \ template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> Type_<T>& operator/=(FloatingPoint scalar) { \
Math::Vector<size, T>::operator/=(scalar); \ Math::Vector<size, T>::operator/=(scalar); \
return *this; \ return *this; \
} \ } \
template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>>::type operator/(FloatingPoint scalar) const { \ template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Type_<T> operator/(FloatingPoint scalar) const { \
return Math::Vector<size, T>::divideIntegerInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::divideIntegerInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
\ \
@ -1463,14 +1419,14 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const Vector<4, Double>&
constexpr Type_<T> operator*(const Math::Vector<size, T>& other) const { \ constexpr Type_<T> operator*(const Math::Vector<size, T>& other) const { \
return Math::Vector<size, T>::multiplyInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::multiplyInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>&>::type operator*=(const Math::Vector<size, FloatingPoint>& other) { \ template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> Type_<T>& operator*=(const Math::Vector<size, FloatingPoint>& other) { \
Math::Vector<size, T>::operator*=(other); \ Math::Vector<size, T>::operator*=(other); \
return *this; \ return *this; \
} \ } \
template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value>::type* = nullptr> constexpr Type_<T> operator*(const Math::Vector<size, FloatingPoint>& other) const { \ template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Type_<T> operator*(const Math::Vector<size, FloatingPoint>& other) const { \
return Math::Vector<size, T>::multiplyIntegerInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::multiplyIntegerInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
template<class Integral, class FloatingPoint = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value>::type* = nullptr> constexpr Type_<Integral> operator*(const Math::Vector<size, Integral>& other) const { \ template<class Integral, class FloatingPoint = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Type_<Integral> operator*(const Math::Vector<size, Integral>& other) const { \
return other**this; \ return other**this; \
} \ } \
\ \
@ -1481,78 +1437,78 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const Vector<4, Double>&
constexpr Type_<T> operator/(const Math::Vector<size, T>& other) const { \ constexpr Type_<T> operator/(const Math::Vector<size, T>& other) const { \
return Math::Vector<size, T>::divideInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::divideInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>&>::type operator/=(const Math::Vector<size, FloatingPoint>& other) { \ template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> Type_<T>& operator/=(const Math::Vector<size, FloatingPoint>& other) { \
Math::Vector<size, T>::operator/=(other); \ Math::Vector<size, T>::operator/=(other); \
return *this; \ return *this; \
} \ } \
template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>>::type operator/(const Math::Vector<size, FloatingPoint>& other) const { \ template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Type_<T> operator/(const Math::Vector<size, FloatingPoint>& other) const { \
return Math::Vector<size, T>::divideIntegerInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::divideIntegerInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
\ \
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Type_<T>&>::type operator%=(T scalar) { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Type_<T>& operator%=(T scalar) { \
Math::Vector<size, T>::operator%=(scalar); \ Math::Vector<size, T>::operator%=(scalar); \
return *this; \ return *this; \
} \ } \
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator%(T scalar) const { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator%(T scalar) const { \
return Math::Vector<size, T>::moduloInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::moduloInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Type_<T>&>::type operator%=(const Math::Vector<size, T>& other) { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Type_<T>& operator%=(const Math::Vector<size, T>& other) { \
Math::Vector<size, T>::operator%=(other); \ Math::Vector<size, T>::operator%=(other); \
return *this; \ return *this; \
} \ } \
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator%(const Math::Vector<size, T>& other) const { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator%(const Math::Vector<size, T>& other) const { \
return Math::Vector<size, T>::moduloInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::moduloInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
\ \
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator~() const { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator~() const { \
return Math::Vector<size, T>::invertInternal(typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::invertInternal(typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Type_<T>&>::type operator&=(const Math::Vector<size, T>& other) { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Type_<T>& operator&=(const Math::Vector<size, T>& other) { \
Math::Vector<size, T>::operator&=(other); \ Math::Vector<size, T>::operator&=(other); \
return *this; \ return *this; \
} \ } \
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator&(const Math::Vector<size, T>& other) const { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator&(const Math::Vector<size, T>& other) const { \
return Math::Vector<size, T>::andInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::andInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Type_<T>&>::type operator|=(const Math::Vector<size, T>& other) { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Type_<T>& operator|=(const Math::Vector<size, T>& other) { \
Math::Vector<size, T>::operator|=(other); \ Math::Vector<size, T>::operator|=(other); \
return *this; \ return *this; \
} \ } \
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator|(const Math::Vector<size, T>& other) const { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator|(const Math::Vector<size, T>& other) const { \
return Math::Vector<size, T>::orInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::orInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Type_<T>&>::type operator^=(const Math::Vector<size, T>& other) { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Type_<T>& operator^=(const Math::Vector<size, T>& other) { \
Math::Vector<size, T>::operator^=(other); \ Math::Vector<size, T>::operator^=(other); \
return *this; \ return *this; \
} \ } \
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator^(const Math::Vector<size, T>& other) const { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator^(const Math::Vector<size, T>& other) const { \
return Math::Vector<size, T>::xorInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::xorInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Type_<T>&>::type operator<<=(typename std::common_type<T>::type shift) { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Type_<T>& operator<<=(typename std::common_type<T>::type shift) { \
Math::Vector<size, T>::operator<<=(shift); \ Math::Vector<size, T>::operator<<=(shift); \
return *this; \ return *this; \
} \ } \
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator<<(typename std::common_type<T>::type shift) const { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator<<(typename std::common_type<T>::type shift) const { \
return Math::Vector<size, T>::shiftLeftInternal(shift, typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::shiftLeftInternal(shift, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Type_<T>&>::type operator>>=(typename std::common_type<T>::type shift) { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Type_<T>& operator>>=(typename std::common_type<T>::type shift) { \
Math::Vector<size, T>::operator>>=(shift); \ Math::Vector<size, T>::operator>>=(shift); \
return *this; \ return *this; \
} \ } \
template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator>>(typename std::common_type<T>::type shift) const { \ template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator>>(typename std::common_type<T>::type shift) const { \
return Math::Vector<size, T>::shiftRightInternal(shift, typename Containers::Implementation::GenerateSequence<size>::Type{}); \ return Math::Vector<size, T>::shiftRightInternal(shift, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
} \ } \
\ \
template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Type_<T>>::type normalized() const { \ template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0> Type_<T> normalized() const { \
return Math::Vector<size, T>::normalized(); \ return Math::Vector<size, T>::normalized(); \
} \ } \
template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Type_<T>>::type resized(T length) const { \ template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0> Type_<T> resized(T length) const { \
return Math::Vector<size, T>::resized(length); \ return Math::Vector<size, T>::resized(length); \
} \ } \
template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Type_<T>>::type projected(const Math::Vector<size, T>& other) const { \ template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0> Type_<T> projected(const Math::Vector<size, T>& other) const { \
return Math::Vector<size, T>::projected(other); \ return Math::Vector<size, T>::projected(other); \
} \ } \
template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Type_<T>>::type projectedOntoNormalized(const Math::Vector<size, T>& other) const { \ template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0> Type_<T> projectedOntoNormalized(const Math::Vector<size, T>& other) const { \
return Math::Vector<size, T>::projectedOntoNormalized(other); \ return Math::Vector<size, T>::projectedOntoNormalized(other); \
} \ } \
constexpr Type_<T> flipped() const { \ constexpr Type_<T> flipped() const { \
@ -1570,12 +1526,12 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const Vector<4, Double>&
VectorTest::subclass() and corresponding cases in Vector2Test, Vector3Test, VectorTest::subclass() and corresponding cases in Vector2Test, Vector3Test,
Vector4Test and ColorTest for regression tests. The same issue and a Vector4Test and ColorTest for regression tests. The same issue and a
matching workaround is done in Unit as well. */ matching workaround is done in Unit as well. */
template<std::size_t size, class FloatingPoint, class Integral> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, Integral>>::type operator*(FloatingPoint scalar, const Vector<size, Integral>& vector) { template<std::size_t size, class FloatingPoint, class Integral, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Vector<size, Integral> operator*(FloatingPoint scalar, const Vector<size, Integral>& vector) {
return vector*scalar; return vector*scalar;
} }
#define MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(size, Type) \ #define MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(size, Type) \
template<class FloatingPoint, class Integral> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type<Integral>>::type operator*(FloatingPoint scalar, const Type<Integral>& vector) { \ template<class FloatingPoint, class Integral, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Type<Integral> operator*(FloatingPoint scalar, const Type<Integral>& vector) { \
return vector*scalar; \ return vector*scalar; \
} }
#endif #endif
@ -1617,12 +1573,10 @@ template<std::size_t size, class T> inline BitVector<size> Vector<size, T>::oper
} }
template<std::size_t size, class T> template<std::size_t size, class T>
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
inline Vector<size, T> template<class U, typename std::enable_if<std::is_floating_point<U>::value, int>::type>
#else
template<class U> inline typename std::enable_if<std::is_floating_point<U>::value, Vector<size, T>>::type
#endif #endif
Vector<size, T>::projectedOntoNormalized(const Vector<size, T>& line) const { inline Vector<size, T> Vector<size, T>::projectedOntoNormalized(const Vector<size, T>& line) const {
CORRADE_DEBUG_ASSERT(line.isNormalized(), CORRADE_DEBUG_ASSERT(line.isNormalized(),
"Math::Vector::projectedOntoNormalized(): line" << line << "is not normalized", {}); "Math::Vector::projectedOntoNormalized(): line" << line << "is not normalized", {});
return line*Math::dot(*this, line); return line*Math::dot(*this, line);

16
src/Magnum/Math/Vector2.h
Unescape View File

@ -220,12 +220,10 @@ template<class T> class Vector2: public Vector<2, T> {
* @ref Vector::operator-() const "operator-() const" * @ref Vector::operator-() const "operator-() const"
*/ */
/* For some reason @ref operator-() const doesn't work since 1.8.17 */ /* For some reason @ref operator-() const doesn't work since 1.8.17 */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
Vector2<T> template<class U = T, typename std::enable_if<std::is_signed<U>::value, int>::type = 0>
#else
template<class U = T> typename std::enable_if<std::is_signed<U>::value, Vector2<T>>::type
#endif #endif
perpendicular() const { return {-y(), x()}; } Vector2<T> perpendicular() const { return {-y(), x()}; }
/** /**
* @brief Aspect ratio * @brief Aspect ratio
@ -235,12 +233,10 @@ template<class T> class Vector2: public Vector<2, T> {
* a = \frac{v_x}{v_y} * a = \frac{v_x}{v_y}
* @f] * @f]
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
T template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0>
#else
template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, T>::type
#endif #endif
aspectRatio() const { return x()/y(); } T aspectRatio() const { return x()/y(); }
MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(2, Vector2) MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(2, Vector2)

8
src/Magnum/MeshTools/Interleave.h
Unescape View File

@ -50,7 +50,7 @@ namespace Implementation {
resolution (the functions would otherwise need to be de-inlined to break resolution (the functions would otherwise need to be de-inlined to break
cyclic dependencies) */ cyclic dependencies) */
struct AttributeCount { struct AttributeCount {
template<class T, class ...U> typename std::enable_if<!std::is_convertible<T, std::size_t>::value, std::size_t>::type operator()(const T& first, const U&... template<class T, class ...U, typename std::enable_if<!std::is_convertible<T, std::size_t>::value, int>::type = 0> std::size_t operator()(const T& first, const U&...
#ifndef CORRADE_NO_ASSERT #ifndef CORRADE_NO_ASSERT
next next
#endif #endif
@ -90,7 +90,7 @@ template<class T> constexpr std::size_t typeSize() {
/* Stride, taking gaps into account. It must be in the structure, same reason /* Stride, taking gaps into account. It must be in the structure, same reason
as above */ as above */
struct Stride { struct Stride {
template<class T, class ...U> typename std::enable_if<!std::is_convertible<T, std::size_t>::value, std::size_t>::type operator()(const T&, const U&... next) const { template<class T, class ...U, typename std::enable_if<!std::is_convertible<T, std::size_t>::value, int>::type = 0> std::size_t operator()(const T&, const U&... next) const {
return typeSize<T>() + Stride{}(next...); return typeSize<T>() + Stride{}(next...);
} }
template<class... T> std::size_t operator()(std::size_t gap, const T&... next) const { template<class... T> std::size_t operator()(std::size_t gap, const T&... next) const {
@ -100,7 +100,7 @@ struct Stride {
}; };
/* Copy data to the buffer */ /* Copy data to the buffer */
template<class T> typename std::enable_if<!std::is_convertible<T, std::size_t>::value, std::size_t>::type writeOneInterleaved(std::size_t stride, char* startingOffset, const T& attributeList) { template<class T, typename std::enable_if<!std::is_convertible<T, std::size_t>::value, int>::type = 0> std::size_t writeOneInterleaved(std::size_t stride, char* startingOffset, const T& attributeList) {
auto it = attributeList.begin(); auto it = attributeList.begin();
for(std::size_t i = 0; i != attributeList.size(); ++i, ++it) for(std::size_t i = 0; i != attributeList.size(); ++i, ++it)
std::memcpy(startingOffset + i*stride, reinterpret_cast<const char*>(&*it), typeSize<T>()); std::memcpy(startingOffset + i*stride, reinterpret_cast<const char*>(&*it), typeSize<T>());
@ -150,7 +150,7 @@ would be 21 bytes, causing possible performance loss.
template<class T, class ...U template<class T, class ...U
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
/* So it doesn't clash with the MeshData variant */ /* So it doesn't clash with the MeshData variant */
, class = typename std::enable_if<Utility::IsIterable<T>::value>::type , typename std::enable_if<Utility::IsIterable<T>::value, int>::type = 0
#endif #endif
> Containers::Array<char> interleave(const T& first, const U&... next) > Containers::Array<char> interleave(const T& first, const U&... next)
{ {

4
src/Magnum/Platform/ScreenedApplication.h
Unescape View File

@ -295,8 +295,8 @@ template<class Application> class BasicScreenedApplication:
CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") const BasicScreenedApplication<Application>& operator*() const { return *this; } CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") const BasicScreenedApplication<Application>& operator*() const { return *this; }
CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") operator BasicScreenedApplication<Application>*() { return this; } CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") operator BasicScreenedApplication<Application>*() { return this; }
CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") operator const BasicScreenedApplication<Application>*() const { return this; } CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") operator const BasicScreenedApplication<Application>*() const { return this; }
template<class T, class = typename std::enable_if<std::is_base_of<BasicScreenedApplication<Application>, T>::value>::type> CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") operator T*() { return static_cast<T*>(this); } template<class T, typename std::enable_if<std::is_base_of<BasicScreenedApplication<Application>, T>::value, int>::type = 0> CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") operator T*() { return static_cast<T*>(this); }
template<class T, class = typename std::enable_if<std::is_base_of<BasicScreenedApplication<Application>, T>::value>::type> CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") operator const T*() const { return static_cast<const T*>(this); } template<class T, typename std::enable_if<std::is_base_of<BasicScreenedApplication<Application>, T>::value, int>::type = 0> CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") operator const T*() const { return static_cast<const T*>(this); }
CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now, use hasApplication() instead") bool operator!() const { return false; } CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now, use hasApplication() instead") bool operator!() const { return false; }
#endif #endif

2
src/Magnum/SceneGraph/AbstractFeature.h
Unescape View File

@ -161,7 +161,7 @@ template<UnsignedInt dimensions, class T> class AbstractFeature
/* This is here to avoid ambiguity with deleted copy constructor when /* This is here to avoid ambiguity with deleted copy constructor when
passing `*this` from class subclassing both AbstractFeature and passing `*this` from class subclassing both AbstractFeature and
AbstractObject */ AbstractObject */
template<class U, class = typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value>::type> AbstractFeature(U& object): AbstractFeature(static_cast<AbstractObject<dimensions, T>&>(object)) {} template<class U, typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value, int>::type = 0> AbstractFeature(U& object): AbstractFeature(static_cast<AbstractObject<dimensions, T>&>(object)) {}
#endif #endif
virtual ~AbstractFeature() = 0; virtual ~AbstractFeature() = 0;

2
src/Magnum/SceneGraph/Animable.h
Unescape View File

@ -139,7 +139,7 @@ template<UnsignedInt dimensions, class T> class Animable: public AbstractGrouped
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
/* This is here to avoid ambiguity with deleted copy constructor when /* This is here to avoid ambiguity with deleted copy constructor when
passing `*this` from class subclassing both Animable and AbstractObject */ passing `*this` from class subclassing both Animable and AbstractObject */
template<class U, class = typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value>::type> explicit Animable(U& object): Animable<dimensions, T>{static_cast<AbstractObject<dimensions, T>&>(object)} {} template<class U, typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value, int>::type = 0> explicit Animable(U& object): Animable<dimensions, T>{static_cast<AbstractObject<dimensions, T>&>(object)} {}
#endif #endif
~Animable(); ~Animable();

2
src/Magnum/SceneGraph/Camera.h
Unescape View File

@ -100,7 +100,7 @@ template<UnsignedInt dimensions, class T> class Camera: public AbstractFeature<d
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
/* This is here to avoid ambiguity with deleted copy constructor when /* This is here to avoid ambiguity with deleted copy constructor when
passing `*this` from class subclassing both Camera and AbstractObject */ passing `*this` from class subclassing both Camera and AbstractObject */
template<class U, class = typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value>::type> explicit Camera(U& object): Camera<dimensions, T>{static_cast<AbstractObject<dimensions, T>&>(object)} {} template<class U, typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value, int>::type = 0> explicit Camera(U& object): Camera<dimensions, T>{static_cast<AbstractObject<dimensions, T>&>(object)} {}
#endif #endif
~Camera(); ~Camera();

2
src/Magnum/SceneGraph/Drawable.h
Unescape View File

@ -162,7 +162,7 @@ template<UnsignedInt dimensions, class T> class Drawable: public AbstractGrouped
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
/* This is here to avoid ambiguity with deleted copy constructor when /* This is here to avoid ambiguity with deleted copy constructor when
passing `*this` from class subclassing both Drawable and AbstractObject */ passing `*this` from class subclassing both Drawable and AbstractObject */
template<class U, class = typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value>::type> explicit Drawable(U& object): Drawable<dimensions, T>{static_cast<AbstractObject<dimensions, T>&>(object)} {} template<class U, typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value, int>::type = 0> explicit Drawable(U& object): Drawable<dimensions, T>{static_cast<AbstractObject<dimensions, T>&>(object)} {}
#endif #endif
/** /**

30
src/Magnum/Trade/MaterialData.h
Unescape View File

@ -1408,7 +1408,7 @@ class MAGNUM_TRADE_EXPORT MaterialAttributeData {
*/ */
template<class T template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
, class = typename std::enable_if<!std::is_convertible<const T&, Containers::StringView>::value && !std::is_convertible<const T&, Containers::ArrayView<const void>>::value>::type , typename std::enable_if<!std::is_convertible<const T&, Containers::StringView>::value && !std::is_convertible<const T&, Containers::ArrayView<const void>>::value, int>::type = 0
#endif #endif
> constexpr /*implicit*/ MaterialAttributeData(Containers::StringView name, const T& value) noexcept; > constexpr /*implicit*/ MaterialAttributeData(Containers::StringView name, const T& value) noexcept;
@ -1447,7 +1447,7 @@ class MAGNUM_TRADE_EXPORT MaterialAttributeData {
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
/* "Sure can't be constexpr" overloads to avoid going through the /* "Sure can't be constexpr" overloads to avoid going through the
*insane* overload puzzle when not needed */ *insane* overload puzzle when not needed */
template<class T, class = typename std::enable_if<!std::is_convertible<const T&, Containers::StringView>::value && !std::is_convertible<const T&, Containers::ArrayView<const void>>::value>::type> /*implicit*/ MaterialAttributeData(const char* name, const T& value) noexcept: MaterialAttributeData{name, Implementation::MaterialAttributeTypeFor<T>::type(), sizeof(T), &value} {} template<class T, typename std::enable_if<!std::is_convertible<const T&, Containers::StringView>::value && !std::is_convertible<const T&, Containers::ArrayView<const void>>::value, int>::type = 0> /*implicit*/ MaterialAttributeData(const char* name, const T& value) noexcept: MaterialAttributeData{name, Implementation::MaterialAttributeTypeFor<T>::type(), sizeof(T), &value} {}
/*implicit*/ MaterialAttributeData(const char* name, Containers::StringView value) noexcept: MaterialAttributeData{name, MaterialAttributeType::String, 0, &value} {} /*implicit*/ MaterialAttributeData(const char* name, Containers::StringView value) noexcept: MaterialAttributeData{name, MaterialAttributeType::String, 0, &value} {}
#endif #endif
@ -1466,7 +1466,7 @@ class MAGNUM_TRADE_EXPORT MaterialAttributeData {
*/ */
template<class T template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
, class = typename std::enable_if<!std::is_convertible<const T&, Containers::StringView>::value>::type , typename std::enable_if<!std::is_convertible<const T&, Containers::StringView>::value, int>::type = 0
#endif #endif
> /*implicit*/ MaterialAttributeData(MaterialAttribute name, const T& value) noexcept: MaterialAttributeData{name, Implementation::MaterialAttributeTypeFor<T>::type(), &value} {} > /*implicit*/ MaterialAttributeData(MaterialAttribute name, const T& value) noexcept: MaterialAttributeData{name, Implementation::MaterialAttributeTypeFor<T>::type(), &value} {}
@ -1677,18 +1677,18 @@ class MAGNUM_TRADE_EXPORT MaterialAttributeData {
constexpr explicit Storage(Containers::StringView name, Containers::StringView value) noexcept: s{MaterialAttributeType::String, name, value} {} constexpr explicit Storage(Containers::StringView name, Containers::StringView value) noexcept: s{MaterialAttributeType::String, name, value} {}
template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 1, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _1{type, name, value} {} template<class T, typename std::enable_if<sizeof(T) == 1, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _1{type, name, value} {}
template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 4 && !std::is_pointer<T>::value, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _4{type, name, value} {} template<class T, typename std::enable_if<sizeof(T) == 4 && !std::is_pointer<T>::value, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _4{type, name, value} {}
template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 8 && !Math::IsVector<T>::value && !std::is_pointer<T>::value, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _8{type, name, value} {} template<class T, typename std::enable_if<sizeof(T) == 8 && !Math::IsVector<T>::value && !std::is_pointer<T>::value, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _8{type, name, value} {}
template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 8 && Math::IsVector<T>::value && !std::is_pointer<T>::value, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _8v{type, name, value} {} template<class T, typename std::enable_if<sizeof(T) == 8 && Math::IsVector<T>::value && !std::is_pointer<T>::value, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _8v{type, name, value} {}
constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const void* value) noexcept: p{type, name, value} {} constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const void* value) noexcept: p{type, name, value} {}
template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 12, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _12{type, name, value} {} template<class T, typename std::enable_if<sizeof(T) == 12, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _12{type, name, value} {}
template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 16 && Math::IsVector<T>::value, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _16{type, name, value} {} template<class T, typename std::enable_if<sizeof(T) == 16 && Math::IsVector<T>::value, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _16{type, name, value} {}
template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 16 && !Math::IsVector<T>::value, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _16m{type, name, value} {} template<class T, typename std::enable_if<sizeof(T) == 16 && !Math::IsVector<T>::value, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _16m{type, name, value} {}
template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 24, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _24{type, name, value} {} template<class T, typename std::enable_if<sizeof(T) == 24, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _24{type, name, value} {}
template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 32, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _32{type, name, value} {} template<class T, typename std::enable_if<sizeof(T) == 32, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _32{type, name, value} {}
template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 36, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _36{type, name, value} {} template<class T, typename std::enable_if<sizeof(T) == 36, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _36{type, name, value} {}
template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 48, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _48{type, name, value} {} template<class T, typename std::enable_if<sizeof(T) == 48, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _48{type, name, value} {}
MaterialAttributeType type; MaterialAttributeType type;
char data[Implementation::MaterialAttributeDataSize]; char data[Implementation::MaterialAttributeDataSize];
@ -3563,7 +3563,7 @@ namespace Implementation {
/* The 2 extra bytes are for a null byte after the name and a type */ /* The 2 extra bytes are for a null byte after the name and a type */
template<class T template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
, class , typename std::enable_if<!std::is_convertible<const T&, Containers::StringView>::value && !std::is_convertible<const T&, Containers::ArrayView<const void>>::value, int>::type
#endif #endif
> constexpr MaterialAttributeData::MaterialAttributeData(const Containers::StringView name, const T& value) noexcept: > constexpr MaterialAttributeData::MaterialAttributeData(const Containers::StringView name, const T& value) noexcept:
_data{Implementation::MaterialAttributeTypeFor<T>::type(), ( _data{Implementation::MaterialAttributeTypeFor<T>::type(), (

72
src/Magnum/Trade/MeshData.h
Unescape View File

@ -313,7 +313,7 @@ class MAGNUM_TRADE_EXPORT MeshIndexData {
* @ref MeshIndexData(std::nullptr_t) constructor. * @ref MeshIndexData(std::nullptr_t) constructor.
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<class T, class = typename std::enable_if<std::is_convertible<T, Containers::ArrayView<const void>>::value>::type> explicit MeshIndexData(MeshIndexType type, T&& data) noexcept; template<class T, typename std::enable_if<std::is_convertible<T, Containers::ArrayView<const void>>::value, int>::type = 0> explicit MeshIndexData(MeshIndexType type, T&& data) noexcept;
#else #else
explicit MeshIndexData(MeshIndexType type, Containers::ArrayView<const void> data) noexcept; explicit MeshIndexData(MeshIndexType type, Containers::ArrayView<const void> data) noexcept;
#endif #endif
@ -523,7 +523,7 @@ class MAGNUM_TRADE_EXPORT MeshAttributeData {
offset-only constructor (where 0 passed to offset would match with offset-only constructor (where 0 passed to offset would match with
std::nullptr_t). 0 as null pointer constant was deprecated in C++11 std::nullptr_t). 0 as null pointer constant was deprecated in C++11
already, WHY IS THIS STILL A PROBLEM?! */ already, WHY IS THIS STILL A PROBLEM?! */
template<class U, class = typename std::enable_if<std::is_convertible<U, std::nullptr_t>::value && !std::is_convertible<U, std::size_t>::value>::type> explicit MeshAttributeData(MeshAttribute name, VertexFormat format, U, UnsignedShort arraySize = 0, Int morphTargetId = -1) noexcept: MeshAttributeData{nullptr, name, format, nullptr, arraySize, morphTargetId} {} template<class U, typename std::enable_if<std::is_convertible<U, std::nullptr_t>::value && !std::is_convertible<U, std::size_t>::value, int>::type = 0> explicit MeshAttributeData(MeshAttribute name, VertexFormat format, U, UnsignedShort arraySize = 0, Int morphTargetId = -1) noexcept: MeshAttributeData{nullptr, name, format, nullptr, arraySize, morphTargetId} {}
#endif #endif
/** /**
@ -1770,7 +1770,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
* @ref isVertexFormatImplementationSpecific(), * @ref isVertexFormatImplementationSpecific(),
* @ref attributeArraySize() * @ref attributeArraySize()
*/ */
template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<const T> attribute(UnsignedInt id) const; template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<!std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView1D<const T> attribute(UnsignedInt id) const;
/** /**
* @brief Data for given array attribute in a concrete type * @brief Data for given array attribute in a concrete type
@ -1782,7 +1786,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
* @ref attributeArraySize() for given attribute. For non-array * @ref attributeArraySize() for given attribute. For non-array
* attributes the second dimension has a size of @cpp 1 @ce. * attributes the second dimension has a size of @cpp 1 @ce.
*/ */
template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> attribute(UnsignedInt id) const; template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> attribute(UnsignedInt id) const;
/** /**
* @brief Mutable data for given attribute in a concrete type * @brief Mutable data for given attribute in a concrete type
@ -1791,7 +1799,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
* Expects that the mesh is mutable. * Expects that the mesh is mutable.
* @see @ref vertexDataFlags() * @see @ref vertexDataFlags()
*/ */
template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<T> mutableAttribute(UnsignedInt id); template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<!std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView1D<T> mutableAttribute(UnsignedInt id);
/** /**
* @brief Mutable data for given array attribute in a concrete type * @brief Mutable data for given array attribute in a concrete type
@ -1803,7 +1815,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
* @ref attributeArraySize() for given attribute. For non-array * @ref attributeArraySize() for given attribute. For non-array
* attributes the second dimension has a size of @cpp 1 @ce. * attributes the second dimension has a size of @cpp 1 @ce.
*/ */
template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableAttribute(UnsignedInt id); template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableAttribute(UnsignedInt id);
/** /**
* @brief Data for given named attribute * @brief Data for given named attribute
@ -1853,7 +1869,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
* @ref mutableAttribute(MeshAttribute, UnsignedInt, Int), * @ref mutableAttribute(MeshAttribute, UnsignedInt, Int),
* @ref isVertexFormatImplementationSpecific() * @ref isVertexFormatImplementationSpecific()
*/ */
template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<const T> attribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1) const; template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<!std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView1D<const T> attribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1) const;
/** /**
* @brief Data for given named array attribute in a concrete type * @brief Data for given named array attribute in a concrete type
@ -1865,7 +1885,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
* @ref attributeArraySize() for given attribute. For non-array * @ref attributeArraySize() for given attribute. For non-array
* attributes the second dimension has a size of @cpp 1 @ce. * attributes the second dimension has a size of @cpp 1 @ce.
*/ */
template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> attribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1) const; template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> attribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1) const;
/** /**
* @brief Mutable data for given named attribute in a concrete type * @brief Mutable data for given named attribute in a concrete type
@ -1874,7 +1898,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
* returns a mutable view. Expects that the mesh is mutable. * returns a mutable view. Expects that the mesh is mutable.
* @see @ref vertexDataFlags() * @see @ref vertexDataFlags()
*/ */
template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<T> mutableAttribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1); template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<!std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView1D<T> mutableAttribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1);
/** /**
* @brief Mutable data for given named array attribute in a concrete type * @brief Mutable data for given named array attribute in a concrete type
@ -1886,7 +1914,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
* @ref attributeArraySize() for given attribute. For non-array * @ref attributeArraySize() for given attribute. For non-array
* attributes the second dimension has a size of @cpp 1 @ce. * attributes the second dimension has a size of @cpp 1 @ce.
*/ */
template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableAttribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1); template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableAttribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1);
/** /**
* @brief Indices as 32-bit integers * @brief Indices as 32-bit integers
@ -2330,7 +2362,7 @@ namespace Implementation {
} }
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template<class T, class> MeshIndexData::MeshIndexData(const MeshIndexType type, T&& data) noexcept: _type{type} { template<class T, typename std::enable_if<std::is_convertible<T, Containers::ArrayView<const void>>::value, int>::type> MeshIndexData::MeshIndexData(const MeshIndexType type, T&& data) noexcept: _type{type} {
const Containers::ArrayView<const void> erased = data; const Containers::ArrayView<const void> erased = data;
CORRADE_ASSERT(!isMeshIndexTypeImplementationSpecific(type), CORRADE_ASSERT(!isMeshIndexTypeImplementationSpecific(type),
"Trade::MeshIndexData: can't create index data from a contiguous view and an implementation-specific type" << Debug::hex << meshIndexTypeUnwrap(type) << Debug::nospace << ", pass a strided view instead", ); "Trade::MeshIndexData: can't create index data from a contiguous view and an implementation-specific type" << Debug::hex << meshIndexTypeUnwrap(type) << Debug::nospace << ", pass a strided view instead", );
@ -2737,7 +2769,8 @@ template<class T> bool MeshData::checkVertexFormatCompatibility(const MeshAttrib
} }
#endif #endif
template<class T, class> Containers::StridedArrayView1D<const T> MeshData::attribute(const UnsignedInt id) const { #ifndef DOXYGEN_GENERATING_OUTPUT
template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<const T> MeshData::attribute(const UnsignedInt id) const {
Containers::StridedArrayView2D<const char> data = attribute(id); Containers::StridedArrayView2D<const char> data = attribute(id);
#ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */ #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
if(!data.stride()[1]) return {}; if(!data.stride()[1]) return {};
@ -2748,7 +2781,7 @@ template<class T, class> Containers::StridedArrayView1D<const T> MeshData::attri
return Containers::arrayCast<1, const T>(data); return Containers::arrayCast<1, const T>(data);
} }
template<class T, class> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> MeshData::attribute(const UnsignedInt id) const { template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> MeshData::attribute(const UnsignedInt id) const {
Containers::StridedArrayView2D<const char> data = attribute(id); Containers::StridedArrayView2D<const char> data = attribute(id);
#ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */ #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
if(!data.stride()[1]) return {}; if(!data.stride()[1]) return {};
@ -2759,7 +2792,7 @@ template<class T, class> Containers::StridedArrayView2D<const typename std::remo
return Containers::arrayCast<2, const typename std::remove_extent<T>::type>(data); return Containers::arrayCast<2, const typename std::remove_extent<T>::type>(data);
} }
template<class T, class> Containers::StridedArrayView1D<T> MeshData::mutableAttribute(const UnsignedInt id) { template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<T> MeshData::mutableAttribute(const UnsignedInt id) {
Containers::StridedArrayView2D<char> data = mutableAttribute(id); Containers::StridedArrayView2D<char> data = mutableAttribute(id);
#ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */ #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
if(!data.stride()[1]) return {}; if(!data.stride()[1]) return {};
@ -2770,7 +2803,7 @@ template<class T, class> Containers::StridedArrayView1D<T> MeshData::mutableAttr
return Containers::arrayCast<1, T>(data); return Containers::arrayCast<1, T>(data);
} }
template<class T, class> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> MeshData::mutableAttribute(const UnsignedInt id) { template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> MeshData::mutableAttribute(const UnsignedInt id) {
Containers::StridedArrayView2D<char> data = mutableAttribute(id); Containers::StridedArrayView2D<char> data = mutableAttribute(id);
#ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */ #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
if(!data.stride()[1]) return {}; if(!data.stride()[1]) return {};
@ -2781,7 +2814,7 @@ template<class T, class> Containers::StridedArrayView2D<typename std::remove_ext
return Containers::arrayCast<2, typename std::remove_extent<T>::type>(data); return Containers::arrayCast<2, typename std::remove_extent<T>::type>(data);
} }
template<class T, class> Containers::StridedArrayView1D<const T> MeshData::attribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) const { template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<const T> MeshData::attribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) const {
const UnsignedInt attributeId = findAttributeIdInternal(name, id, morphTargetId); const UnsignedInt attributeId = findAttributeIdInternal(name, id, morphTargetId);
#ifndef CORRADE_NO_ASSERT #ifndef CORRADE_NO_ASSERT
if(morphTargetId == -1) CORRADE_ASSERT(attributeId != ~UnsignedInt{}, if(morphTargetId == -1) CORRADE_ASSERT(attributeId != ~UnsignedInt{},
@ -2798,7 +2831,7 @@ template<class T, class> Containers::StridedArrayView1D<const T> MeshData::attri
return Containers::arrayCast<1, const T>(data); return Containers::arrayCast<1, const T>(data);
} }
template<class T, class> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> MeshData::attribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) const { template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> MeshData::attribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) const {
const UnsignedInt attributeId = findAttributeIdInternal(name, id, morphTargetId); const UnsignedInt attributeId = findAttributeIdInternal(name, id, morphTargetId);
#ifndef CORRADE_NO_ASSERT #ifndef CORRADE_NO_ASSERT
if(morphTargetId == -1) CORRADE_ASSERT(attributeId != ~UnsignedInt{}, if(morphTargetId == -1) CORRADE_ASSERT(attributeId != ~UnsignedInt{},
@ -2815,7 +2848,7 @@ template<class T, class> Containers::StridedArrayView2D<const typename std::remo
return Containers::arrayCast<2, const typename std::remove_extent<T>::type>(data); return Containers::arrayCast<2, const typename std::remove_extent<T>::type>(data);
} }
template<class T, class> Containers::StridedArrayView1D<T> MeshData::mutableAttribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) { template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<T> MeshData::mutableAttribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) {
const UnsignedInt attributeId = findAttributeIdInternal(name, id, morphTargetId); const UnsignedInt attributeId = findAttributeIdInternal(name, id, morphTargetId);
#ifndef CORRADE_NO_ASSERT #ifndef CORRADE_NO_ASSERT
if(morphTargetId == -1) CORRADE_ASSERT(attributeId != ~UnsignedInt{}, if(morphTargetId == -1) CORRADE_ASSERT(attributeId != ~UnsignedInt{},
@ -2833,7 +2866,7 @@ template<class T, class> Containers::StridedArrayView1D<T> MeshData::mutableAttr
return Containers::arrayCast<1, T>(data); return Containers::arrayCast<1, T>(data);
} }
template<class T, class> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> MeshData::mutableAttribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) { template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> MeshData::mutableAttribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) {
const UnsignedInt attributeId = findAttributeIdInternal(name, id, morphTargetId); const UnsignedInt attributeId = findAttributeIdInternal(name, id, morphTargetId);
#ifndef CORRADE_NO_ASSERT #ifndef CORRADE_NO_ASSERT
if(morphTargetId == -1) CORRADE_ASSERT(attributeId != ~UnsignedInt{}, if(morphTargetId == -1) CORRADE_ASSERT(attributeId != ~UnsignedInt{},
@ -2850,6 +2883,7 @@ template<class T, class> Containers::StridedArrayView2D<typename std::remove_ext
#endif #endif
return Containers::arrayCast<2, typename std::remove_extent<T>::type>(data); return Containers::arrayCast<2, typename std::remove_extent<T>::type>(data);
} }
#endif
}} }}

66
src/Magnum/Trade/SceneData.h
Unescape View File

@ -2528,7 +2528,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
* @see @ref field(SceneField) const, @ref mutableField(UnsignedInt), * @see @ref field(SceneField) const, @ref mutableField(UnsignedInt),
* @ref fieldArraySize() * @ref fieldArraySize()
*/ */
template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<const T> field(UnsignedInt id) const; template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<!std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView1D<const T> field(UnsignedInt id) const;
/** /**
* @brief Data for given array field in a concrete type * @brief Data for given array field in a concrete type
@ -2541,7 +2545,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
* @ref fieldArraySize(UnsignedInt) const for given field. For * @ref fieldArraySize(UnsignedInt) const for given field. For
* non-array fields the second dimension has a size of @cpp 1 @ce. * non-array fields the second dimension has a size of @cpp 1 @ce.
*/ */
template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> field(UnsignedInt id) const; template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> field(UnsignedInt id) const;
/** /**
* @brief Mutable data for given field in a concrete type * @brief Mutable data for given field in a concrete type
@ -2551,7 +2559,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
* Expects that the scene is mutable. * Expects that the scene is mutable.
* @see @ref dataFlags() * @see @ref dataFlags()
*/ */
template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<T> mutableField(UnsignedInt id); template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<!std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView1D<T> mutableField(UnsignedInt id);
/** /**
* @brief Mutable data for given array field in a concrete type * @brief Mutable data for given array field in a concrete type
@ -2564,7 +2576,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
* @ref fieldArraySize(UnsignedInt) const for given field. For * @ref fieldArraySize(UnsignedInt) const for given field. For
* non-array fields the second dimension has a size of @cpp 1 @ce. * non-array fields the second dimension has a size of @cpp 1 @ce.
*/ */
template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableField(UnsignedInt id); template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableField(UnsignedInt id);
/** /**
* @brief Data for given named field * @brief Data for given named field
@ -2608,7 +2624,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
* @see @ref hasField(), @ref field(UnsignedInt) const, * @see @ref hasField(), @ref field(UnsignedInt) const,
* @ref mutableField(SceneField) * @ref mutableField(SceneField)
*/ */
template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<const T> field(SceneField name) const; template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<!std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView1D<const T> field(SceneField name) const;
/** /**
* @brief Data for given named array field in a concrete type * @brief Data for given named array field in a concrete type
@ -2621,7 +2641,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
* @ref fieldArraySize(SceneField) const for given field. For non-array * @ref fieldArraySize(SceneField) const for given field. For non-array
* fields the second dimension has a size of @cpp 1 @ce. * fields the second dimension has a size of @cpp 1 @ce.
*/ */
template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> field(SceneField name) const; template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> field(SceneField name) const;
/** /**
* @brief Mutable data for given named field * @brief Mutable data for given named field
@ -2631,7 +2655,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
* Expects that the scene is mutable. * Expects that the scene is mutable.
* @see @ref dataFlags() * @see @ref dataFlags()
*/ */
template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<T> mutableField(SceneField name); template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<!std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView1D<T> mutableField(SceneField name);
/** /**
* @brief Mutable data for given named array field in a concrete type * @brief Mutable data for given named array field in a concrete type
@ -2644,7 +2672,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
* @ref fieldArraySize(SceneField) const for given field. For non-array * @ref fieldArraySize(SceneField) const for given field. For non-array
* fields the second dimension has a size of @cpp 1 @ce. * fields the second dimension has a size of @cpp 1 @ce.
*/ */
template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableField(SceneField name); template<class T
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<std::is_array<T>::value, int>::type = 0
#endif
> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableField(SceneField name);
/** /**
* @brief Contents of given bit field * @brief Contents of given bit field
@ -4265,7 +4297,8 @@ template<class T> bool SceneData::checkFieldTypeCompatibility(const SceneFieldDa
} }
#endif #endif
template<class T, class> Containers::StridedArrayView1D<const T> SceneData::field(const UnsignedInt id) const { #ifndef DOXYGEN_GENERATING_OUTPUT
template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<const T> SceneData::field(const UnsignedInt id) const {
Containers::StridedArrayView2D<const char> data = field(id); Containers::StridedArrayView2D<const char> data = field(id);
#ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */ #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
if(!data.stride()[1]) return {}; if(!data.stride()[1]) return {};
@ -4276,7 +4309,7 @@ template<class T, class> Containers::StridedArrayView1D<const T> SceneData::fiel
return Containers::arrayCast<1, const T>(data); return Containers::arrayCast<1, const T>(data);
} }
template<class T, class> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> SceneData::field(const UnsignedInt id) const { template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> SceneData::field(const UnsignedInt id) const {
Containers::StridedArrayView2D<const char> data = field(id); Containers::StridedArrayView2D<const char> data = field(id);
#ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */ #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
if(!data.stride()[1]) return {}; if(!data.stride()[1]) return {};
@ -4287,7 +4320,7 @@ template<class T, class> Containers::StridedArrayView2D<const typename std::remo
return Containers::arrayCast<2, const typename std::remove_extent<T>::type>(data); return Containers::arrayCast<2, const typename std::remove_extent<T>::type>(data);
} }
template<class T, class> Containers::StridedArrayView1D<T> SceneData::mutableField(const UnsignedInt id) { template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<T> SceneData::mutableField(const UnsignedInt id) {
Containers::StridedArrayView2D<char> data = mutableField(id); Containers::StridedArrayView2D<char> data = mutableField(id);
#ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */ #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
if(!data.stride()[1]) return {}; if(!data.stride()[1]) return {};
@ -4298,7 +4331,7 @@ template<class T, class> Containers::StridedArrayView1D<T> SceneData::mutableFie
return Containers::arrayCast<1, T>(data); return Containers::arrayCast<1, T>(data);
} }
template<class T, class> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> SceneData::mutableField(const UnsignedInt id) { template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> SceneData::mutableField(const UnsignedInt id) {
Containers::StridedArrayView2D<char> data = mutableField(id); Containers::StridedArrayView2D<char> data = mutableField(id);
#ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */ #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
if(!data.stride()[1]) return {}; if(!data.stride()[1]) return {};
@ -4309,7 +4342,7 @@ template<class T, class> Containers::StridedArrayView2D<typename std::remove_ext
return Containers::arrayCast<2, typename std::remove_extent<T>::type>(data); return Containers::arrayCast<2, typename std::remove_extent<T>::type>(data);
} }
template<class T, class> Containers::StridedArrayView1D<const T> SceneData::field(const SceneField name) const { template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<const T> SceneData::field(const SceneField name) const {
const UnsignedInt fieldId = findFieldIdInternal(name); const UnsignedInt fieldId = findFieldIdInternal(name);
CORRADE_ASSERT(fieldId != ~UnsignedInt{}, CORRADE_ASSERT(fieldId != ~UnsignedInt{},
"Trade::SceneData::field(): field" << name << "not found", {}); "Trade::SceneData::field(): field" << name << "not found", {});
@ -4323,7 +4356,7 @@ template<class T, class> Containers::StridedArrayView1D<const T> SceneData::fiel
return Containers::arrayCast<1, const T>(data); return Containers::arrayCast<1, const T>(data);
} }
template<class T, class> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> SceneData::field(const SceneField name) const { template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> SceneData::field(const SceneField name) const {
const UnsignedInt fieldId = findFieldIdInternal(name); const UnsignedInt fieldId = findFieldIdInternal(name);
CORRADE_ASSERT(fieldId != ~UnsignedInt{}, CORRADE_ASSERT(fieldId != ~UnsignedInt{},
"Trade::SceneData::field(): field" << name << "not found", {}); "Trade::SceneData::field(): field" << name << "not found", {});
@ -4337,7 +4370,7 @@ template<class T, class> Containers::StridedArrayView2D<const typename std::remo
return Containers::arrayCast<2, const typename std::remove_extent<T>::type>(data); return Containers::arrayCast<2, const typename std::remove_extent<T>::type>(data);
} }
template<class T, class> Containers::StridedArrayView1D<T> SceneData::mutableField(const SceneField name) { template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<T> SceneData::mutableField(const SceneField name) {
const UnsignedInt fieldId = findFieldIdInternal(name); const UnsignedInt fieldId = findFieldIdInternal(name);
CORRADE_ASSERT(fieldId != ~UnsignedInt{}, CORRADE_ASSERT(fieldId != ~UnsignedInt{},
"Trade::SceneData::mutableField(): field" << name << "not found", {}); "Trade::SceneData::mutableField(): field" << name << "not found", {});
@ -4351,7 +4384,7 @@ template<class T, class> Containers::StridedArrayView1D<T> SceneData::mutableFie
return Containers::arrayCast<1, T>(data); return Containers::arrayCast<1, T>(data);
} }
template<class T, class> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> SceneData::mutableField(const SceneField name) { template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> SceneData::mutableField(const SceneField name) {
const UnsignedInt fieldId = findFieldIdInternal(name); const UnsignedInt fieldId = findFieldIdInternal(name);
CORRADE_ASSERT(fieldId != ~UnsignedInt{}, CORRADE_ASSERT(fieldId != ~UnsignedInt{},
"Trade::SceneData::mutableField(): field" << name << "not found", {}); "Trade::SceneData::mutableField(): field" << name << "not found", {});
@ -4364,6 +4397,7 @@ template<class T, class> Containers::StridedArrayView2D<typename std::remove_ext
#endif #endif
return Containers::arrayCast<2, typename std::remove_extent<T>::type>(data); return Containers::arrayCast<2, typename std::remove_extent<T>::type>(data);
} }
#endif
}} }}

12
src/Magnum/Vk/Extensions.h
Unescape View File

@ -214,7 +214,11 @@ class MAGNUM_VK_EXPORT InstanceExtension {
constexpr Containers::StringView string() const { return _string; } constexpr Containers::StringView string() const { return _string; }
/** @brief Construct from a compile-time instance extension */ /** @brief Construct from a compile-time instance extension */
template<class E, class = typename std::enable_if<Implementation::IsInstanceExtension<E>::value>::type> constexpr /*implicit*/ InstanceExtension(const E&): _index{E::InstanceIndex}, _requiredVersion{E::requiredVersion()}, _coreVersion{E::coreVersion()}, _string{E::string()} {} template<class E
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<Implementation::IsInstanceExtension<E>::value, int>::type = 0
#endif
> constexpr /*implicit*/ InstanceExtension(const E&): _index{E::InstanceIndex}, _requiredVersion{E::requiredVersion()}, _coreVersion{E::coreVersion()}, _string{E::string()} {}
private: private:
std::size_t _index; std::size_t _index;
@ -253,7 +257,11 @@ class MAGNUM_VK_EXPORT Extension {
/** @brief Construct from a compile-time device extension */ /** @brief Construct from a compile-time device extension */
/** @todo prohibit conversion from GL/AL extensions also? */ /** @todo prohibit conversion from GL/AL extensions also? */
template<class E, class = typename std::enable_if<Implementation::IsExtension<E>::value>::type> constexpr /*implicit*/ Extension(const E&): _index{E::Index}, _requiredVersion{E::requiredVersion()}, _coreVersion{E::coreVersion()}, _string{E::string()} {} template<class E
#ifndef DOXYGEN_GENERATING_OUTPUT
, typename std::enable_if<Implementation::IsExtension<E>::value, int>::type = 0
#endif
> constexpr /*implicit*/ Extension(const E&): _index{E::Index}, _requiredVersion{E::requiredVersion()}, _coreVersion{E::coreVersion()}, _string{E::string()} {}
private: private:
std::size_t _index; std::size_t _index;

2
src/Magnum/Vk/Implementation/structureHelpers.h
Unescape View File

@ -101,7 +101,7 @@ template<class T> inline const void** structureFind(const void*& next, const T&
class AnyStructure { class AnyStructure {
public: public:
template<class T, class = typename std::enable_if<IsVulkanStructure<T>::value>::type> /*implicit*/ AnyStructure(const T& structure): _structure{reinterpret_cast<const VkBaseOutStructure*>(&structure)} {} template<class T, typename std::enable_if<IsVulkanStructure<T>::value, int>::type = 0> /*implicit*/ AnyStructure(const T& structure): _structure{reinterpret_cast<const VkBaseOutStructure*>(&structure)} {}
/*implicit*/ operator const VkBaseOutStructure&() const { return *_structure; } /*implicit*/ operator const VkBaseOutStructure&() const { return *_structure; }

Write Preview
Loading…
Cancel
Save