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

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.
pull/419/merge
Vladimír Vondruš 2 years ago
parent
657f7164a8
commit
e9b07ef4ce
5 changed files with 771 additions and 661 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 192
      src/Magnum/GL/Test/CubeMapTextureArrayGLTest.cpp
  2. 364
      src/Magnum/GL/Test/CubeMapTextureGLTest.cpp
  3. 84
      src/Magnum/GL/Test/RectangleTextureGLTest.cpp
  4. 284
      src/Magnum/GL/Test/TextureArrayGLTest.cpp
  5. 506
      src/Magnum/GL/Test/TextureGLTest.cpp

192
src/Magnum/GL/Test/CubeMapTextureArrayGLTest.cpp
Unescape View File

@ -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<Extensions::ARB::texture_cube_map_array>())
@ -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<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_cube_map_array>())
@ -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<UnsignedByte>(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_cube_map_array>())
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<char> 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<char> 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<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_cube_map_array>())
@ -792,35 +796,36 @@ void CubeMapTextureArrayGLTest::compressedImage() {
#endif
#ifndef MAGNUM_TARGET_GLES
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
CompressedPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_cube_map_array>())
@ -838,59 +843,60 @@ void CubeMapTextureArrayGLTest::compressedImageBuffer() {
#endif
#ifndef MAGNUM_TARGET_GLES
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<UnsignedByte>(imageData).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
CompressedPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_cube_map_array>())
CORRADE_SKIP(Extensions::ARB::texture_cube_map_array::string() << "is not supported.");
if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<char> data{CompressedPixelStorageData[testCaseInstanceId()].offset + 6*16};
MutableCompressedImageView3D image{CompressedPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, data, ImageFlag3D::Array};
Containers::Array<char> 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<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
CompressedPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_cube_map_array>())
@ -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<Extensions::ARB::texture_cube_map_array>())
@ -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<Extensions::ARB::texture_cube_map_array>())
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<UnsignedByte>(image.data()).exceptPrefix(SubPixelStorageData[testCaseInstanceId()].offset),
SubPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_cube_map_array>())
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<char> 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<char> 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<UnsignedByte>(image.data()).exceptPrefix(SubPixelStorageData[testCaseInstanceId()].offset),
SubPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_cube_map_array>())
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<UnsignedByte>(imageData).exceptPrefix(SubPixelStorageData[testCaseInstanceId()].offset),
SubPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_cube_map_array>())
@ -1177,7 +1189,7 @@ void CubeMapTextureArrayGLTest::compressedSubImage() {
#endif
#ifndef MAGNUM_TARGET_GLES
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<UnsignedByte>(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<Extensions::ARB::texture_cube_map_array>())
@ -1230,7 +1243,7 @@ void CubeMapTextureArrayGLTest::compressedSubImageBuffer() {
#endif
#ifndef MAGNUM_TARGET_GLES
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<Extensions::ARB::texture_cube_map_array>())
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<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedSubPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
if(CompressedSubPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
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<UnsignedByte>(image.data()).exceptPrefix(CompressedSubPixelStorageData[testCaseInstanceId()].offset),
CompressedSubPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_cube_map_array>())
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<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedSubPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
if(CompressedSubPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
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<char> data{CompressedSubPixelStorageData[testCaseInstanceId()].offset + 4*16};
MutableCompressedImageView3D image{CompressedPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 4}, data, ImageFlag3D::Array};
Containers::Array<char> 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<UnsignedByte>(image.data()).exceptPrefix(CompressedSubPixelStorageData[testCaseInstanceId()].offset),
CompressedSubPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_cube_map_array>())
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<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedSubPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
if(CompressedSubPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
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<UnsignedByte>(imageData).exceptPrefix(CompressedSubPixelStorageData[testCaseInstanceId()].offset),
CompressedSubPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
data.data,
TestSuite::Compare::Container);
}
#endif

364
src/Magnum/GL/Test/CubeMapTextureGLTest.cpp
Unescape View File

