From e9b07ef4ce2528b0d3d6b1d15955bea411f72e8b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Sun, 6 Oct 2024 16:42:00 +0200 Subject: [PATCH] GL: clean up instanced data access in *Texture GL tests. This was quite a mess, the whole array name copypasted to each and every access. I mean, yeah, originally I thought this would be *the* usage pattern, but oh god this resulted in SO MANY copypaste errors. Which ultimately means the two annoying NVidia failures in the TextureGLTest related to pixel storage in compressed 3D images are no longer failing as a result of cleanup. --- .../GL/Test/CubeMapTextureArrayGLTest.cpp | 192 ++++--- src/Magnum/GL/Test/CubeMapTextureGLTest.cpp | 364 +++++++------ src/Magnum/GL/Test/RectangleTextureGLTest.cpp | 84 +-- src/Magnum/GL/Test/TextureArrayGLTest.cpp | 284 +++++----- src/Magnum/GL/Test/TextureGLTest.cpp | 508 ++++++++++-------- 5 files changed, 771 insertions(+), 661 deletions(-) diff --git a/src/Magnum/GL/Test/CubeMapTextureArrayGLTest.cpp b/src/Magnum/GL/Test/CubeMapTextureArrayGLTest.cpp index 41c9e7d56..24d2fbf05 100644 --- a/src/Magnum/GL/Test/CubeMapTextureArrayGLTest.cpp +++ b/src/Magnum/GL/Test/CubeMapTextureArrayGLTest.cpp @@ -676,7 +676,8 @@ void CubeMapTextureArrayGLTest::viewOnNonArray() { } void CubeMapTextureArrayGLTest::image() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -688,28 +689,29 @@ void CubeMapTextureArrayGLTest::image() { CubeMapTextureArray texture; texture.setImage(0, TextureFormat::RGBA8, ImageView3D{ - PixelStorageData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, - PixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); /** @todo How to test this on ES? */ #ifndef MAGNUM_TARGET_GLES - Image3D image = texture.image(0, {PixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte}); + Image3D image = texture.image(0, {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlag3D::CubeMap|ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i(2, 2, 6)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } void CubeMapTextureArrayGLTest::imageBuffer() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -721,45 +723,46 @@ void CubeMapTextureArrayGLTest::imageBuffer() { CubeMapTextureArray texture; texture.setImage(0, TextureFormat::RGBA8, BufferImage3D{ - PixelStorageData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, - PixelStorageData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); /** @todo How to test this on ES? */ #ifndef MAGNUM_TARGET_GLES - BufferImage3D image = texture.image(0, {PixelStorageData[testCaseInstanceId()].storage, + BufferImage3D image = texture.image(0, {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector3i(2, 2, 6)); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } #ifndef MAGNUM_TARGET_GLES void CubeMapTextureArrayGLTest::imageQueryView() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported."); CubeMapTextureArray texture; texture.setImage(0, TextureFormat::RGBA8, ImageView3D{ - PixelStorageData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, - PixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorageData[testCaseInstanceId()].offset + 2*2*6*4}; - MutableImageView3D image{PixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, data, ImageFlag3D::Array}; + Containers::Array imageData{data.offset + 2*2*6*4}; + MutableImageView3D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, imageData, ImageFlag3D::Array}; texture.image(0, image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -767,14 +770,15 @@ void CubeMapTextureArrayGLTest::imageQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i(2, 2, 6)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif void CubeMapTextureArrayGLTest::compressedImage() { - setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -792,35 +796,36 @@ void CubeMapTextureArrayGLTest::compressedImage() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif CubeMapTextureArray texture; texture.setCompressedImage(0, CompressedImageView3D{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorageData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, - CompressedPixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); #ifndef MAGNUM_TARGET_GLES - CompressedImage3D image = texture.compressedImage(0, {CompressedPixelStorageData[testCaseInstanceId()].storage}); + CompressedImage3D image = texture.compressedImage(0, {data.storage}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlag3D::CubeMap|ImageFlag3D::Array); CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 6})); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset), - CompressedPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } void CubeMapTextureArrayGLTest::compressedImageBuffer() { - setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -838,59 +843,60 @@ void CubeMapTextureArrayGLTest::compressedImageBuffer() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif CubeMapTextureArray texture; texture.setCompressedImage(0, CompressedBufferImage3D{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorageData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, - CompressedPixelStorageData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); /** @todo How to test this on ES? */ #ifndef MAGNUM_TARGET_GLES - CompressedBufferImage3D image = texture.compressedImage(0, {CompressedPixelStorageData[testCaseInstanceId()].storage}, BufferUsage::StaticRead); + CompressedBufferImage3D image = texture.compressedImage(0, {data.storage}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 6})); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset), - CompressedPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } #ifndef MAGNUM_TARGET_GLES void CubeMapTextureArrayGLTest::compressedImageQueryView() { - setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); CubeMapTextureArray texture; texture.setCompressedImage(0, CompressedImageView3D{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorageData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, - CompressedPixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{CompressedPixelStorageData[testCaseInstanceId()].offset + 6*16}; - MutableCompressedImageView3D image{CompressedPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, data, ImageFlag3D::Array}; + Containers::Array imageData{data.offset + 6*16}; + MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, imageData, ImageFlag3D::Array}; texture.compressedImage(0, image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -898,8 +904,8 @@ void CubeMapTextureArrayGLTest::compressedImageQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 6})); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset), - CompressedPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif @@ -940,7 +946,8 @@ constexpr UnsignedByte SubDataComplete[]{ #endif void CubeMapTextureArrayGLTest::subImage() { - setTestCaseDescription(SubPixelStorageData[testCaseInstanceId()].name); + auto&& data = SubPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -954,9 +961,9 @@ void CubeMapTextureArrayGLTest::subImage() { texture.setImage(0, TextureFormat::RGBA8, ImageView3D(PixelFormat::RGBA, PixelType::UnsignedByte, {4, 4, 6}, Zero)); texture.setSubImage(0, Vector3i(1), ImageView3D{ - SubPixelStorageData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 4}, - SubPixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -973,7 +980,8 @@ void CubeMapTextureArrayGLTest::subImage() { } void CubeMapTextureArrayGLTest::subImageBuffer() { - setTestCaseDescription(SubPixelStorageData[testCaseInstanceId()].name); + auto&& data = SubPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -987,9 +995,9 @@ void CubeMapTextureArrayGLTest::subImageBuffer() { texture.setImage(0, TextureFormat::RGBA8, ImageView3D(PixelFormat::RGBA, PixelType::UnsignedByte, {4, 4, 6}, Zero)); texture.setSubImage(0, Vector3i(1), BufferImage3D{ - SubPixelStorageData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 4}, - SubPixelStorageData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1010,7 +1018,8 @@ void CubeMapTextureArrayGLTest::subImageBuffer() { #ifndef MAGNUM_TARGET_GLES void CubeMapTextureArrayGLTest::subImageQuery() { - setTestCaseDescription(SubPixelStorageData[testCaseInstanceId()].name); + auto&& data = SubPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported."); @@ -1024,20 +1033,21 @@ void CubeMapTextureArrayGLTest::subImageQuery() { MAGNUM_VERIFY_NO_GL_ERROR(); Image3D image = texture.subImage(0, Range3Di::fromSize(Vector3i{1}, {2, 2, 4}), - {SubPixelStorageData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i(2, 2, 4)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(SubPixelStorageData[testCaseInstanceId()].offset), - SubPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void CubeMapTextureArrayGLTest::subImageQueryView() { - setTestCaseDescription(SubPixelStorageData[testCaseInstanceId()].name); + auto&& data = SubPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported."); @@ -1050,8 +1060,8 @@ void CubeMapTextureArrayGLTest::subImageQueryView() { MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{SubPixelStorageData[testCaseInstanceId()].offset + 2*2*4*4}; - MutableImageView3D image{PixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 4}, data, ImageFlag3D::Array}; + Containers::Array imageData{data.offset + 2*2*4*4}; + MutableImageView3D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 4}, imageData, ImageFlag3D::Array}; texture.subImage(0, Range3Di::fromSize(Vector3i{1}, {2, 2, 4}), image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1059,13 +1069,14 @@ void CubeMapTextureArrayGLTest::subImageQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i(2, 2, 4)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(SubPixelStorageData[testCaseInstanceId()].offset), - SubPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void CubeMapTextureArrayGLTest::subImageQueryBuffer() { - setTestCaseDescription(SubPixelStorageData[testCaseInstanceId()].name); + auto&& data = SubPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported."); @@ -1079,15 +1090,15 @@ void CubeMapTextureArrayGLTest::subImageQueryBuffer() { MAGNUM_VERIFY_NO_GL_ERROR(); BufferImage3D image = texture.subImage(0, Range3Di::fromSize(Vector3i{1}, {2, 2, 4}), - {SubPixelStorageData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector3i(2, 2, 4)); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(SubPixelStorageData[testCaseInstanceId()].offset), - SubPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif @@ -1159,7 +1170,8 @@ constexpr UnsignedByte CompressedSubDataComplete[] = { #endif void CubeMapTextureArrayGLTest::compressedSubImage() { - setTestCaseDescription(CompressedSubPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedSubPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1177,7 +1189,7 @@ void CubeMapTextureArrayGLTest::compressedSubImage() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif @@ -1186,10 +1198,10 @@ void CubeMapTextureArrayGLTest::compressedSubImage() { {12, 12, 6}, CompressedZero}); texture.setCompressedSubImage(0, {4, 4, 1}, CompressedImageView3D{ #ifndef MAGNUM_TARGET_GLES - CompressedSubPixelStorageData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, Vector3i{4}, - CompressedSubPixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1201,7 +1213,7 @@ void CubeMapTextureArrayGLTest::compressedSubImage() { CORRADE_COMPARE(image.size(), (Vector3i{12, 12, 6})); { - CORRADE_EXPECT_FAIL_IF(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), + CORRADE_EXPECT_FAIL_IF(data.storage != CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), "Non-default compressed pixel storage for cube map textures behaves weirdly on NVidia for client-memory images"); CORRADE_COMPARE_AS(Containers::arrayCast(image.data()), @@ -1212,7 +1224,8 @@ void CubeMapTextureArrayGLTest::compressedSubImage() { } void CubeMapTextureArrayGLTest::compressedSubImageBuffer() { - setTestCaseDescription(CompressedSubPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedSubPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1230,7 +1243,7 @@ void CubeMapTextureArrayGLTest::compressedSubImageBuffer() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif @@ -1239,10 +1252,10 @@ void CubeMapTextureArrayGLTest::compressedSubImageBuffer() { {12, 12, 6}, CompressedZero}); texture.setCompressedSubImage(0, {4, 4, 1}, CompressedBufferImage3D{ #ifndef MAGNUM_TARGET_GLES - CompressedSubPixelStorageData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, Vector3i{4}, - CompressedSubPixelStorageData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1262,7 +1275,8 @@ void CubeMapTextureArrayGLTest::compressedSubImageBuffer() { #ifndef MAGNUM_TARGET_GLES void CubeMapTextureArrayGLTest::compressedSubImageQuery() { - setTestCaseDescription(CompressedSubPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedSubPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported."); @@ -1270,9 +1284,9 @@ void CubeMapTextureArrayGLTest::compressedSubImageQuery() { CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedSubPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedSubPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); CubeMapTextureArray texture; @@ -1281,19 +1295,20 @@ void CubeMapTextureArrayGLTest::compressedSubImageQuery() { MAGNUM_VERIFY_NO_GL_ERROR(); - CompressedImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 1}, Vector3i{4}), {CompressedSubPixelStorageData[testCaseInstanceId()].storage}); + CompressedImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 1}, Vector3i{4}), {data.storage}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i{4}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedSubPixelStorageData[testCaseInstanceId()].offset), - CompressedSubPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void CubeMapTextureArrayGLTest::compressedSubImageQueryView() { - setTestCaseDescription(CompressedSubPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedSubPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported."); @@ -1301,9 +1316,9 @@ void CubeMapTextureArrayGLTest::compressedSubImageQueryView() { CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedSubPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedSubPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); CubeMapTextureArray texture; @@ -1312,8 +1327,8 @@ void CubeMapTextureArrayGLTest::compressedSubImageQueryView() { MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{CompressedSubPixelStorageData[testCaseInstanceId()].offset + 4*16}; - MutableCompressedImageView3D image{CompressedPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 4}, data, ImageFlag3D::Array}; + Containers::Array imageData{data.offset + 4*16}; + MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 4}, imageData, ImageFlag3D::Array}; texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 1}, Vector3i{4}), image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1321,13 +1336,14 @@ void CubeMapTextureArrayGLTest::compressedSubImageQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i{4}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedSubPixelStorageData[testCaseInstanceId()].offset), - CompressedSubPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void CubeMapTextureArrayGLTest::compressedSubImageQueryBuffer() { - setTestCaseDescription(CompressedSubPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedSubPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported."); @@ -1335,9 +1351,9 @@ void CubeMapTextureArrayGLTest::compressedSubImageQueryBuffer() { CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedSubPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedSubPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); CubeMapTextureArray texture; @@ -1346,14 +1362,14 @@ void CubeMapTextureArrayGLTest::compressedSubImageQueryBuffer() { MAGNUM_VERIFY_NO_GL_ERROR(); - CompressedBufferImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 1}, Vector3i{4}), {CompressedSubPixelStorageData[testCaseInstanceId()].storage}, BufferUsage::StaticRead); + CompressedBufferImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 1}, Vector3i{4}), {data.storage}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector3i{4}); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(CompressedSubPixelStorageData[testCaseInstanceId()].offset), - CompressedSubPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif diff --git a/src/Magnum/GL/Test/CubeMapTextureGLTest.cpp b/src/Magnum/GL/Test/CubeMapTextureGLTest.cpp index 608643b65..3fe7baf18 100644 --- a/src/Magnum/GL/Test/CubeMapTextureGLTest.cpp +++ b/src/Magnum/GL/Test/CubeMapTextureGLTest.cpp @@ -812,14 +812,15 @@ void CubeMapTextureGLTest::viewOnArray() { #endif void CubeMapTextureGLTest::storage() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifdef MAGNUM_TARGET_GLES2 #ifndef MAGNUM_TARGET_WEBGL - if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported."); #else - if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{}) + if(data.storage != PixelStorage{}) CORRADE_SKIP("Image unpack is not supported in WebGL 1."); #endif #endif @@ -832,19 +833,19 @@ void CubeMapTextureGLTest::storage() { TextureFormat::RGBA, #endif Vector2i(2)); - texture.setSubImage(CubeMapCoordinate::PositiveX, 0, {}, ImageView2D{PixelStorageData[testCaseInstanceId()].storage, + texture.setSubImage(CubeMapCoordinate::PositiveX, 0, {}, ImageView2D{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); texture.setSubImage(CubeMapCoordinate::NegativeX, 0, {}, ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), Zero}); - texture.setSubImage(CubeMapCoordinate::PositiveY, 0, {}, ImageView2D{PixelStorageData[testCaseInstanceId()].storage, + texture.setSubImage(CubeMapCoordinate::PositiveY, 0, {}, ImageView2D{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); texture.setSubImage(CubeMapCoordinate::NegativeY, 0, {}, ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), Zero}); - texture.setSubImage(CubeMapCoordinate::PositiveZ, 0, {}, ImageView2D{PixelStorageData[testCaseInstanceId()].storage, + texture.setSubImage(CubeMapCoordinate::PositiveZ, 0, {}, ImageView2D{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); texture.setSubImage(CubeMapCoordinate::NegativeZ, 0, {}, ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), Zero}); @@ -854,50 +855,51 @@ void CubeMapTextureGLTest::storage() { #ifndef MAGNUM_TARGET_GLES { Image2D image = texture.image(CubeMapCoordinate::PositiveX, 0, - {PixelStorageData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } { Image2D image = texture.image(CubeMapCoordinate::PositiveY, 0, - {PixelStorageData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } { Image2D image = texture.image(CubeMapCoordinate::PositiveZ, 0, - {PixelStorageData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif } void CubeMapTextureGLTest::image() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifdef MAGNUM_TARGET_GLES2 #ifndef MAGNUM_TARGET_WEBGL - if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported."); #else - if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{}) + if(data.storage != PixelStorage{}) CORRADE_SKIP("Image unpack is not supported in WebGL 1."); #endif #endif @@ -909,19 +911,19 @@ void CubeMapTextureGLTest::image() { #endif CubeMapTexture texture; - texture.setImage(CubeMapCoordinate::PositiveX, 0, format, ImageView2D{PixelStorageData[testCaseInstanceId()].storage, + texture.setImage(CubeMapCoordinate::PositiveX, 0, format, ImageView2D{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); texture.setImage(CubeMapCoordinate::NegativeX, 0, format, ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), Zero}); - texture.setImage(CubeMapCoordinate::PositiveY, 0, format, ImageView2D{PixelStorageData[testCaseInstanceId()].storage, + texture.setImage(CubeMapCoordinate::PositiveY, 0, format, ImageView2D{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); texture.setImage(CubeMapCoordinate::NegativeY, 0, format, ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), Zero}); - texture.setImage(CubeMapCoordinate::PositiveZ, 0, format, ImageView2D{PixelStorageData[testCaseInstanceId()].storage, + texture.setImage(CubeMapCoordinate::PositiveZ, 0, format, ImageView2D{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); texture.setImage(CubeMapCoordinate::NegativeZ, 0, format, ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), Zero}); @@ -931,39 +933,39 @@ void CubeMapTextureGLTest::image() { #ifndef MAGNUM_TARGET_GLES { Image2D image = texture.image(CubeMapCoordinate::PositiveX, 0, - {PixelStorageData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlags2D{}); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } { Image2D image = texture.image(CubeMapCoordinate::PositiveY, 0, - {PixelStorageData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlags2D{}); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } { Image2D image = texture.image(CubeMapCoordinate::PositiveZ, 0, - {PixelStorageData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlags2D{}); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif @@ -971,13 +973,14 @@ void CubeMapTextureGLTest::image() { #ifndef MAGNUM_TARGET_GLES2 void CubeMapTextureGLTest::imageBuffer() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); CubeMapTexture texture; texture.setImage(CubeMapCoordinate::PositiveX, 0, TextureFormat::RGBA8, - BufferImage2D{PixelStorageData[testCaseInstanceId()].storage, + BufferImage2D{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); texture.setImage(CubeMapCoordinate::NegativeX, 0, TextureFormat::RGBA8, ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), Zero}); @@ -995,14 +998,14 @@ void CubeMapTextureGLTest::imageBuffer() { /** @todo How to test this on ES? */ #ifndef MAGNUM_TARGET_GLES BufferImage2D image = texture.image(CubeMapCoordinate::PositiveX, 0, - {PixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } @@ -1010,20 +1013,21 @@ void CubeMapTextureGLTest::imageBuffer() { #ifndef MAGNUM_TARGET_GLES void CubeMapTextureGLTest::imageQueryView() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); CubeMapTexture texture; texture.setStorage(1, TextureFormat::RGBA8, Vector2i{2}) .setSubImage(CubeMapCoordinate::PositiveY, 0, {}, - ImageView2D{PixelStorageData[testCaseInstanceId()].storage, + ImageView2D{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorageData[testCaseInstanceId()].offset + 2*2*4}; - MutableImageView2D image{PixelStorageData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array}; + Containers::Array imageData{data.offset + 2*2*4}; + MutableImageView2D image{data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array}; texture.image(CubeMapCoordinate::PositiveY, 0, image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1031,8 +1035,8 @@ void CubeMapTextureGLTest::imageQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag2D::Array); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } @@ -1082,14 +1086,15 @@ constexpr UnsignedByte SubDataComplete[]{ #endif void CubeMapTextureGLTest::subImage() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifdef MAGNUM_TARGET_GLES2 #ifndef MAGNUM_TARGET_WEBGL - if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported."); #else - if(PixelStorageData[testCaseInstanceId()].storage != PixelStorage{}) + if(data.storage != PixelStorage{}) CORRADE_SKIP("Image unpack is not supported in WebGL 1."); #endif #endif @@ -1114,9 +1119,9 @@ void CubeMapTextureGLTest::subImage() { texture.setImage(CubeMapCoordinate::NegativeZ, 0, format, ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero)); texture.setSubImage(CubeMapCoordinate::PositiveX, 0, Vector2i(1), ImageView2D{ - PixelStorageData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1134,7 +1139,8 @@ void CubeMapTextureGLTest::subImage() { #ifndef MAGNUM_TARGET_GLES2 void CubeMapTextureGLTest::subImageBuffer() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); CubeMapTexture texture; texture.setImage(CubeMapCoordinate::PositiveX, 0, TextureFormat::RGBA8, @@ -1150,9 +1156,9 @@ void CubeMapTextureGLTest::subImageBuffer() { texture.setImage(CubeMapCoordinate::NegativeZ, 0, TextureFormat::RGBA8, ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero)); texture.setSubImage(CubeMapCoordinate::PositiveX, 0, Vector2i(1), BufferImage2D{ - PixelStorageData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1174,7 +1180,8 @@ void CubeMapTextureGLTest::subImageBuffer() { #ifndef MAGNUM_TARGET_GLES void CubeMapTextureGLTest::subImageQuery() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); @@ -1186,20 +1193,21 @@ void CubeMapTextureGLTest::subImageQuery() { MAGNUM_VERIFY_NO_GL_ERROR(); Image3D image = texture.subImage(0, Range3Di::fromSize({1, 1, 0}, {2, 2, 1}), - {PixelStorageData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i(2, 2, 1)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void CubeMapTextureGLTest::subImageQueryView() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); @@ -1210,9 +1218,9 @@ void CubeMapTextureGLTest::subImageQueryView() { MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorageData[testCaseInstanceId()].offset + 2*2*4}; - MutableImageView3D image{PixelStorageData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 1}, data, ImageFlag3D::Array}; + Containers::Array imageData{data.offset + 2*2*4}; + MutableImageView3D image{data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 1}, imageData, ImageFlag3D::Array}; texture.subImage(0, Range3Di::fromSize({1, 1, 0}, {2, 2, 1}), image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1220,13 +1228,14 @@ void CubeMapTextureGLTest::subImageQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i(2, 2, 1)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void CubeMapTextureGLTest::subImageQueryBuffer() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); @@ -1238,21 +1247,22 @@ void CubeMapTextureGLTest::subImageQueryBuffer() { MAGNUM_VERIFY_NO_GL_ERROR(); BufferImage3D image = texture.subImage(0, Range3Di::fromSize({1, 1, 0}, {2, 2, 1}), - {PixelStorageData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector3i(2, 2, 1)); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif void CubeMapTextureGLTest::compressedImage() { - setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1266,16 +1276,16 @@ void CubeMapTextureGLTest::compressedImage() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif const CompressedImageView2D view{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorageData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, - CompressedPixelStorageData[testCaseInstanceId()].dataSparse}; + data.dataSparse}; CubeMapTexture texture; texture.setCompressedImage(CubeMapCoordinate::PositiveX, 0, view) @@ -1288,21 +1298,22 @@ void CubeMapTextureGLTest::compressedImage() { MAGNUM_VERIFY_NO_GL_ERROR(); #ifndef MAGNUM_TARGET_GLES - CompressedImage2D image = texture.compressedImage(CubeMapCoordinate::PositiveX, 0, {CompressedPixelStorageData[testCaseInstanceId()].storage}); + CompressedImage2D image = texture.compressedImage(CubeMapCoordinate::PositiveX, 0, {data.storage}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlags2D{}); CORRADE_COMPARE(image.size(), Vector2i{4}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset), - CompressedPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } #ifndef MAGNUM_TARGET_GLES2 void CubeMapTextureGLTest::compressedImageBuffer() { - setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1316,16 +1327,16 @@ void CubeMapTextureGLTest::compressedImageBuffer() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif CompressedBufferImage2D buffer{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorageData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, - CompressedPixelStorageData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}; CubeMapTexture texture; @@ -1340,14 +1351,14 @@ void CubeMapTextureGLTest::compressedImageBuffer() { #ifndef MAGNUM_TARGET_GLES CompressedBufferImage2D image = texture.compressedImage(CubeMapCoordinate::PositiveX, 0, - {CompressedPixelStorageData[testCaseInstanceId()].storage}, BufferUsage::StaticRead); + {data.storage}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector2i{4}); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset), - CompressedPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } @@ -1355,18 +1366,19 @@ void CubeMapTextureGLTest::compressedImageBuffer() { #ifndef MAGNUM_TARGET_GLES void CubeMapTextureGLTest::compressedImageQueryView() { - setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); const CompressedImageView2D view{ - CompressedPixelStorageData[testCaseInstanceId()].storage, + data.storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, - CompressedPixelStorageData[testCaseInstanceId()].dataSparse}; + data.dataSparse}; CubeMapTexture texture; texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4}) @@ -1374,8 +1386,8 @@ void CubeMapTextureGLTest::compressedImageQueryView() { MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{CompressedPixelStorageData[testCaseInstanceId()].offset + 16}; - MutableCompressedImageView2D image{CompressedPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, data, ImageFlag2D::Array}; + Containers::Array imageData{data.offset + 16}; + MutableCompressedImageView2D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, imageData, ImageFlag2D::Array}; texture.compressedImage(CubeMapCoordinate::PositiveZ, 0, image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1383,8 +1395,8 @@ void CubeMapTextureGLTest::compressedImageQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag2D::Array); CORRADE_COMPARE(image.size(), Vector2i{4}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset), - CompressedPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } @@ -1470,7 +1482,8 @@ void CubeMapTextureGLTest::compressedImageQueryViewBadFormat() { #if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL)) void CubeMapTextureGLTest::immutableCompressedImage() { - setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1491,7 +1504,7 @@ void CubeMapTextureGLTest::immutableCompressedImage() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif @@ -1504,10 +1517,10 @@ void CubeMapTextureGLTest::immutableCompressedImage() { const CompressedImageView2D view{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorageData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, - CompressedPixelStorageData[testCaseInstanceId()].dataSparse}; + data.dataSparse}; CubeMapTexture texture; texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4}) @@ -1521,13 +1534,13 @@ void CubeMapTextureGLTest::immutableCompressedImage() { MAGNUM_VERIFY_NO_GL_ERROR(); #ifndef MAGNUM_TARGET_GLES - CompressedImage2D image = texture.compressedImage(CubeMapCoordinate::NegativeY, 0, {CompressedPixelStorageData[testCaseInstanceId()].storage}); + CompressedImage2D image = texture.compressedImage(CubeMapCoordinate::NegativeY, 0, {data.storage}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector2i{4}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset), - CompressedPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } @@ -1563,7 +1576,8 @@ constexpr UnsignedByte CompressedSubDataComplete[]{ #endif void CubeMapTextureGLTest::compressedSubImage() { - setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1577,7 +1591,7 @@ void CubeMapTextureGLTest::compressedSubImage() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif @@ -1596,10 +1610,10 @@ void CubeMapTextureGLTest::compressedSubImage() { CompressedImageView2D{CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{12}, CompressedZero}); texture.setCompressedSubImage(CubeMapCoordinate::PositiveX, 0, Vector2i{4}, CompressedImageView2D{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorageData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, - CompressedPixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1611,7 +1625,7 @@ void CubeMapTextureGLTest::compressedSubImage() { CORRADE_COMPARE(image.size(), Vector2i{12}); { - CORRADE_EXPECT_FAIL_IF(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && Context::current().isExtensionSupported() && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), + CORRADE_EXPECT_FAIL_IF(data.storage != CompressedPixelStorage{} && Context::current().isExtensionSupported() && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), "Non-default compressed pixel storage for cube map textures behaves weirdly on NVidia for client-memory images when using ARB_direct_state_access"); CORRADE_COMPARE_AS(Containers::arrayCast(image.data()), @@ -1623,7 +1637,8 @@ void CubeMapTextureGLTest::compressedSubImage() { #ifndef MAGNUM_TARGET_GLES2 void CubeMapTextureGLTest::compressedSubImageBuffer() { - setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1637,7 +1652,7 @@ void CubeMapTextureGLTest::compressedSubImageBuffer() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif @@ -1656,10 +1671,10 @@ void CubeMapTextureGLTest::compressedSubImageBuffer() { CompressedImageView2D{CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{12}, CompressedZero}); texture.setCompressedSubImage(CubeMapCoordinate::PositiveX, 0, Vector2i{4}, CompressedBufferImage2D{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorageData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, - CompressedPixelStorageData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1681,15 +1696,16 @@ void CubeMapTextureGLTest::compressedSubImageBuffer() { #ifndef MAGNUM_TARGET_GLES void CubeMapTextureGLTest::compressedSubImageQuery() { - setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); CubeMapTexture texture; @@ -1698,26 +1714,27 @@ void CubeMapTextureGLTest::compressedSubImageQuery() { MAGNUM_VERIFY_NO_GL_ERROR(); - CompressedImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 0}, {4, 4, 1}), {CompressedPixelStorageData[testCaseInstanceId()].storage}); + CompressedImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 0}, {4, 4, 1}), {data.storage}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 1})); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset), - CompressedPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void CubeMapTextureGLTest::compressedSubImageQueryView() { - setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); CubeMapTexture texture; @@ -1726,8 +1743,8 @@ void CubeMapTextureGLTest::compressedSubImageQueryView() { MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{CompressedPixelStorageData[testCaseInstanceId()].offset + 16}; - MutableCompressedImageView3D image{CompressedPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 1}, data, ImageFlag3D::Array}; + Containers::Array imageData{data.offset + 16}; + MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 1}, imageData, ImageFlag3D::Array}; texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 0}, {4, 4, 1}), image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1735,8 +1752,8 @@ void CubeMapTextureGLTest::compressedSubImageQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 1})); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset), - CompressedPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } @@ -1820,15 +1837,16 @@ void CubeMapTextureGLTest::compressedSubImageQueryViewBadFormat() { } void CubeMapTextureGLTest::compressedSubImageQueryBuffer() { - setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); CubeMapTexture texture; @@ -1837,21 +1855,22 @@ void CubeMapTextureGLTest::compressedSubImageQueryBuffer() { MAGNUM_VERIFY_NO_GL_ERROR(); - CompressedBufferImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 0}, {4, 4, 1}), {CompressedPixelStorageData[testCaseInstanceId()].storage}, BufferUsage::StaticRead); + CompressedBufferImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 0}, {4, 4, 1}), {data.storage}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 1})); CORRADE_COMPARE_AS( - Containers::arrayCast(imageData).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset), - CompressedPixelStorageData[testCaseInstanceId()].data, + Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif void CubeMapTextureGLTest::image3D() { - setTestCaseDescription(FullPixelStorageData[testCaseInstanceId()].name); + auto&& data = FullPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL)) constexpr TextureFormat format = TextureFormat::RGBA8; @@ -1863,23 +1882,23 @@ void CubeMapTextureGLTest::image3D() { texture.setStorage(1, format, Vector2i{2, 2}) .setSubImage(0, {}, ImageView3D{ PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, - FullPixelStorageData[testCaseInstanceId()].data}); + data.data}); MAGNUM_VERIFY_NO_GL_ERROR(); #ifndef MAGNUM_TARGET_GLES Image3D image = texture.image(0, - {FullPixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte}); + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlag3D::CubeMap); CORRADE_COMPARE(image.size(), Vector3i(2, 2, 6)); { - CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && FullPixelStorageData[testCaseInstanceId()].storage != PixelStorage{}, + CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != PixelStorage{}, "Mesa drivers can't handle non-default pixel storage for full cubemap image queries."); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(FullPixelStorageData[testCaseInstanceId()].offset), - FullPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif @@ -1887,20 +1906,21 @@ void CubeMapTextureGLTest::image3D() { #ifndef MAGNUM_TARGET_GLES2 void CubeMapTextureGLTest::image3DBuffer() { - setTestCaseDescription(FullPixelStorageData[testCaseInstanceId()].name); + auto&& data = FullPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); CubeMapTexture texture; texture.setStorage(1, TextureFormat::RGBA8, Vector2i{2}) .setSubImage(0, {}, BufferImage3D{ PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, - FullPixelStorageData[testCaseInstanceId()].data, + data.data, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); #ifndef MAGNUM_TARGET_GLES BufferImage3D image = texture.image(0, - {FullPixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1908,10 +1928,10 @@ void CubeMapTextureGLTest::image3DBuffer() { CORRADE_COMPARE(image.size(), Vector3i(2, 2, 6)); const auto imageData = image.buffer().data(); { - CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && FullPixelStorageData[testCaseInstanceId()].storage != PixelStorage{}, + CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != PixelStorage{}, "Mesa drivers can't handle non-default pixel storage for full cubemap image queries."); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(FullPixelStorageData[testCaseInstanceId()].offset), - FullPixelStorageData[testCaseInstanceId()].data, TestSuite::Compare::Container); + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif } @@ -1919,18 +1939,19 @@ void CubeMapTextureGLTest::image3DBuffer() { #ifndef MAGNUM_TARGET_GLES void CubeMapTextureGLTest::image3DQueryView() { - setTestCaseDescription(FullPixelStorageData[testCaseInstanceId()].name); + auto&& data = FullPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); CubeMapTexture texture; texture.setStorage(1, TextureFormat::RGBA8, Vector2i{2, 2}) .setSubImage(0, {}, ImageView3D{ PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, - FullPixelStorageData[testCaseInstanceId()].data}); + data.data}); MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{FullPixelStorageData[testCaseInstanceId()].offset + 2*2*6*4}; - MutableImageView3D image{FullPixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, data, ImageFlag3D::Array}; + Containers::Array imageData{data.offset + 2*2*6*4}; + MutableImageView3D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, imageData, ImageFlag3D::Array}; texture.image(0, image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1939,10 +1960,10 @@ void CubeMapTextureGLTest::image3DQueryView() { CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i(2, 2, 6)); { - CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && FullPixelStorageData[testCaseInstanceId()].storage != PixelStorage{}, + CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != PixelStorage{}, "Mesa drivers can't handle non-default pixel storage for full cubemap image queries."); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(FullPixelStorageData[testCaseInstanceId()].offset), - FullPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } } @@ -1985,20 +2006,21 @@ void CubeMapTextureGLTest::image3DQueryViewBadSize() { #ifndef MAGNUM_TARGET_GLES void CubeMapTextureGLTest::compressedImage3D() { - setTestCaseDescription(CompressedFullPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedFullPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::direct_state_access::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); CubeMapTexture texture; texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4}) .setCompressedSubImage(0, {}, CompressedImageView3D{ CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, - CompressedFullPixelStorageData[testCaseInstanceId()].data}); + data.data}); { bool fails(Context::current().detectedDriver() & Context::DetectedDriver::Amd); @@ -2009,7 +2031,7 @@ void CubeMapTextureGLTest::compressedImage3D() { if(fails) CORRADE_SKIP("Skipping the rest of the test"); } - CompressedImage3D image = texture.compressedImage(0, {CompressedFullPixelStorageData[testCaseInstanceId()].storage}); + CompressedImage3D image = texture.compressedImage(0, {data.storage}); { #ifdef CORRADE_TARGET_WINDOWS @@ -2027,29 +2049,30 @@ void CubeMapTextureGLTest::compressedImage3D() { CORRADE_COMPARE(image.flags(), ImageFlag3D::CubeMap); CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 6})); { - CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && CompressedFullPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{}, + CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != CompressedPixelStorage{}, "Mesa drivers can't handle non-default pixel storage for full cubemap image queries."); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedFullPixelStorageData[testCaseInstanceId()].offset), - CompressedFullPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } } void CubeMapTextureGLTest::compressedImage3DBuffer() { - setTestCaseDescription(CompressedFullPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedFullPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::direct_state_access::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); CubeMapTexture texture; texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4}) .setCompressedSubImage(0, {}, CompressedBufferImage3D{ CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, - CompressedFullPixelStorageData[testCaseInstanceId()].data, + data.data, BufferUsage::StaticDraw}); { @@ -2061,7 +2084,7 @@ void CubeMapTextureGLTest::compressedImage3DBuffer() { if(fails) CORRADE_SKIP("Skipping the rest of the test"); } - CompressedBufferImage3D image = texture.compressedImage(0, {CompressedFullPixelStorageData[testCaseInstanceId()].storage}, BufferUsage::StaticRead); + CompressedBufferImage3D image = texture.compressedImage(0, {data.storage}, BufferUsage::StaticRead); { #ifdef CORRADE_TARGET_WINDOWS @@ -2079,29 +2102,30 @@ void CubeMapTextureGLTest::compressedImage3DBuffer() { CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 6})); const auto imageData = image.buffer().data(); { - CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && CompressedFullPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{}, + CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != CompressedPixelStorage{}, "Mesa drivers can't handle non-default pixel storage for full cubemap image queries."); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(CompressedFullPixelStorageData[testCaseInstanceId()].offset), - CompressedFullPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } } void CubeMapTextureGLTest::compressedImage3DQueryView() { - setTestCaseDescription(CompressedFullPixelStorageData[testCaseInstanceId()].name); + auto&& data = CompressedFullPixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::direct_state_access::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); CubeMapTexture texture; texture.setStorage(1, TextureFormat::CompressedRGBAS3tcDxt3, Vector2i{4}) .setCompressedSubImage(0, {}, CompressedImageView3D{ CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, - CompressedFullPixelStorageData[testCaseInstanceId()].data}); + data.data}); { bool fails(Context::current().detectedDriver() & Context::DetectedDriver::Amd); @@ -2112,8 +2136,8 @@ void CubeMapTextureGLTest::compressedImage3DQueryView() { if(fails) CORRADE_SKIP("Skipping the rest of the test"); } - Containers::Array data{CompressedFullPixelStorageData[testCaseInstanceId()].offset + 16*6}; - MutableCompressedImageView3D image{CompressedFullPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, data, ImageFlag3D::Array}; + Containers::Array imageData{data.offset + 16*6}; + MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, imageData, ImageFlag3D::Array}; texture.compressedImage(0, image); { @@ -2133,10 +2157,10 @@ void CubeMapTextureGLTest::compressedImage3DQueryView() { CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 6})); { - CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && CompressedFullPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{}, + CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != CompressedPixelStorage{}, "Mesa drivers can't handle non-default pixel storage for full cubemap image queries."); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedFullPixelStorageData[testCaseInstanceId()].offset), - CompressedFullPixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } } diff --git a/src/Magnum/GL/Test/RectangleTextureGLTest.cpp b/src/Magnum/GL/Test/RectangleTextureGLTest.cpp index d00c168e2..6764d5a1d 100644 --- a/src/Magnum/GL/Test/RectangleTextureGLTest.cpp +++ b/src/Magnum/GL/Test/RectangleTextureGLTest.cpp @@ -374,74 +374,77 @@ void RectangleTextureGLTest::view() { } void RectangleTextureGLTest::image() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported."); RectangleTexture texture; texture.setImage(TextureFormat::RGBA8, ImageView2D{ - PixelStorageData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Image2D image = texture.image({PixelStorageData[testCaseInstanceId()].storage, + Image2D image = texture.image({data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlag2D{}); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void RectangleTextureGLTest::imageBuffer() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported."); RectangleTexture texture; texture.setImage(TextureFormat::RGBA8, BufferImage2D{ - PixelStorageData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); - BufferImage2D image = texture.image({PixelStorageData[testCaseInstanceId()].storage, + BufferImage2D image = texture.image({data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void RectangleTextureGLTest::imageQueryView() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported."); RectangleTexture texture; texture.setImage(TextureFormat::RGBA8, ImageView2D{ - PixelStorageData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorageData[testCaseInstanceId()].offset + 2*2*4}; - MutableImageView2D image{PixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array}; + Containers::Array imageData{data.offset + 2*2*4}; + MutableImageView2D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array}; texture.image(image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -449,8 +452,8 @@ void RectangleTextureGLTest::imageQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag2D::Array); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } @@ -463,7 +466,8 @@ constexpr UnsignedByte SubDataComplete[]{ }; void RectangleTextureGLTest::subImage() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported."); @@ -472,9 +476,9 @@ void RectangleTextureGLTest::subImage() { texture.setImage(TextureFormat::RGBA8, ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero)); texture.setSubImage(Vector2i(1), ImageView2D{ - PixelStorageData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -488,7 +492,8 @@ void RectangleTextureGLTest::subImage() { } void RectangleTextureGLTest::subImageBuffer() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported."); @@ -497,9 +502,9 @@ void RectangleTextureGLTest::subImageBuffer() { texture.setImage(TextureFormat::RGBA8, ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero)); texture.setSubImage(Vector2i(1), BufferImage2D{ - PixelStorageData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorageData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -516,7 +521,8 @@ void RectangleTextureGLTest::subImageBuffer() { } void RectangleTextureGLTest::subImageQuery() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported."); @@ -530,20 +536,21 @@ void RectangleTextureGLTest::subImageQuery() { MAGNUM_VERIFY_NO_GL_ERROR(); Image2D image = texture.subImage(Range2Di::fromSize(Vector2i{1}, Vector2i{2}), - {PixelStorageData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlag2D{}); CORRADE_COMPARE(image.size(), Vector2i{2}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void RectangleTextureGLTest::subImageQueryView() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported."); @@ -556,8 +563,8 @@ void RectangleTextureGLTest::subImageQueryView() { MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorageData[testCaseInstanceId()].offset + 2*2*4}; - MutableImageView2D image{PixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array}; + Containers::Array imageData{data.offset + 2*2*4}; + MutableImageView2D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array}; texture.subImage(Range2Di::fromSize(Vector2i{1}, Vector2i{2}), image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -565,13 +572,14 @@ void RectangleTextureGLTest::subImageQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag2D::Array); CORRADE_COMPARE(image.size(), Vector2i{2}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void RectangleTextureGLTest::subImageQueryBuffer() { - setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name); + auto&& data = PixelStorageData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported."); @@ -585,15 +593,15 @@ void RectangleTextureGLTest::subImageQueryBuffer() { MAGNUM_VERIFY_NO_GL_ERROR(); BufferImage2D image = texture.subImage(Range2Di::fromSize(Vector2i{1}, Vector2i{2}), - {PixelStorageData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector2i{2}); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset), - PixelStorageData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } diff --git a/src/Magnum/GL/Test/TextureArrayGLTest.cpp b/src/Magnum/GL/Test/TextureArrayGLTest.cpp index 1b8cb6afa..bb2b7f164 100644 --- a/src/Magnum/GL/Test/TextureArrayGLTest.cpp +++ b/src/Magnum/GL/Test/TextureArrayGLTest.cpp @@ -1089,73 +1089,76 @@ void TextureArrayGLTest::view2DOnCubeMapArray() { #ifndef MAGNUM_TARGET_GLES void TextureArrayGLTest::image1D() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); Texture1DArray texture; texture.setImage(0, TextureFormat::RGBA8, ImageView2D{ - PixelStorage1DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), PixelStorage1DData[testCaseInstanceId()].dataSparse}); + data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Image2D image = texture.image(0, {PixelStorage1DData[testCaseInstanceId()].storage, + Image2D image = texture.image(0, {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlag2D::Array); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset), - PixelStorage1DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureArrayGLTest::image1DBuffer() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); Texture1DArray texture; texture.setImage(0, TextureFormat::RGBA8, BufferImage2D{ - PixelStorage1DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), PixelStorage1DData[testCaseInstanceId()].dataSparse, + data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); BufferImage2D image = texture.image(0, - {PixelStorage1DData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset), - PixelStorage1DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureArrayGLTest::image1DQueryView() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); Texture1DArray texture; texture.setImage(0, TextureFormat::RGBA8, ImageView2D{ - PixelStorage1DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), PixelStorage1DData[testCaseInstanceId()].dataSparse}); + data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorage1DData[testCaseInstanceId()].offset + 2*2*4}; - MutableImageView2D image{PixelStorage1DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array}; + Containers::Array imageData{data.offset + 2*2*4}; + MutableImageView2D image{data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array}; texture.image(0, image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1163,8 +1166,8 @@ void TextureArrayGLTest::image1DQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag2D::Array); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset), - PixelStorage1DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } @@ -1177,7 +1180,8 @@ constexpr UnsignedByte SubData1DComplete[] = { }; void TextureArrayGLTest::subImage1D() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); @@ -1186,8 +1190,8 @@ void TextureArrayGLTest::subImage1D() { texture.setImage(0, TextureFormat::RGBA8, ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero1D)); texture.setSubImage(0, Vector2i(1), ImageView2D{ - PixelStorage1DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), PixelStorage1DData[testCaseInstanceId()].dataSparse}); + data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1202,7 +1206,8 @@ void TextureArrayGLTest::subImage1D() { } void TextureArrayGLTest::subImage1DBuffer() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); @@ -1211,9 +1216,9 @@ void TextureArrayGLTest::subImage1DBuffer() { texture.setImage(0, TextureFormat::RGBA8, ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero1D)); texture.setSubImage(0, Vector2i(1), BufferImage2D{ - PixelStorage1DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorage1DData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1230,7 +1235,8 @@ void TextureArrayGLTest::subImage1DBuffer() { } void TextureArrayGLTest::subImage1DQuery() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); @@ -1244,20 +1250,21 @@ void TextureArrayGLTest::subImage1DQuery() { MAGNUM_VERIFY_NO_GL_ERROR(); Image2D image = texture.subImage(0, Range2Di::fromSize(Vector2i{1}, Vector2i{2}), - {PixelStorage1DData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlag2D::Array); CORRADE_COMPARE(image.size(), Vector2i{2}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset), - PixelStorage1DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureArrayGLTest::subImage1DQueryView() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); @@ -1270,9 +1277,9 @@ void TextureArrayGLTest::subImage1DQueryView() { MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorage1DData[testCaseInstanceId()].offset + 2*2*4}; - MutableImageView2D image{PixelStorage1DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array}; + Containers::Array imageData{data.offset + 2*2*4}; + MutableImageView2D image{data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array}; texture.subImage(0, Range2Di::fromSize(Vector2i{1}, Vector2i{2}), image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1280,13 +1287,14 @@ void TextureArrayGLTest::subImage1DQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag2D::Array); CORRADE_COMPARE(image.size(), Vector2i{2}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset), - PixelStorage1DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureArrayGLTest::subImage1DQueryBuffer() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); @@ -1300,7 +1308,7 @@ void TextureArrayGLTest::subImage1DQueryBuffer() { MAGNUM_VERIFY_NO_GL_ERROR(); BufferImage2D image = texture.subImage(0, Range2Di::fromSize(Vector2i{1}, Vector2i{2}), - {PixelStorage1DData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); auto imageData = image.buffer().data(); @@ -1309,8 +1317,8 @@ void TextureArrayGLTest::subImage1DQueryBuffer() { CORRADE_COMPARE(image.size(), Vector2i{2}); /* Was broken on NV since 370.xx (May 2017), fixed in 390.25 (Mar 2018) */ - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset), - PixelStorage1DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } @@ -1348,7 +1356,8 @@ void TextureArrayGLTest::compressedSubImage1DQueryBuffer() { #endif void TextureArrayGLTest::image2D() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1357,29 +1366,30 @@ void TextureArrayGLTest::image2D() { Texture2DArray texture; texture.setImage(0, TextureFormat::RGBA8, ImageView3D{ - PixelStorage2DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2), - PixelStorage2DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); /** @todo How to test this on ES? */ #ifndef MAGNUM_TARGET_GLES - Image3D image = texture.image(0, {PixelStorage2DData[testCaseInstanceId()].storage, + Image3D image = texture.image(0, {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset), - PixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } void TextureArrayGLTest::image2DBuffer() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1388,53 +1398,54 @@ void TextureArrayGLTest::image2DBuffer() { Texture2DArray texture; texture.setImage(0, TextureFormat::RGBA8, BufferImage3D{ - PixelStorage2DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2), - PixelStorage2DData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); /** @todo How to test this on ES? */ #ifndef MAGNUM_TARGET_GLES - BufferImage3D image = texture.image(0, {PixelStorage2DData[testCaseInstanceId()].storage, + BufferImage3D image = texture.image(0, {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector3i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset), - PixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } #ifndef MAGNUM_TARGET_GLES void TextureArrayGLTest::image2DQueryView() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); Texture2DArray texture; texture.setImage(0, TextureFormat::RGBA8, ImageView3D{ - PixelStorage2DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2), - PixelStorage2DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorage2DData[testCaseInstanceId()].offset + 2*2*2*4}; - MutableImageView3D image{PixelStorage2DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, data}; + Containers::Array imageData{data.offset + 2*2*2*4}; + MutableImageView3D image{data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, imageData}; texture.image(0, image); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector3i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset), - PixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif @@ -1466,7 +1477,8 @@ constexpr UnsignedByte SubData2DComplete[]{ #endif void TextureArrayGLTest::subImage2D() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1477,9 +1489,9 @@ void TextureArrayGLTest::subImage2D() { texture.setImage(0, TextureFormat::RGBA8, ImageView3D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(4), Zero2D)); texture.setSubImage(0, Vector3i(1), ImageView3D{ - PixelStorage2DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2), - PixelStorage2DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1497,7 +1509,8 @@ void TextureArrayGLTest::subImage2D() { } void TextureArrayGLTest::subImage2DBuffer() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1508,9 +1521,9 @@ void TextureArrayGLTest::subImage2DBuffer() { texture.setImage(0, TextureFormat::RGBA8, ImageView3D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(4), Zero2D)); texture.setSubImage(0, Vector3i(1), BufferImage3D{ - PixelStorage2DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2), - PixelStorage2DData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1531,7 +1544,8 @@ void TextureArrayGLTest::subImage2DBuffer() { #ifndef MAGNUM_TARGET_GLES void TextureArrayGLTest::subImage2DQuery() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); @@ -1545,20 +1559,21 @@ void TextureArrayGLTest::subImage2DQuery() { MAGNUM_VERIFY_NO_GL_ERROR(); Image3D image = texture.subImage(0, Range3Di::fromSize(Vector3i{1}, Vector3i{2}), - {PixelStorage2DData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i{2}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset), - PixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureArrayGLTest::subImage2DQueryView() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); @@ -1571,9 +1586,9 @@ void TextureArrayGLTest::subImage2DQueryView() { MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorage2DData[testCaseInstanceId()].offset + 2*2*2*4}; - MutableImageView3D image{PixelStorage2DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, data, ImageFlag3D::Array}; + Containers::Array imageData{data.offset + 2*2*2*4}; + MutableImageView3D image{data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, imageData, ImageFlag3D::Array}; texture.subImage(0, Range3Di::fromSize(Vector3i{1}, Vector3i{2}), image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1581,13 +1596,14 @@ void TextureArrayGLTest::subImage2DQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i{2}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset), - PixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureArrayGLTest::subImage2DQueryBuffer() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); @@ -1601,21 +1617,22 @@ void TextureArrayGLTest::subImage2DQueryBuffer() { MAGNUM_VERIFY_NO_GL_ERROR(); BufferImage3D image = texture.subImage(0, Range3Di::fromSize(Vector3i{1}, Vector3i{2}), - {PixelStorage2DData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector3i{2}); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset), - PixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif void TextureArrayGLTest::compressedImage2D() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1633,35 +1650,36 @@ void TextureArrayGLTest::compressedImage2D() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif Texture2DArray texture; texture.setCompressedImage(0, CompressedImageView3D{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorage2DData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, - CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); #ifndef MAGNUM_TARGET_GLES - CompressedImage3D image = texture.compressedImage(0, {CompressedPixelStorage2DData[testCaseInstanceId()].storage}); + CompressedImage3D image = texture.compressedImage(0, {data.storage}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 2})); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset), - CompressedPixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } void TextureArrayGLTest::compressedImage2DBuffer() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1679,63 +1697,64 @@ void TextureArrayGLTest::compressedImage2DBuffer() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif Texture2DArray texture; texture.setCompressedImage(0, CompressedBufferImage3D{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorage2DData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, - CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); #ifndef MAGNUM_TARGET_GLES - CompressedBufferImage3D image = texture.compressedImage(0, {CompressedPixelStorage2DData[testCaseInstanceId()].storage}, BufferUsage::StaticRead); + CompressedBufferImage3D image = texture.compressedImage(0, {data.storage}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 2})); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset), - CompressedPixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } #ifndef MAGNUM_TARGET_GLES void TextureArrayGLTest::compressedImage2DQueryView() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); Texture2DArray texture; texture.setCompressedImage(0, CompressedImageView3D{ - CompressedPixelStorage2DData[testCaseInstanceId()].storage, + data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, - CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{CompressedPixelStorage2DData[testCaseInstanceId()].offset + 2*16}; - MutableCompressedImageView3D image{CompressedPixelStorage2DData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, data}; + Containers::Array imageData{data.offset + 2*16}; + MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, imageData}; texture.compressedImage(0, image); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 2})); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset), - CompressedPixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif @@ -1777,7 +1796,8 @@ constexpr UnsignedByte CompressedSubData2DComplete[]{ #endif void TextureArrayGLTest::compressedSubImage2D() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1795,7 +1815,7 @@ void TextureArrayGLTest::compressedSubImage2D() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif @@ -1804,10 +1824,10 @@ void TextureArrayGLTest::compressedSubImage2D() { Vector3i{12, 4, 4}, CompressedZero2D}); texture.setCompressedSubImage(0, {4, 0, 1}, CompressedImageView3D{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorage2DData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, - CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1819,7 +1839,7 @@ void TextureArrayGLTest::compressedSubImage2D() { CORRADE_COMPARE(image.size(), (Vector3i{12, 4, 4})); { - CORRADE_EXPECT_FAIL_IF(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), + CORRADE_EXPECT_FAIL_IF(data.storage != CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), "Non-default compressed pixel storage for array textures behaves weirdly on NVidia"); CORRADE_COMPARE_AS(Containers::arrayCast(image.data()), @@ -1830,7 +1850,8 @@ void TextureArrayGLTest::compressedSubImage2D() { } void TextureArrayGLTest::compressedSubImage2DBuffer() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -1848,7 +1869,7 @@ void TextureArrayGLTest::compressedSubImage2DBuffer() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif @@ -1857,10 +1878,10 @@ void TextureArrayGLTest::compressedSubImage2DBuffer() { Vector3i{12, 4, 4}, CompressedZero2D}); texture.setCompressedSubImage(0, {4, 0, 1}, CompressedBufferImage3D{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorage2DData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, - CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1880,7 +1901,8 @@ void TextureArrayGLTest::compressedSubImage2DBuffer() { #ifndef MAGNUM_TARGET_GLES void TextureArrayGLTest::compressedSubImage2DQuery() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); @@ -1888,9 +1910,9 @@ void TextureArrayGLTest::compressedSubImage2DQuery() { CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); Texture2DArray texture; @@ -1900,19 +1922,20 @@ void TextureArrayGLTest::compressedSubImage2DQuery() { MAGNUM_VERIFY_NO_GL_ERROR(); - CompressedImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 1}, {4, 4, 2}), {CompressedPixelStorage2DData[testCaseInstanceId()].storage}); + CompressedImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 1}, {4, 4, 2}), {data.storage}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 2})); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset), - CompressedPixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureArrayGLTest::compressedSubImage2DQueryView() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); @@ -1920,9 +1943,9 @@ void TextureArrayGLTest::compressedSubImage2DQueryView() { CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); Texture2DArray texture; @@ -1932,8 +1955,8 @@ void TextureArrayGLTest::compressedSubImage2DQueryView() { MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{CompressedPixelStorage2DData[testCaseInstanceId()].offset + 2*16}; - MutableCompressedImageView3D image{CompressedPixelStorage2DData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, data, ImageFlag3D::Array}; + Containers::Array imageData{data.offset + 2*16}; + MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, imageData, ImageFlag3D::Array}; texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 1}, {4, 4, 2}), image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1941,13 +1964,14 @@ void TextureArrayGLTest::compressedSubImage2DQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 2})); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset), - CompressedPixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureArrayGLTest::compressedSubImage2DQueryBuffer() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported."); @@ -1955,9 +1979,9 @@ void TextureArrayGLTest::compressedSubImage2DQueryBuffer() { CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); Texture2DArray texture; @@ -1969,7 +1993,7 @@ void TextureArrayGLTest::compressedSubImage2DQueryBuffer() { CompressedBufferImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 1}, {4, 4, 2}), { #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorage2DData[testCaseInstanceId()].storage + data.storage #endif }, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); @@ -1977,8 +2001,8 @@ void TextureArrayGLTest::compressedSubImage2DQueryBuffer() { MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), (Vector3i{4, 4, 2})); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset), - CompressedPixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } diff --git a/src/Magnum/GL/Test/TextureGLTest.cpp b/src/Magnum/GL/Test/TextureGLTest.cpp index 0195dcd71..0d148650c 100644 --- a/src/Magnum/GL/Test/TextureGLTest.cpp +++ b/src/Magnum/GL/Test/TextureGLTest.cpp @@ -1587,66 +1587,69 @@ void TextureGLTest::view3D() { #ifndef MAGNUM_TARGET_GLES void TextureGLTest::image1D() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); Texture1D texture; texture.setImage(0, TextureFormat::RGBA8, ImageView1D{ - PixelStorage1DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, 2, - PixelStorage1DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Image1D image = texture.image(0, {PixelStorage1DData[testCaseInstanceId()].storage, + Image1D image = texture.image(0, {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlags1D{}); CORRADE_COMPARE(image.size(), 2); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset), - PixelStorage1DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureGLTest::image1DBuffer() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); Texture1D texture; texture.setImage(0, TextureFormat::RGBA8, BufferImage1D{ - PixelStorage1DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, 2, - PixelStorage1DData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); BufferImage1D image = texture.image(0, - {PixelStorage1DData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticDraw); + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticDraw); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), 2); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset), - PixelStorage1DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureGLTest::image1DQueryView() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); Texture1D texture; texture.setImage(0, TextureFormat::RGBA8, ImageView1D{ - PixelStorage1DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, 2, - PixelStorage1DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorage1DData[testCaseInstanceId()].offset + 2*4}; - MutableImageView1D image{PixelStorage1DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, 2, data}; + Containers::Array imageData{data.offset + 2*4}; + MutableImageView1D image{data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, 2, imageData}; texture.image(0, image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1654,8 +1657,8 @@ void TextureGLTest::image1DQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlags1D{}); CORRADE_COMPARE(image.size(), 2); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset), - PixelStorage1DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } @@ -1665,15 +1668,16 @@ constexpr UnsignedByte SubData1DComplete[]{ }; void TextureGLTest::subImage1D() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); Texture1D texture; texture.setImage(0, TextureFormat::RGBA8, ImageView1D(PixelFormat::RGBA, PixelType::UnsignedByte, 4, Zero1D)); texture.setSubImage(0, 1, ImageView1D{ - PixelStorage1DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, 2, - PixelStorage1DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1688,15 +1692,16 @@ void TextureGLTest::subImage1D() { } void TextureGLTest::subImage1DBuffer() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); Texture1D texture; texture.setImage(0, TextureFormat::RGBA8, ImageView1D(PixelFormat::RGBA, PixelType::UnsignedByte, 4, Zero1D)); texture.setSubImage(0, 1, BufferImage1D{ - PixelStorage1DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, 2, - PixelStorage1DData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1712,7 +1717,8 @@ void TextureGLTest::subImage1DBuffer() { } void TextureGLTest::subImage1DQuery() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); @@ -1724,20 +1730,21 @@ void TextureGLTest::subImage1DQuery() { MAGNUM_VERIFY_NO_GL_ERROR(); Image1D image = texture.subImage(0, Range1Di::fromSize(1, 2), - {PixelStorage1DData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlags1D{}); CORRADE_COMPARE(image.size(), 2); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset), - PixelStorage1DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureGLTest::subImage1DQueryView() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); @@ -1748,9 +1755,9 @@ void TextureGLTest::subImage1DQueryView() { MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorage1DData[testCaseInstanceId()].offset + 2*4}; - MutableImageView1D image{PixelStorage1DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, 2, data}; + Containers::Array imageData{data.offset + 2*4}; + MutableImageView1D image{data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, 2, imageData}; texture.subImage(0, Range1Di::fromSize(1, 2), image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1758,13 +1765,14 @@ void TextureGLTest::subImage1DQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlags1D{}); CORRADE_COMPARE(image.size(), 2); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset), - PixelStorage1DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureGLTest::subImage1DQueryBuffer() { - setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name); + auto&& data = PixelStorage1DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); @@ -1776,15 +1784,15 @@ void TextureGLTest::subImage1DQueryBuffer() { MAGNUM_VERIFY_NO_GL_ERROR(); BufferImage1D image = texture.subImage(0, Range1Di::fromSize(1, 2), - {PixelStorage1DData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), 2); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset), - PixelStorage1DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } @@ -1822,14 +1830,15 @@ void TextureGLTest::compressedSubImage1DQueryBuffer() { #endif void TextureGLTest::image2D() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifdef MAGNUM_TARGET_GLES2 #ifndef MAGNUM_TARGET_WEBGL - if(PixelStorage2DData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported."); #else - if(PixelStorage2DData[testCaseInstanceId()].storage != PixelStorage{}) + if(data.storage != PixelStorage{}) CORRADE_SKIP("Image unpack is not supported in WebGL 1."); #endif #endif @@ -1841,37 +1850,37 @@ void TextureGLTest::image2D() { #else TextureFormat::RGBA, #endif - ImageView2D{ - PixelStorage2DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorage2DData[testCaseInstanceId()].dataSparse}); + ImageView2D{data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); /** @todo How to test this on ES? */ #ifndef MAGNUM_TARGET_GLES - Image2D image = texture.image(0, {PixelStorage2DData[testCaseInstanceId()].storage, + Image2D image = texture.image(0, {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlags2D{}); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset), - PixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } #ifndef MAGNUM_TARGET_GLES2 void TextureGLTest::image2DBuffer() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); Texture2D texture; texture.setImage(0, TextureFormat::RGBA8, BufferImage2D{ - PixelStorage2DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorage2DData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1879,15 +1888,15 @@ void TextureGLTest::image2DBuffer() { /** @todo How to test this on ES? */ #ifndef MAGNUM_TARGET_GLES BufferImage2D image = texture.image(0, - {PixelStorage2DData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset), - PixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } @@ -1895,19 +1904,20 @@ void TextureGLTest::image2DBuffer() { #ifndef MAGNUM_TARGET_GLES void TextureGLTest::image2DQueryView() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); Texture2D texture; texture.setImage(0, TextureFormat::RGBA8, ImageView2D{ - PixelStorage2DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorage2DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorage2DData[testCaseInstanceId()].offset + 2*2*4}; - MutableImageView2D image{PixelStorage2DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array}; + Containers::Array imageData{data.offset + 2*2*4}; + MutableImageView2D image{data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array}; texture.image(0, image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1915,8 +1925,8 @@ void TextureGLTest::image2DQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag2D::Array); CORRADE_COMPARE(image.size(), Vector2i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset), - PixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif @@ -1933,14 +1943,15 @@ constexpr UnsignedByte SubData2DComplete[]{ #endif void TextureGLTest::subImage2D() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifdef MAGNUM_TARGET_GLES2 #ifndef MAGNUM_TARGET_WEBGL - if(PixelStorage2DData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported."); #else - if(PixelStorage2DData[testCaseInstanceId()].storage != PixelStorage{}) + if(data.storage != PixelStorage{}) CORRADE_SKIP("Image unpack is not supported in WebGL 1."); #endif #endif @@ -1953,9 +1964,9 @@ void TextureGLTest::subImage2D() { TextureFormat::RGBA, #endif ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero2D)); - texture.setSubImage(0, Vector2i(1), ImageView2D{PixelStorage2DData[testCaseInstanceId()].storage, + texture.setSubImage(0, Vector2i(1), ImageView2D{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorage2DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -1974,14 +1985,15 @@ void TextureGLTest::subImage2D() { #ifndef MAGNUM_TARGET_GLES2 void TextureGLTest::subImage2DBuffer() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); Texture2D texture; texture.setImage(0, TextureFormat::RGBA8, ImageView2D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(4), Zero2D)); - texture.setSubImage(0, Vector2i(1), BufferImage2D{PixelStorage2DData[testCaseInstanceId()].storage, + texture.setSubImage(0, Vector2i(1), BufferImage2D{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i(2), - PixelStorage2DData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2002,7 +2014,8 @@ void TextureGLTest::subImage2DBuffer() { #ifndef MAGNUM_TARGET_GLES void TextureGLTest::subImage2DQuery() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); @@ -2014,20 +2027,21 @@ void TextureGLTest::subImage2DQuery() { MAGNUM_VERIFY_NO_GL_ERROR(); Image2D image = texture.subImage(0, Range2Di::fromSize(Vector2i{1}, Vector2i{2}), - {PixelStorage2DData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlags2D{}); CORRADE_COMPARE(image.size(), Vector2i{2}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset), - PixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureGLTest::subImage2DQueryView() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); @@ -2038,9 +2052,9 @@ void TextureGLTest::subImage2DQueryView() { MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorage2DData[testCaseInstanceId()].offset + 2*2*4}; - MutableImageView2D image{PixelStorage2DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array}; + Containers::Array imageData{data.offset + 2*2*4}; + MutableImageView2D image{data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array}; texture.subImage(0, Range2Di::fromSize(Vector2i{1}, Vector2i{2}), image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2048,13 +2062,14 @@ void TextureGLTest::subImage2DQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag2D::Array); CORRADE_COMPARE(image.size(), Vector2i{2}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset), - PixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureGLTest::subImage2DQueryBuffer() { - setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name); + auto&& data = PixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); @@ -2066,21 +2081,22 @@ void TextureGLTest::subImage2DQueryBuffer() { MAGNUM_VERIFY_NO_GL_ERROR(); BufferImage2D image = texture.subImage(0, Range2Di::fromSize(Vector2i{1}, Vector2i{2}), - {PixelStorage2DData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector2i{2}); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset), - PixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif void TextureGLTest::compressedImage2D() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -2094,37 +2110,38 @@ void TextureGLTest::compressedImage2D() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif Texture2D texture; texture.setCompressedImage(0, CompressedImageView2D{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorage2DData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, - CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); #ifndef MAGNUM_TARGET_GLES - CompressedImage2D image = texture.compressedImage(0, {CompressedPixelStorage2DData[testCaseInstanceId()].storage}); + CompressedImage2D image = texture.compressedImage(0, {data.storage}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlags2D{}); CORRADE_COMPARE(image.size(), Vector2i{4}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset), - CompressedPixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } #ifndef MAGNUM_TARGET_GLES2 void TextureGLTest::compressedImage2DBuffer() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -2138,30 +2155,30 @@ void TextureGLTest::compressedImage2DBuffer() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif Texture2D texture; texture.setCompressedImage(0, CompressedBufferImage2D{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorage2DData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, - CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); #ifndef MAGNUM_TARGET_GLES - CompressedBufferImage2D image = texture.compressedImage(0, {CompressedPixelStorage2DData[testCaseInstanceId()].storage}, BufferUsage::StaticRead); + CompressedBufferImage2D image = texture.compressedImage(0, {data.storage}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector2i{4}); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset), - CompressedPixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } @@ -2169,24 +2186,25 @@ void TextureGLTest::compressedImage2DBuffer() { #ifndef MAGNUM_TARGET_GLES void TextureGLTest::compressedImage2DQueryView() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); Texture2D texture; texture.setCompressedImage(0, CompressedImageView2D{ - CompressedPixelStorage2DData[testCaseInstanceId()].storage, + data.storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, - CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{CompressedPixelStorage2DData[testCaseInstanceId()].offset + 1*16}; - MutableCompressedImageView2D image{CompressedPixelStorage2DData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, data, ImageFlag2D::Array}; + Containers::Array imageData{data.offset + 1*16}; + MutableCompressedImageView2D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, imageData, ImageFlag2D::Array}; texture.compressedImage(0, image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2195,8 +2213,8 @@ void TextureGLTest::compressedImage2DQueryView() { CORRADE_COMPARE(image.flags(), ImageFlag2D::Array); CORRADE_COMPARE(image.size(), Vector2i{4}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset), - CompressedPixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif @@ -2217,7 +2235,8 @@ constexpr UnsignedByte CompressedSubData2DComplete[]{ #endif void TextureGLTest::compressedSubImage2D() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -2231,7 +2250,7 @@ void TextureGLTest::compressedSubImage2D() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif @@ -2240,10 +2259,10 @@ void TextureGLTest::compressedSubImage2D() { {12, 4}, CompressedZero2D}); texture.setCompressedSubImage(0, {4, 0}, CompressedImageView2D{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorage2DData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, - CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2261,7 +2280,8 @@ void TextureGLTest::compressedSubImage2D() { #ifndef MAGNUM_TARGET_GLES2 void TextureGLTest::compressedSubImage2DBuffer() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) @@ -2275,7 +2295,7 @@ void TextureGLTest::compressedSubImage2DBuffer() { #endif #ifndef MAGNUM_TARGET_GLES - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #endif @@ -2284,10 +2304,10 @@ void TextureGLTest::compressedSubImage2DBuffer() { {12, 4}, CompressedZero2D}); texture.setCompressedSubImage(0, {4, 0}, CompressedBufferImage2D{ #ifndef MAGNUM_TARGET_GLES - CompressedPixelStorage2DData[testCaseInstanceId()].storage, + data.storage, #endif CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, - CompressedPixelStorage2DData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2308,15 +2328,16 @@ void TextureGLTest::compressedSubImage2DBuffer() { #ifndef MAGNUM_TARGET_GLES void TextureGLTest::compressedSubImage2DQuery() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); Texture2D texture; @@ -2326,27 +2347,28 @@ void TextureGLTest::compressedSubImage2DQuery() { MAGNUM_VERIFY_NO_GL_ERROR(); CompressedImage2D image = texture.compressedSubImage(0, Range2Di::fromSize({4, 0}, Vector2i{4}), - {CompressedPixelStorage2DData[testCaseInstanceId()].storage}); + {data.storage}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlags2D{}); CORRADE_COMPARE(image.size(), Vector2i{4}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset), - CompressedPixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureGLTest::compressedSubImage2DQueryView() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); Texture2D texture; @@ -2355,8 +2377,8 @@ void TextureGLTest::compressedSubImage2DQueryView() { MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{CompressedPixelStorage2DData[testCaseInstanceId()].offset + 1*16}; - MutableCompressedImageView2D image{CompressedPixelStorage2DData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, data, ImageFlag2D::Array}; + Containers::Array imageData{data.offset + 1*16}; + MutableCompressedImageView2D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, imageData, ImageFlag2D::Array}; texture.compressedSubImage(0, Range2Di::fromSize({4, 0}, Vector2i{4}), image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2364,21 +2386,22 @@ void TextureGLTest::compressedSubImage2DQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag2D::Array); CORRADE_COMPARE(image.size(), Vector2i{4}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset), - CompressedPixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureGLTest::compressedSubImage2DQueryBuffer() { - setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage2DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported."); - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); Texture2D texture; @@ -2388,61 +2411,63 @@ void TextureGLTest::compressedSubImage2DQueryBuffer() { MAGNUM_VERIFY_NO_GL_ERROR(); CompressedBufferImage2D image = texture.compressedSubImage(0, Range2Di::fromSize({4, 0}, Vector2i{4}), - {CompressedPixelStorage2DData[testCaseInstanceId()].storage}, BufferUsage::StaticRead); + {data.storage}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector2i{4}); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset), - CompressedPixelStorage2DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif #if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL)) void TextureGLTest::image3D() { - setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name); + auto&& data = PixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifdef MAGNUM_TARGET_GLES2 if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported."); - if(PixelStorage3DData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported."); #endif Texture3D texture; texture.setImage(0, TextureFormat::RGBA8, ImageView3D{ - PixelStorage3DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2), - PixelStorage3DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); /** @todo How to test this on ES? */ #ifndef MAGNUM_TARGET_GLES - Image3D image = texture.image(0, {PixelStorage3DData[testCaseInstanceId()].storage, + Image3D image = texture.image(0, {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlags3D{}); CORRADE_COMPARE(image.size(), Vector3i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage3DData[testCaseInstanceId()].offset), - PixelStorage3DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } #ifndef MAGNUM_TARGET_GLES2 void TextureGLTest::image3DBuffer() { - setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name); + auto&& data = PixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); Texture3D texture; texture.setImage(0, TextureFormat::RGBA8, BufferImage3D{ - PixelStorage3DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2), - PixelStorage3DData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2450,15 +2475,15 @@ void TextureGLTest::image3DBuffer() { /** @todo How to test this on ES? */ #ifndef MAGNUM_TARGET_GLES BufferImage3D image = texture.image(0, - {PixelStorage3DData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte}, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector3i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorage3DData[testCaseInstanceId()].offset), - PixelStorage3DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); #endif } @@ -2466,19 +2491,20 @@ void TextureGLTest::image3DBuffer() { #ifndef MAGNUM_TARGET_GLES void TextureGLTest::image3DQueryView() { - setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name); + auto&& data = PixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); Texture3D texture; texture.setImage(0, TextureFormat::RGBA8, ImageView3D{ - PixelStorage3DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2), - PixelStorage3DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorage3DData[testCaseInstanceId()].offset + 2*2*2*4}; - MutableImageView3D image{PixelStorage3DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, data, ImageFlag3D::Array}; + Containers::Array imageData{data.offset + 2*2*2*4}; + MutableImageView3D image{data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, imageData, ImageFlag3D::Array}; texture.image(0, image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2486,8 +2512,8 @@ void TextureGLTest::image3DQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i(2)); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage3DData[testCaseInstanceId()].offset), - PixelStorage3DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif @@ -2519,21 +2545,22 @@ constexpr UnsignedByte SubData3DComplete[]{ #endif void TextureGLTest::subImage3D() { - setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name); + auto&& data = PixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifdef MAGNUM_TARGET_GLES2 if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::OES::texture_3D::string() << "is not supported."); - if(PixelStorage3DData[testCaseInstanceId()].storage != PixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::EXT::unpack_subimage::string() << "is not supported."); #endif Texture3D texture; texture.setImage(0, TextureFormat::RGBA8, ImageView3D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(4), Zero3D)); - texture.setSubImage(0, Vector3i(1), ImageView3D{PixelStorage3DData[testCaseInstanceId()].storage, + texture.setSubImage(0, Vector3i(1), ImageView3D{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2), - PixelStorage3DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2552,15 +2579,16 @@ void TextureGLTest::subImage3D() { #ifndef MAGNUM_TARGET_GLES2 void TextureGLTest::subImage3DBuffer() { - setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name); + auto&& data = PixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); Texture3D texture; texture.setImage(0, TextureFormat::RGBA8, ImageView3D(PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(4), Zero3D)); texture.setSubImage(0, Vector3i(1), BufferImage3D{ - PixelStorage3DData[testCaseInstanceId()].storage, + data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i(2), - PixelStorage3DData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2582,7 +2610,8 @@ void TextureGLTest::subImage3DBuffer() { #ifndef MAGNUM_TARGET_GLES void TextureGLTest::subImage3DQuery() { - setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name); + auto&& data = PixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); @@ -2594,20 +2623,20 @@ void TextureGLTest::subImage3DQuery() { MAGNUM_VERIFY_NO_GL_ERROR(); Image3D image = texture.subImage(0, Range3Di::fromSize(Vector3i{1}, Vector3i{2}), - {PixelStorage3DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte}); + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlags3D{}); CORRADE_COMPARE(image.size(), Vector3i{2}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage3DData[testCaseInstanceId()].offset), - PixelStorage3DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureGLTest::subImage3DQueryView() { - setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name); + auto&& data = PixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); @@ -2618,9 +2647,9 @@ void TextureGLTest::subImage3DQueryView() { MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{PixelStorage3DData[testCaseInstanceId()].offset + 2*2*2*4}; - MutableImageView3D image{PixelStorage3DData[testCaseInstanceId()].storage, - PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, data, ImageFlag3D::Array}; + Containers::Array imageData{data.offset + 2*2*2*4}; + MutableImageView3D image{data.storage, + PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, imageData, ImageFlag3D::Array}; texture.subImage(0, Range3Di::fromSize(Vector3i{1}, Vector3i{2}), image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2628,13 +2657,14 @@ void TextureGLTest::subImage3DQueryView() { /* Doesn't matter what flags are set, they stay untouched */ CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i{2}); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(PixelStorage3DData[testCaseInstanceId()].offset), - PixelStorage3DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } void TextureGLTest::subImage3DQueryBuffer() { - setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name); + auto&& data = PixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); @@ -2646,7 +2676,7 @@ void TextureGLTest::subImage3DQueryBuffer() { MAGNUM_VERIFY_NO_GL_ERROR(); BufferImage3D image = texture.subImage(0, Range3Di::fromSize(Vector3i{1}, Vector3i{2}), - {PixelStorage3DData[testCaseInstanceId()].storage, + {data.storage, PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); @@ -2655,14 +2685,15 @@ void TextureGLTest::subImage3DQueryBuffer() { CORRADE_COMPARE(image.size(), Vector3i{2}); CORRADE_EXPECT_FAIL_IF(Context::current().detectedDriver() & Context::DetectedDriver::Mesa, "Mesa has this broken since 21.2, worked fine with 21.1."); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(PixelStorage3DData[testCaseInstanceId()].offset), - PixelStorage3DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif void TextureGLTest::compressedImage3D() { - setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #if defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL) CORRADE_SKIP("No 3D texture compression format available on OpenGL ES 2.0."); @@ -2670,7 +2701,7 @@ void TextureGLTest::compressedImage3D() { #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported."); - if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #else if(!Context::current().isExtensionSupported()) @@ -2679,25 +2710,25 @@ void TextureGLTest::compressedImage3D() { Texture3D texture; texture.setCompressedImage(0, CompressedImageView3D{ - CompressedPixelStorage3DData[testCaseInstanceId()].storage, + data.storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, - CompressedPixelStorage3DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); /** @todo How to test this on ES? */ #ifndef MAGNUM_TARGET_GLES - CompressedImage3D image = texture.compressedImage(0, {CompressedPixelStorage3DData[testCaseInstanceId()].storage}); + CompressedImage3D image = texture.compressedImage(0, {data.storage}); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.flags(), ImageFlags3D{}); CORRADE_COMPARE(image.size(), Vector3i{4}); { - CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{}, + CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != CompressedPixelStorage{}, "Mesa drivers can't handle non-default compressed 3D pixel storage."); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorage3DData[testCaseInstanceId()].offset), - CompressedPixelStorage3DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif @@ -2706,12 +2737,13 @@ void TextureGLTest::compressedImage3D() { #ifndef MAGNUM_TARGET_GLES2 void TextureGLTest::compressedImage3DBuffer() { - setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported."); - if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #else if(!Context::current().isExtensionSupported()) @@ -2720,26 +2752,26 @@ void TextureGLTest::compressedImage3DBuffer() { Texture3D texture; texture.setCompressedImage(0, CompressedBufferImage3D{ - CompressedPixelStorage3DData[testCaseInstanceId()].storage, + data.storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, - CompressedPixelStorage3DData[testCaseInstanceId()].dataSparse, + data.dataSparse, BufferUsage::StaticDraw}); MAGNUM_VERIFY_NO_GL_ERROR(); /** @todo How to test this on ES? */ #ifndef MAGNUM_TARGET_GLES - CompressedBufferImage3D image = texture.compressedImage(0, {CompressedPixelStorage3DData[testCaseInstanceId()].storage}, BufferUsage::StaticRead); + CompressedBufferImage3D image = texture.compressedImage(0, {data.storage}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(image.size(), Vector3i{4}); { - CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{}, + CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != CompressedPixelStorage{}, "Mesa drivers can't handle non-default compressed 3D pixel storage."); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(CompressedPixelStorage3DData[testCaseInstanceId()].offset), - CompressedPixelStorage3DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } #endif @@ -2748,23 +2780,24 @@ void TextureGLTest::compressedImage3DBuffer() { #ifndef MAGNUM_TARGET_GLES void TextureGLTest::compressedImage3DQueryView() { - setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported."); - if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); Texture3D texture; texture.setCompressedImage(0, CompressedImageView3D{ - CompressedPixelStorage3DData[testCaseInstanceId()].storage, + data.storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, - CompressedPixelStorage3DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{CompressedPixelStorage2DData[testCaseInstanceId()].offset + 64}; - MutableCompressedImageView3D image{CompressedPixelStorage2DData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, data, ImageFlag3D::Array}; + Containers::Array imageData{data.offset + 64}; + MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, imageData, ImageFlag3D::Array}; texture.compressedImage(0, image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2773,10 +2806,10 @@ void TextureGLTest::compressedImage3DQueryView() { CORRADE_COMPARE(image.flags(), ImageFlag3D::Array); CORRADE_COMPARE(image.size(), Vector3i{4}); { - CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{}, + CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa) && data.storage != CompressedPixelStorage{}, "Mesa drivers can't handle non-default compressed 3D pixel storage."); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorage3DData[testCaseInstanceId()].offset), - CompressedPixelStorage3DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } } @@ -2829,7 +2862,8 @@ constexpr UnsignedByte CompressedSubData3DComplete[]{ #endif void TextureGLTest::compressedSubImage3D() { - setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #if defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL) CORRADE_SKIP("No 3D texture compression format available on OpenGL ES 2.0."); @@ -2837,7 +2871,7 @@ void TextureGLTest::compressedSubImage3D() { #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported."); - if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #else if(!Context::current().isExtensionSupported()) @@ -2847,9 +2881,9 @@ void TextureGLTest::compressedSubImage3D() { Texture3D texture; texture.setCompressedImage(0, CompressedImageView3D{CompressedPixelFormat::RGBABptcUnorm, {12, 4, 4}, CompressedZero3D}); - texture.setCompressedSubImage(0, {4, 0, 0}, CompressedImageView3D{CompressedPixelStorage3DData[testCaseInstanceId()].storage, + texture.setCompressedSubImage(0, {4, 0, 0}, CompressedImageView3D{data.storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, - CompressedPixelStorage3DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2862,7 +2896,7 @@ void TextureGLTest::compressedSubImage3D() { CORRADE_COMPARE(image.size(), (Vector3i{12, 4, 4})); { - CORRADE_EXPECT_FAIL_IF(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), + CORRADE_EXPECT_FAIL_IF(data.storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), "Default compressed pixel storage behaves weirdly with BPTC compression on NVidia."); CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa), "Mesa drivers can't handle compressed 3D pixel storage for subimages."); @@ -2876,12 +2910,13 @@ void TextureGLTest::compressedSubImage3D() { #ifndef MAGNUM_TARGET_GLES2 void TextureGLTest::compressedSubImage3DBuffer() { - setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported."); - if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); #else if(!Context::current().isExtensionSupported()) @@ -2891,9 +2926,9 @@ void TextureGLTest::compressedSubImage3DBuffer() { Texture3D texture; texture.setCompressedImage(0, CompressedImageView3D{CompressedPixelFormat::RGBABptcUnorm, {12, 4, 4}, CompressedZero3D}); - texture.setCompressedSubImage(0, {4, 0, 0}, CompressedImageView3D{CompressedPixelStorage3DData[testCaseInstanceId()].storage, + texture.setCompressedSubImage(0, {4, 0, 0}, CompressedImageView3D{data.storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, - CompressedPixelStorage3DData[testCaseInstanceId()].dataSparse}); + data.dataSparse}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2907,7 +2942,7 @@ void TextureGLTest::compressedSubImage3DBuffer() { CORRADE_COMPARE(image.size(), (Vector3i{12, 4, 4})); { - CORRADE_EXPECT_FAIL_IF(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), + CORRADE_EXPECT_FAIL_IF(data.storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), "Default compressed pixel storage behaves weirdly with BPTC compression on NVidia."); CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa), "Mesa drivers can't handle compressed 3D pixel storage for subimages."); @@ -2921,15 +2956,16 @@ void TextureGLTest::compressedSubImage3DBuffer() { #ifndef MAGNUM_TARGET_GLES void TextureGLTest::compressedSubImage3DQuery() { - setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported."); - if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); Texture3D texture; @@ -2939,7 +2975,7 @@ void TextureGLTest::compressedSubImage3DQuery() { MAGNUM_VERIFY_NO_GL_ERROR(); CompressedImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 0}, Vector3i{4}), - {CompressedPixelStorage3DData[testCaseInstanceId()].storage}); + {data.storage}); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2947,26 +2983,27 @@ void TextureGLTest::compressedSubImage3DQuery() { CORRADE_COMPARE(image.size(), (Vector3i{4})); { - CORRADE_EXPECT_FAIL_IF(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), + CORRADE_EXPECT_FAIL_IF(data.storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), "Default compressed pixel storage behaves weirdly with BPTC compression on NVidia."); CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa), "Mesa drivers can't handle compressed 3D pixel storage for subimages."); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorage3DData[testCaseInstanceId()].offset), - CompressedPixelStorage3DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } } void TextureGLTest::compressedSubImage3DQueryView() { - setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported."); - if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); Texture3D texture; @@ -2975,8 +3012,8 @@ void TextureGLTest::compressedSubImage3DQueryView() { MAGNUM_VERIFY_NO_GL_ERROR(); - Containers::Array data{CompressedPixelStorage2DData[testCaseInstanceId()].offset + 64}; - MutableCompressedImageView3D image{CompressedPixelStorage2DData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, data, ImageFlag3D::Array}; + Containers::Array imageData{data.offset + 64}; + MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, imageData, ImageFlag3D::Array}; texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 0}, Vector3i{4}), image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -2986,26 +3023,27 @@ void TextureGLTest::compressedSubImage3DQueryView() { CORRADE_COMPARE(image.size(), (Vector3i{4})); { - CORRADE_EXPECT_FAIL_IF(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), + CORRADE_EXPECT_FAIL_IF(data.storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), "Default compressed pixel storage behaves weirdly with BPTC compression on NVidia."); CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa), "Mesa drivers can't handle compressed 3D pixel storage for subimages."); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(CompressedPixelStorage3DData[testCaseInstanceId()].offset), - CompressedPixelStorage3DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } } void TextureGLTest::compressedSubImage3DQueryBuffer() { - setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name); + auto&& data = CompressedPixelStorage3DData[testCaseInstanceId()]; + setTestCaseDescription(data.name); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported."); if(!Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::texture_compression_bptc::string() << "is not supported."); - if(CompressedPixelStorage3DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported."); - if(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) + if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported()) CORRADE_SKIP(Extensions::ARB::internalformat_query2::string() << "is not supported."); Texture3D texture; @@ -3015,7 +3053,7 @@ void TextureGLTest::compressedSubImage3DQueryBuffer() { MAGNUM_VERIFY_NO_GL_ERROR(); CompressedBufferImage3D image = texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 0}, Vector3i{4}), - {CompressedPixelStorage3DData[testCaseInstanceId()].storage}, BufferUsage::StaticRead); + {data.storage}, BufferUsage::StaticRead); const auto imageData = image.buffer().data(); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -3023,12 +3061,12 @@ void TextureGLTest::compressedSubImage3DQueryBuffer() { CORRADE_COMPARE(image.size(), Vector3i{4}); { - CORRADE_EXPECT_FAIL_IF(CompressedPixelStorage3DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), + CORRADE_EXPECT_FAIL_IF(data.storage == CompressedPixelStorage{} && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia), "Default compressed pixel storage behaves weirdly with BPTC compression on NVidia."); CORRADE_EXPECT_FAIL_IF((Context::current().detectedDriver() & Context::DetectedDriver::Mesa), "Mesa drivers can't handle compressed 3D pixel storage for subimages."); - CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(CompressedPixelStorage3DData[testCaseInstanceId()].offset), - CompressedPixelStorage3DData[testCaseInstanceId()].data, + CORRADE_COMPARE_AS(Containers::arrayCast(imageData).exceptPrefix(data.offset), + data.data, TestSuite::Compare::Container); } }