@ -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<Extensions::EXT::unpack_subimage>())
if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
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<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::unpack_subimage>())
if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
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<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<UnsignedByte>(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<char> data{PixelStorageData[testCaseInstanceId()].offset + 2*2*4};
MutableImageView2D image{PixelStorageData[testCaseInstanceId()].storage,
PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array};
Containers::Array<char> 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<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::unpack_subimage>())
if(data.storage != PixelStorage{} && !Context::current().isExtensionSupported<Extensions::EXT::unpack_subimage>())
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<Extensions::ARB::get_texture_sub_image>())
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<const UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedByte>(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<Extensions::ARB::get_texture_sub_image>())
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<char> data{PixelStorageData[testCaseInstanceId()].offset + 2*2*4};
MutableImageView3D image{PixelStorageData[testCaseInstanceId()].storage,
PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 1}, data, ImageFlag3D::Array};
Containers::Array<char> 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<const UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedByte>(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<Extensions::ARB::get_texture_sub_image>())
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<UnsignedByte>(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_compression_s3tc>())
@ -1266,16 +1276,16 @@ void CubeMapTextureGLTest::compressedImage() {
#endif
#ifndef MAGNUM_TARGET_GLES
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
CompressedPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_compression_s3tc>())
@ -1316,16 +1327,16 @@ void CubeMapTextureGLTest::compressedImageBuffer() {
#endif
#ifndef MAGNUM_TARGET_GLES
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<UnsignedByte>(imageData).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
CompressedPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<char> data{CompressedPixelStorageData[testCaseInstanceId()].offset + 16};
MutableCompressedImageView2D image{CompressedPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, data, ImageFlag2D::Array};
Containers::Array<char> 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<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
CompressedPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_storage>())
@ -1491,7 +1504,7 @@ void CubeMapTextureGLTest::immutableCompressedImage() {
#endif
#ifndef MAGNUM_TARGET_GLES
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
CompressedPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_compression_s3tc>())
@ -1577,7 +1591,7 @@ void CubeMapTextureGLTest::compressedSubImage() {
#endif
#ifndef MAGNUM_TARGET_GLES
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<Extensions::ARB::direct_state_access>() && (Context::current().detectedDriver() & Context::DetectedDriver::NVidia),
CORRADE_EXPECT_FAIL_IF(data.storage != CompressedPixelStorage{} && Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>() && (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<UnsignedByte>(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<Extensions::EXT::texture_compression_s3tc>())
@ -1637,7 +1652,7 @@ void CubeMapTextureGLTest::compressedSubImageBuffer() {
#endif
#ifndef MAGNUM_TARGET_GLES
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<Extensions::ARB::get_texture_sub_image>())
CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
if(CompressedPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
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<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
CompressedPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::get_texture_sub_image>())
CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
if(CompressedPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
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<char> data{CompressedPixelStorageData[testCaseInstanceId()].offset + 16};
MutableCompressedImageView3D image{CompressedPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 1}, data, ImageFlag3D::Array};
Containers::Array<char> 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<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
CompressedPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::get_texture_sub_image>())
CORRADE_SKIP(Extensions::ARB::get_texture_sub_image::string() << "is not supported.");
if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
if(CompressedPixelStorageData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
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<UnsignedByte>(imageData).exceptPrefix(CompressedPixelStorageData[testCaseInstanceId()].offset),
CompressedPixelStorageData[testCaseInstanceId()].data,
Containers::arrayCast<UnsignedByte>(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<UnsignedByte>(image.data()).exceptPrefix(FullPixelStorageData[testCaseInstanceId()].offset),
FullPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<UnsignedByte>(imageData).exceptPrefix(FullPixelStorageData[testCaseInstanceId()].offset),
FullPixelStorageData[testCaseInstanceId()].data, TestSuite::Compare::Container);
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<char> 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<char> 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<UnsignedByte>(image.data()).exceptPrefix(FullPixelStorageData[testCaseInstanceId()].offset),
FullPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::direct_state_access>())
CORRADE_SKIP(Extensions::ARB::direct_state_access::string() << "is not supported.");
if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<UnsignedByte>(image.data()).exceptPrefix(CompressedFullPixelStorageData[testCaseInstanceId()].offset),
CompressedFullPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::direct_state_access>())
CORRADE_SKIP(Extensions::ARB::direct_state_access::string() << "is not supported.");
if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<UnsignedByte>(imageData).exceptPrefix(CompressedFullPixelStorageData[testCaseInstanceId()].offset),
CompressedFullPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::direct_state_access>())
CORRADE_SKIP(Extensions::ARB::direct_state_access::string() << "is not supported.");
if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedPixelStorageData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<char> data{CompressedFullPixelStorageData[testCaseInstanceId()].offset + 16*6};
MutableCompressedImageView3D image{CompressedFullPixelStorageData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, data, ImageFlag3D::Array};
Containers::Array<char> 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<UnsignedByte>(image.data()).exceptPrefix(CompressedFullPixelStorageData[testCaseInstanceId()].offset),
CompressedFullPixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()).exceptPrefix(data.offset),
data.data,
TestSuite::Compare::Container);
}
}

84
src/Magnum/GL/Test/RectangleTextureGLTest.cpp
Unescape View File

@ -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<Extensions::ARB::texture_rectangle>())
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<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_rectangle>())
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<UnsignedByte>(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_rectangle>())
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<char> data{PixelStorageData[testCaseInstanceId()].offset + 2*2*4};
MutableImageView2D image{PixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array};
Containers::Array<char> 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<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_rectangle>())
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<Extensions::ARB::texture_rectangle>())
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<Extensions::ARB::texture_rectangle>())
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<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_rectangle>())
CORRADE_SKIP(Extensions::ARB::texture_rectangle::string() << "is not supported.");
@ -556,8 +563,8 @@ void RectangleTextureGLTest::subImageQueryView() {
MAGNUM_VERIFY_NO_GL_ERROR();
Containers::Array<char> data{PixelStorageData[testCaseInstanceId()].offset + 2*2*4};
MutableImageView2D image{PixelStorageData[testCaseInstanceId()].storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array};
Containers::Array<char> 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<UnsignedByte>(image.data()).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::ARB::texture_rectangle>())
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<UnsignedByte>(imageData).exceptPrefix(PixelStorageData[testCaseInstanceId()].offset),
PixelStorageData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
data.data,
TestSuite::Compare::Container);
}

284
src/Magnum/GL/Test/TextureArrayGLTest.cpp
Unescape View File

@ -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<Extensions::EXT::texture_array>())
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<UnsignedByte>(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
PixelStorage1DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
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<UnsignedByte>(imageData).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
PixelStorage1DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
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<char> data{PixelStorage1DData[testCaseInstanceId()].offset + 2*2*4};
MutableImageView2D image{PixelStorage1DData[testCaseInstanceId()].storage,
PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array};
Containers::Array<char> 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<UnsignedByte>(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
PixelStorage1DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
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<Extensions::EXT::texture_array>())
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<Extensions::EXT::texture_array>())
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<UnsignedByte>(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
PixelStorage1DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
@ -1270,9 +1277,9 @@ void TextureArrayGLTest::subImage1DQueryView() {
MAGNUM_VERIFY_NO_GL_ERROR();
Containers::Array<char> data{PixelStorage1DData[testCaseInstanceId()].offset + 2*2*4};
MutableImageView2D image{PixelStorage1DData[testCaseInstanceId()].storage,
PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, data, ImageFlag2D::Array};
Containers::Array<char> 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<UnsignedByte>(image.data()).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
PixelStorage1DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
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<UnsignedByte>(imageData).exceptPrefix(PixelStorage1DData[testCaseInstanceId()].offset),
PixelStorage1DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
@ -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<UnsignedByte>(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
PixelStorage2DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
@ -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<UnsignedByte>(imageData).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
PixelStorage2DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
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<char> data{PixelStorage2DData[testCaseInstanceId()].offset + 2*2*2*4};
MutableImageView3D image{PixelStorage2DData[testCaseInstanceId()].storage,
PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, data};
Containers::Array<char> 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<UnsignedByte>(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
PixelStorage2DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
@ -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<Extensions::EXT::texture_array>())
@ -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<Extensions::EXT::texture_array>())
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<UnsignedByte>(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
PixelStorage2DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
@ -1571,9 +1586,9 @@ void TextureArrayGLTest::subImage2DQueryView() {
MAGNUM_VERIFY_NO_GL_ERROR();
Containers::Array<char> data{PixelStorage2DData[testCaseInstanceId()].offset + 2*2*2*4};
MutableImageView3D image{PixelStorage2DData[testCaseInstanceId()].storage,
PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, data, ImageFlag3D::Array};
Containers::Array<char> 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<UnsignedByte>(image.data()).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
PixelStorage2DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
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<UnsignedByte>(imageData).exceptPrefix(PixelStorage2DData[testCaseInstanceId()].offset),
PixelStorage2DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
@ -1633,35 +1650,36 @@ void TextureArrayGLTest::compressedImage2D() {
#endif
#ifndef MAGNUM_TARGET_GLES
if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
CompressedPixelStorage2DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
@ -1679,63 +1697,64 @@ void TextureArrayGLTest::compressedImage2DBuffer() {
#endif
#ifndef MAGNUM_TARGET_GLES
if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<UnsignedByte>(imageData).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
CompressedPixelStorage2DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
CORRADE_SKIP(Extensions::EXT::texture_array::string() << "is not supported.");
if(!Context::current().isExtensionSupported<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<char> data{CompressedPixelStorage2DData[testCaseInstanceId()].offset + 2*16};
MutableCompressedImageView3D image{CompressedPixelStorage2DData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, data};
Containers::Array<char> 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<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
CompressedPixelStorage2DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
@ -1795,7 +1815,7 @@ void TextureArrayGLTest::compressedSubImage2D() {
#endif
#ifndef MAGNUM_TARGET_GLES
if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<UnsignedByte>(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<Extensions::EXT::texture_array>())
@ -1848,7 +1869,7 @@ void TextureArrayGLTest::compressedSubImage2DBuffer() {
#endif
#ifndef MAGNUM_TARGET_GLES
if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
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<Extensions::EXT::texture_array>())
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<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
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<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
CompressedPixelStorage2DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
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<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
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<char> data{CompressedPixelStorage2DData[testCaseInstanceId()].offset + 2*16};
MutableCompressedImageView3D image{CompressedPixelStorage2DData[testCaseInstanceId()].storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, data, ImageFlag3D::Array};
Containers::Array<char> 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<UnsignedByte>(image.data()).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
CompressedPixelStorage2DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(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<Extensions::EXT::texture_array>())
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<Extensions::EXT::texture_compression_s3tc>())
CORRADE_SKIP(Extensions::EXT::texture_compression_s3tc::string() << "is not supported.");
if(CompressedPixelStorage2DData[testCaseInstanceId()].storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
if(data.storage != CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
CORRADE_SKIP(Extensions::ARB::compressed_texture_pixel_storage::string() << "is not supported.");
if(CompressedPixelStorage2DData[testCaseInstanceId()].storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
if(data.storage == CompressedPixelStorage{} && !Context::current().isExtensionSupported<Extensions::ARB::internalformat_query2>())
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<UnsignedByte>(imageData).exceptPrefix(CompressedPixelStorage2DData[testCaseInstanceId()].offset),
CompressedPixelStorage2DData[testCaseInstanceId()].data,
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(imageData).exceptPrefix(data.offset),
data.data,
TestSuite::Compare::Container);
}

506
src/Magnum/GL/Test/TextureGLTest.cpp
View File

File diff suppressed because it is too large Load Diff
Write Preview
Loading…
Cancel
Save