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

Test: create fake pointer values from size_t, not int. 

Should fix the remaining MSVC C4312 warnings.
pull/638/head
Vladimír Vondruš 2 years ago
parent
4435877cf1
commit
8bd42f5a3b
20 changed files with 204 additions and 204 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. 16
      src/Magnum/DebugTools/Test/CompareMaterialTest.cpp
  2. 24
      src/Magnum/MaterialTools/Test/CopyTest.cpp
  3. 4
      src/Magnum/SceneTools/Test/SceneConverterImplementationTest.cpp
  4. 6
      src/Magnum/Text/Test/AbstractGlyphCacheTest.cpp
  5. 4
      src/Magnum/Text/Test/AbstractShaperTest.cpp
  6. 4
      src/Magnum/Trade/Test/AbstractImporterTest.cpp
  7. 140
      src/Magnum/Trade/Test/AbstractSceneConverterTest.cpp
  8. 4
      src/Magnum/Trade/Test/MeshDataTest.cpp
  9. 20
      src/Magnum/Trade/Test/SceneDataTest.cpp
  10. 4
      src/Magnum/Vk/Test/BufferTest.cpp
  11. 26
      src/Magnum/Vk/Test/DescriptorSetLayoutTest.cpp
  12. 44
      src/Magnum/Vk/Test/FramebufferTest.cpp
  13. 12
      src/Magnum/Vk/Test/ImageTest.cpp
  14. 2
      src/Magnum/Vk/Test/ImageViewTest.cpp
  15. 26
      src/Magnum/Vk/Test/MeshTest.cpp
  16. 12
      src/Magnum/Vk/Test/PipelineLayoutTest.cpp
  17. 26
      src/Magnum/Vk/Test/PipelineTest.cpp
  18. 14
      src/Magnum/Vk/Test/QueueTest.cpp
  19. 8
      src/Magnum/Vk/Test/RenderPassTest.cpp
  20. 12
      src/Magnum/Vk/Test/ShaderSetTest.cpp

16
src/Magnum/DebugTools/Test/CompareMaterialTest.cpp
Unescape View File

@ -208,12 +208,12 @@ const struct {
" - OcclusionTexture @ UnsignedInt: 3\n"},
{"different attribute types",
Trade::MaterialData{{}, {
{"pointer", reinterpret_cast<void*>(0xdead)},
{"pointer", reinterpret_cast<void*>(std::size_t{0xdead})},
{"integer", 5u},
{"scale", 0.5f},
}},
Trade::MaterialData{{}, {
{"pointer", reinterpret_cast<const void*>(0xdead)},
{"pointer", reinterpret_cast<const void*>(std::size_t{0xdead})},
{"integer", 5},
{"scale", "small"},
}},
@ -239,16 +239,16 @@ const struct {
{Trade::MaterialAttribute::NormalTexture, 5u},
{Trade::MaterialAttribute::NormalTextureSwizzle, Trade::MaterialTextureSwizzle::RGB},
{"buffer", Containers::ArrayView<const void>{"\x56\x78\x22"}},
{"pointer", reinterpret_cast<const void*>(0xbeef)},
{"pointerMutable", reinterpret_cast<void*>(0xdead)},
{"pointer", reinterpret_cast<const void*>(std::size_t{0xbeef})},
{"pointerMutable", reinterpret_cast<void*>(std::size_t{0xdead})},
}},
Trade::MaterialData{{}, {
{Trade::MaterialAttribute::Metalness, 5.5f},
{Trade::MaterialAttribute::NormalTexture, 5u},
{Trade::MaterialAttribute::NormalTextureSwizzle, Trade::MaterialTextureSwizzle::RG},
{"buffer", Containers::ArrayView<const void>{"\x56\x78\x22"}},
{"pointer", reinterpret_cast<const void*>(0xbeef)},
{"pointerMutable", reinterpret_cast<void*>(0xdead)},
{"pointer", reinterpret_cast<const void*>(std::size_t{0xbeef})},
{"pointerMutable", reinterpret_cast<void*>(std::size_t{0xdead})},
}},
"Materials a and b have different attribute values. Actual (+) vs expected (-):\n"
" Base layer:\n"
@ -276,13 +276,13 @@ const struct {
{Trade::MaterialAttribute::NormalTexture, 5u},
{Trade::MaterialAttribute::NormalTextureScale, 0.5f},
{Trade::MaterialAttribute::OcclusionTexture, 3u},
{"texturePointer", reinterpret_cast<void*>(0xdead)},
{"texturePointer", reinterpret_cast<void*>(std::size_t{0xdead})},
}, {3, 5}},
Trade::MaterialData{{}, {
{Trade::MaterialAttribute::DoubleSided, false},
{Trade::MaterialAttribute::NormalTexture, 5u},
{Trade::MaterialAttribute::OcclusionTexture, 3u},
{"texturePointer", reinterpret_cast<const void*>(0xdead)},
{"texturePointer", reinterpret_cast<const void*>(std::size_t{0xdead})},
{Trade::MaterialAttribute::NormalTextureLayer, 2u},
}, {2, 4, 5}},
"Materials a and b have different layers. Actual (+) vs expected (-):\n"

24
src/Magnum/MaterialTools/Test/CopyTest.cpp
Unescape View File

@ -64,11 +64,11 @@ void CopyTest::singleLayer() {
{Trade::MaterialAttribute::AlphaBlend, true},
{Trade::MaterialAttribute::BaseColor, 0xff3366ff_rgbaf},
{"baseColorTextureName", "yesss.png"},
}, {3}, reinterpret_cast<void*>(0xdeadbeef)};
}, {3}, reinterpret_cast<void*>(std::size_t{0xdeadbeef})};
Trade::MaterialData copy = MaterialTools::copy(material);
CORRADE_COMPARE(copy.types(), Trade::MaterialType::PbrMetallicRoughness);
CORRADE_COMPARE(copy.importerState(), reinterpret_cast<void*>(0xdeadbeef));
CORRADE_COMPARE(copy.importerState(), reinterpret_cast<void*>(std::size_t{0xdeadbeef}));
CORRADE_COMPARE(copy.layerDataFlags(), Trade::DataFlag::Owned|Trade::DataFlag::Mutable);
CORRADE_COMPARE(copy.layerCount(), 1);
@ -93,11 +93,11 @@ void CopyTest::singleLayerNoLayerData() {
{Trade::MaterialAttribute::AlphaBlend, true},
{Trade::MaterialAttribute::BaseColor, 0xff3366ff_rgbaf},
{"baseColorTextureName", "yesss.png"},
}, reinterpret_cast<void*>(0xdeadbeef)};
}, reinterpret_cast<void*>(std::size_t{0xdeadbeef})};
Trade::MaterialData copy = MaterialTools::copy(material);
CORRADE_COMPARE(copy.types(), Trade::MaterialType::PbrMetallicRoughness);
CORRADE_COMPARE(copy.importerState(), reinterpret_cast<void*>(0xdeadbeef));
CORRADE_COMPARE(copy.importerState(), reinterpret_cast<void*>(std::size_t{0xdeadbeef}));
CORRADE_COMPARE(copy.layerDataFlags(), Trade::DataFlag::Owned|Trade::DataFlag::Mutable);
CORRADE_COMPARE(copy.layerCount(), 1);
@ -116,11 +116,11 @@ void CopyTest::multipleLayers() {
{Trade::MaterialAttribute::AlphaBlend, true},
{Trade::MaterialAttribute::BaseColor, 0xff3366ff_rgbaf},
{"baseColorTextureName", "yesss.png"},
}, {2, 3}, reinterpret_cast<void*>(0xdeadbeef)};
}, {2, 3}, reinterpret_cast<void*>(std::size_t{0xdeadbeef})};
Trade::MaterialData copy = MaterialTools::copy(material);
CORRADE_COMPARE(copy.types(), Trade::MaterialType::PbrMetallicRoughness);
CORRADE_COMPARE(copy.importerState(), reinterpret_cast<void*>(0xdeadbeef));
CORRADE_COMPARE(copy.importerState(), reinterpret_cast<void*>(std::size_t{0xdeadbeef}));
CORRADE_COMPARE(copy.layerDataFlags(), Trade::DataFlag::Owned|Trade::DataFlag::Mutable);
CORRADE_COMPARE(copy.layerCount(), 2);
@ -150,9 +150,9 @@ void CopyTest::rvalueNotOwned() {
Trade::MaterialData copy = MaterialTools::copy(Trade::MaterialData{Trade::MaterialType::PbrMetallicRoughness,
Trade::DataFlag::Mutable, attributes,
Trade::DataFlag::Mutable|Trade::DataFlag::ExternallyOwned, layers,
reinterpret_cast<void*>(0xdeadbeef)});
reinterpret_cast<void*>(std::size_t{0xdeadbeef})});
CORRADE_COMPARE(copy.types(), Trade::MaterialType::PbrMetallicRoughness);
CORRADE_COMPARE(copy.importerState(), reinterpret_cast<void*>(0xdeadbeef));
CORRADE_COMPARE(copy.importerState(), reinterpret_cast<void*>(std::size_t{0xdeadbeef}));
CORRADE_COMPARE(copy.layerDataFlags(), Trade::DataFlag::Owned|Trade::DataFlag::Mutable);
CORRADE_COMPARE(copy.layerCount(), 2);
@ -175,9 +175,9 @@ void CopyTest::rvalueOwnedAttributesLayers() {
const void* originalAttributes = attributes.data();
const void* originalLayers = layers.data();
Trade::MaterialData copy = MaterialTools::copy(Trade::MaterialData{Trade::MaterialType::PbrMetallicRoughness, Utility::move(attributes), Utility::move(layers), reinterpret_cast<void*>(0xdeadbeef)});
Trade::MaterialData copy = MaterialTools::copy(Trade::MaterialData{Trade::MaterialType::PbrMetallicRoughness, Utility::move(attributes), Utility::move(layers), reinterpret_cast<void*>(std::size_t{0xdeadbeef})});
CORRADE_COMPARE(copy.types(), Trade::MaterialType::PbrMetallicRoughness);
CORRADE_COMPARE(copy.importerState(), reinterpret_cast<void*>(0xdeadbeef));
CORRADE_COMPARE(copy.importerState(), reinterpret_cast<void*>(std::size_t{0xdeadbeef}));
CORRADE_COMPARE(copy.layerDataFlags(), Trade::DataFlag::Owned|Trade::DataFlag::Mutable);
CORRADE_COMPARE(copy.layerData().data(), originalLayers);
@ -201,9 +201,9 @@ void CopyTest::rvalueOwnedAttributesNoLayerData() {
Containers::Array<UnsignedInt> layers{InPlaceInit, {2, 3}};
const void* originalAttributes = attributes.data();
Trade::MaterialData copy = MaterialTools::copy(Trade::MaterialData{Trade::MaterialType::PbrMetallicRoughness, Utility::move(attributes), reinterpret_cast<void*>(0xdeadbeef)});
Trade::MaterialData copy = MaterialTools::copy(Trade::MaterialData{Trade::MaterialType::PbrMetallicRoughness, Utility::move(attributes), reinterpret_cast<void*>(std::size_t{0xdeadbeef})});
CORRADE_COMPARE(copy.types(), Trade::MaterialType::PbrMetallicRoughness);
CORRADE_COMPARE(copy.importerState(), reinterpret_cast<void*>(0xdeadbeef));
CORRADE_COMPARE(copy.importerState(), reinterpret_cast<void*>(std::size_t{0xdeadbeef}));
CORRADE_COMPARE(copy.layerDataFlags(), Trade::DataFlag::Owned|Trade::DataFlag::Mutable);
CORRADE_COMPARE(copy.layerCount(), 1);

4
src/Magnum/SceneTools/Test/SceneConverterImplementationTest.cpp
Unescape View File

@ -627,8 +627,8 @@ void SceneConverterImplementationTest::infoMaterials() {
{"notAColour4", Vector4{0.1f, 0.2f, 0.3f, 0.4f}},
{"notAColour3", Vector3{0.2f, 0.3f, 0.4f}},
{"data", Containers::ArrayView<const void>{"0123456789abcdef", 17}},
{"deadBeef", reinterpret_cast<const void*>(0xdeadbeef)},
{"undeadBeef", reinterpret_cast<void*>(0xbeefbeef)},
{"deadBeef", reinterpret_cast<const void*>(std::size_t(0xdeadbeef))},
{"undeadBeef", reinterpret_cast<void*>(std::size_t(0xbeefbeef))},
}};
/* Second has layers, custom layers, unnamed layers and a name */

6
src/Magnum/Text/Test/AbstractGlyphCacheTest.cpp
Unescape View File

@ -612,7 +612,7 @@ void AbstractGlyphCacheTest::setInvalidGlyph2DNot2D() {
void AbstractGlyphCacheTest::addFont() {
DummyGlyphCache cache{PixelFormat::R32F, {1024, 512}};
const AbstractFont* font = reinterpret_cast<const AbstractFont*>(0xdeadbeef);
const AbstractFont* font = reinterpret_cast<const AbstractFont*>(std::size_t{0xdeadbeef});
CORRADE_COMPARE(cache.findFont(*font), Containers::NullOpt);
CORRADE_COMPARE(cache.addFont(35, nullptr), 0);
@ -636,7 +636,7 @@ void AbstractGlyphCacheTest::addFontDuplicatePointer() {
cache.addFont(7, nullptr);
const AbstractFont* font = reinterpret_cast<const AbstractFont*>(0xdeadbeef);
const AbstractFont* font = reinterpret_cast<const AbstractFont*>(std::size_t{0xdeadbeef});
cache.addFont(35, font);
std::ostringstream out;
@ -649,7 +649,7 @@ void AbstractGlyphCacheTest::fontOutOfRange() {
CORRADE_SKIP_IF_NO_ASSERT();
DummyGlyphCache cache{PixelFormat::R32F, {1024, 512}};
const AbstractFont* font = reinterpret_cast<const AbstractFont*>(0xdeadbeef);
const AbstractFont* font = reinterpret_cast<const AbstractFont*>(std::size_t{0xdeadbeef});
cache.addFont(35, nullptr);
cache.addFont(12, font);
CORRADE_COMPARE(cache.fontCount(), 2);

4
src/Magnum/Text/Test/AbstractShaperTest.cpp
Unescape View File

@ -176,7 +176,7 @@ void AbstractShaperTest::featureRangeConstructBeginEnd() {
CORRADE_COMPARE(cc.end(), 26);
}
AbstractFont& FakeFont = *reinterpret_cast<AbstractFont*>(0xdeadbeef);
AbstractFont& FakeFont = *reinterpret_cast<AbstractFont*>(std::size_t{0xdeadbeef});
struct DummyShaper: AbstractShaper {
using AbstractShaper::AbstractShaper;
@ -210,7 +210,7 @@ void AbstractShaperTest::constructMove() {
CORRADE_COMPARE(&b.font(), &FakeFont);
CORRADE_COMPARE(b.glyphCount(), 0);
DummyShaper c{*reinterpret_cast<AbstractFont*>(0xcafebabe)};
DummyShaper c{*reinterpret_cast<AbstractFont*>(std::size_t{0xcafebabe})};
c = Utility::move(b);
CORRADE_COMPARE(&b.font(), &FakeFont);
CORRADE_COMPARE(b.glyphCount(), 0);

4
src/Magnum/Trade/Test/AbstractImporterTest.cpp
Unescape View File

@ -1026,7 +1026,7 @@ void AbstractImporterTest::openState() {
void doClose() override { _opened = false; }
void doOpenState(const void* state, Containers::StringView filePath) override {
CORRADE_COMPARE(state, reinterpret_cast<const void*>(0xbadcafe));
CORRADE_COMPARE(state, reinterpret_cast<const void*>(std::size_t{0xbadcafe}));
CORRADE_COMPARE(filePath, "yello/foo/");
_opened = true;
}
@ -1035,7 +1035,7 @@ void AbstractImporterTest::openState() {
} importer;
CORRADE_VERIFY(!importer.isOpened());
CORRADE_VERIFY(importer.openState(reinterpret_cast<const void*>(0xbadcafe), "yello/foo/"));
CORRADE_VERIFY(importer.openState(reinterpret_cast<const void*>(std::size_t{0xbadcafe}), "yello/foo/"));
CORRADE_VERIFY(importer.isOpened());
importer.close();

140
src/Magnum/Trade/Test/AbstractSceneConverterTest.cpp
Unescape View File

@ -1861,7 +1861,7 @@ void AbstractSceneConverterTest::beginEnd() {
bool doIsOpened() const override { return true; }
const void* doImporterState() const override {
return reinterpret_cast<const void*>(0xdeadbeef);
return reinterpret_cast<const void*>(std::size_t{0xdeadbeef});
}
};
@ -1879,7 +1879,7 @@ void AbstractSceneConverterTest::beginEnd() {
Containers::Pointer<AbstractImporter> out = converter.end();
CORRADE_VERIFY(out);
CORRADE_COMPARE(out->importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(out->importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
CORRADE_VERIFY(converter.endCalled);
CORRADE_VERIFY(!converter.isConverting());
}
@ -2775,7 +2775,7 @@ void AbstractSceneConverterTest::addScene() {
CORRADE_COMPARE(id, sceneCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(scene.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(scene.importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -2786,10 +2786,10 @@ void AbstractSceneConverterTest::addScene() {
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.sceneCount(), 0);
CORRADE_COMPARE(converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.sceneCount(), 1);
CORRADE_COMPARE(converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 1);
CORRADE_COMPARE(converter.sceneCount(), 2);
}
@ -3041,7 +3041,7 @@ void AbstractSceneConverterTest::addAnimation() {
CORRADE_COMPARE(id, animationCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(animation.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(animation.importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -3052,10 +3052,10 @@ void AbstractSceneConverterTest::addAnimation() {
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.animationCount(), 0);
CORRADE_COMPARE(converter.add(AnimationData{nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(AnimationData{nullptr, nullptr, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.animationCount(), 1);
CORRADE_COMPARE(converter.add(AnimationData{nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.add(AnimationData{nullptr, nullptr, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 1);
CORRADE_COMPARE(converter.animationCount(), 2);
}
@ -3185,7 +3185,7 @@ void AbstractSceneConverterTest::addLight() {
CORRADE_COMPARE(id, lightCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(light.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(light.importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -3196,10 +3196,10 @@ void AbstractSceneConverterTest::addLight() {
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.lightCount(), 0);
CORRADE_COMPARE(converter.add(LightData{LightType::Point, {}, 0.0f, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(LightData{LightType::Point, {}, 0.0f, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.lightCount(), 1);
CORRADE_COMPARE(converter.add(LightData{LightType::Point, {}, 0.0f, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.add(LightData{LightType::Point, {}, 0.0f, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 1);
CORRADE_COMPARE(converter.lightCount(), 2);
}
@ -3268,7 +3268,7 @@ void AbstractSceneConverterTest::addCamera() {
CORRADE_COMPARE(id, cameraCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(camera.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(camera.importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -3279,10 +3279,10 @@ void AbstractSceneConverterTest::addCamera() {
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.cameraCount(), 0);
CORRADE_COMPARE(converter.add(CameraData{CameraType::Orthographic3D, {}, 0.0f, 1.0f, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(CameraData{CameraType::Orthographic3D, {}, 0.0f, 1.0f, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.cameraCount(), 1);
CORRADE_COMPARE(converter.add(CameraData{CameraType::Orthographic3D, {}, 0.0f, 1.0f, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.add(CameraData{CameraType::Orthographic3D, {}, 0.0f, 1.0f, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 1);
CORRADE_COMPARE(converter.cameraCount(), 2);
}
@ -3351,7 +3351,7 @@ void AbstractSceneConverterTest::addSkin2D() {
CORRADE_COMPARE(id, skin2DCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(skin.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(skin.importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -3362,10 +3362,10 @@ void AbstractSceneConverterTest::addSkin2D() {
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.skin2DCount(), 0);
CORRADE_COMPARE(converter.add(SkinData2D{nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(SkinData2D{nullptr, nullptr, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.skin2DCount(), 1);
CORRADE_COMPARE(converter.add(SkinData2D{nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.add(SkinData2D{nullptr, nullptr, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 1);
CORRADE_COMPARE(converter.skin2DCount(), 2);
}
@ -3434,7 +3434,7 @@ void AbstractSceneConverterTest::addSkin3D() {
CORRADE_COMPARE(id, skin3DCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(skin.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(skin.importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -3445,10 +3445,10 @@ void AbstractSceneConverterTest::addSkin3D() {
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.skin3DCount(), 0);
CORRADE_COMPARE(converter.add(SkinData3D{nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(SkinData3D{nullptr, nullptr, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.skin3DCount(), 1);
CORRADE_COMPARE(converter.add(SkinData3D{nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.add(SkinData3D{nullptr, nullptr, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 1);
CORRADE_COMPARE(converter.skin3DCount(), 2);
}
@ -3517,7 +3517,7 @@ void AbstractSceneConverterTest::addMesh() {
CORRADE_COMPARE(id, meshCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(mesh.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(mesh.importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -3528,10 +3528,10 @@ void AbstractSceneConverterTest::addMesh() {
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.meshCount(), 0);
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 0, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 0, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.meshCount(), 1);
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 0, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 0, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 1);
CORRADE_COMPARE(converter.meshCount(), 2);
}
@ -4070,7 +4070,7 @@ void AbstractSceneConverterTest::addMeshLevels() {
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(meshLevels.size(), 3);
CORRADE_COMPARE(meshLevels[1].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(meshLevels[1].importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -4083,14 +4083,14 @@ void AbstractSceneConverterTest::addMeshLevels() {
CORRADE_COMPARE(converter.meshCount(), 0);
CORRADE_COMPARE(converter.add({
MeshData{MeshPrimitive::Lines, 0},
MeshData{MeshPrimitive::Triangles, 3, reinterpret_cast<const void*>(0xdeadbeef)},
MeshData{MeshPrimitive::Triangles, 3, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})},
MeshData{MeshPrimitive::Faces, 0},
}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.meshCount(), 1);
CORRADE_COMPARE(converter.add({
MeshData{MeshPrimitive::Faces, 2},
MeshData{MeshPrimitive::Meshlets, 1, reinterpret_cast<const void*>(0xdeadbeef)},
MeshData{MeshPrimitive::Meshlets, 1, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})},
MeshData{MeshPrimitive::Points, 0},
}, "hello"), 1);
CORRADE_COMPARE(converter.meshCount(), 2);
@ -4188,7 +4188,7 @@ void AbstractSceneConverterTest::addMeshThroughLevels() {
bool doAdd(UnsignedInt, const Containers::Iterable<const MeshData>& meshLevels, Containers::StringView name) override {
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(meshLevels.size(), 1);
CORRADE_COMPARE(meshLevels[0].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(meshLevels[0].importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -4198,7 +4198,7 @@ void AbstractSceneConverterTest::addMeshThroughLevels() {
} converter;
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 0, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 0, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.meshCount(), 1);
}
@ -4287,7 +4287,7 @@ void AbstractSceneConverterTest::addMaterial() {
CORRADE_COMPARE(id, materialCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(material.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(material.importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -4298,10 +4298,10 @@ void AbstractSceneConverterTest::addMaterial() {
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.materialCount(), 0);
CORRADE_COMPARE(converter.add(MaterialData{{}, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(MaterialData{{}, nullptr, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.materialCount(), 1);
CORRADE_COMPARE(converter.add(MaterialData{{}, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.add(MaterialData{{}, nullptr, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 1);
CORRADE_COMPARE(converter.materialCount(), 2);
}
@ -4370,7 +4370,7 @@ void AbstractSceneConverterTest::addTexture() {
CORRADE_COMPARE(id, textureCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(texture.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(texture.importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -4381,10 +4381,10 @@ void AbstractSceneConverterTest::addTexture() {
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.textureCount(), 0);
CORRADE_COMPARE(converter.add(TextureData{{}, {}, {}, {}, {}, 0, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(TextureData{{}, {}, {}, {}, {}, 0, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.textureCount(), 1);
CORRADE_COMPARE(converter.add(TextureData{{}, {}, {}, {}, {}, 0, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.add(TextureData{{}, {}, {}, {}, {}, 0, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 1);
CORRADE_COMPARE(converter.textureCount(), 2);
}
@ -4453,7 +4453,7 @@ void AbstractSceneConverterTest::addImage1D() {
CORRADE_COMPARE(id, image1DCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(image.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(image.importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -4466,10 +4466,10 @@ void AbstractSceneConverterTest::addImage1D() {
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.image1DCount(), 0);
CORRADE_COMPARE(converter.add(ImageData1D{PixelFormat::RGBA8Unorm, 1, {}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(ImageData1D{PixelFormat::RGBA8Unorm, 1, {}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image1DCount(), 1);
CORRADE_COMPARE(converter.add(ImageData1D{PixelFormat::RGBA8Unorm, 1, {}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.add(ImageData1D{PixelFormat::RGBA8Unorm, 1, {}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 1);
CORRADE_COMPARE(converter.image1DCount(), 2);
}
@ -4639,7 +4639,7 @@ void AbstractSceneConverterTest::addImage2D() {
CORRADE_COMPARE(id, image2DCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(image.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(image.importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -4652,10 +4652,10 @@ void AbstractSceneConverterTest::addImage2D() {
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.image2DCount(), 0);
CORRADE_COMPARE(converter.add(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, {}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, {}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image2DCount(), 1);
CORRADE_COMPARE(converter.add(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, {}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.add(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, {}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 1);
CORRADE_COMPARE(converter.image2DCount(), 2);
}
@ -4849,7 +4849,7 @@ void AbstractSceneConverterTest::addImage3D() {
CORRADE_COMPARE(id, image3DCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(image.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(image.importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -4862,10 +4862,10 @@ void AbstractSceneConverterTest::addImage3D() {
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.image3DCount(), 0);
CORRADE_COMPARE(converter.add(ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, {}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, {}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image3DCount(), 1);
CORRADE_COMPARE(converter.add(ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, {}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.add(ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, {}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 1);
CORRADE_COMPARE(converter.image3DCount(), 2);
}
@ -5039,7 +5039,7 @@ void AbstractSceneConverterTest::addImageLevels1D() {
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 3);
CORRADE_COMPARE(imageLevels[1].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(imageLevels[1].importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -5055,14 +5055,14 @@ void AbstractSceneConverterTest::addImageLevels1D() {
CORRADE_COMPARE(converter.add({
/* Arbitrary dimensions should be fine */
ImageData1D{PixelFormat::RGBA8Unorm, 4, DataFlags{}, imageData},
ImageData1D{PixelFormat::RGBA8Unorm, 2, DataFlags{}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(0xdeadbeef)},
ImageData1D{PixelFormat::RGBA8Unorm, 2, DataFlags{}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})},
ImageData1D{PixelFormat::RGBA8Unorm, 3, DataFlags{}, imageData}
}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image1DCount(), 1);
CORRADE_COMPARE(converter.add({
ImageData1D{PixelFormat::RGBA8Unorm, 2, DataFlags{}, imageData},
ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(0xdeadbeef)},
ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})},
ImageData1D{PixelFormat::RGBA8Unorm, 4, DataFlags{}, imageData}
}, "hello"), 1);
CORRADE_COMPARE(converter.image1DCount(), 2);
@ -5257,7 +5257,7 @@ void AbstractSceneConverterTest::addImageLevels2D() {
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 3);
CORRADE_COMPARE(imageLevels[1].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(imageLevels[1].importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -5273,14 +5273,14 @@ void AbstractSceneConverterTest::addImageLevels2D() {
CORRADE_COMPARE(converter.add({
/* Arbitrary dimensions should be fine */
ImageData2D{PixelFormat::RGBA8Unorm, {4, 1}, DataFlags{}, imageData},
ImageData2D{PixelFormat::RGBA8Unorm, {2, 2}, DataFlags{}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(0xdeadbeef)},
ImageData2D{PixelFormat::RGBA8Unorm, {2, 2}, DataFlags{}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})},
ImageData2D{PixelFormat::RGBA8Unorm, {1, 3}, DataFlags{}, imageData}
}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image2DCount(), 1);
CORRADE_COMPARE(converter.add({
ImageData2D{PixelFormat::RGBA8Unorm, {2, 2}, DataFlags{}, imageData},
ImageData2D{PixelFormat::RGBA8Unorm, {1, 3}, DataFlags{}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(0xdeadbeef)},
ImageData2D{PixelFormat::RGBA8Unorm, {1, 3}, DataFlags{}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})},
ImageData2D{PixelFormat::RGBA8Unorm, {4, 1}, DataFlags{}, imageData}
}, "hello"), 1);
CORRADE_COMPARE(converter.image2DCount(), 2);
@ -5664,7 +5664,7 @@ void AbstractSceneConverterTest::addImageLevels3D() {
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 3);
CORRADE_COMPARE(imageLevels[1].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(imageLevels[1].importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -5680,14 +5680,14 @@ void AbstractSceneConverterTest::addImageLevels3D() {
CORRADE_COMPARE(converter.add({
/* Arbitrary dimensions should be fine */
ImageData3D{PixelFormat::RGBA8Unorm, {4, 1, 1}, DataFlags{}, imageData},
ImageData3D{PixelFormat::RGBA8Unorm, {2, 2, 1}, DataFlags{}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(0xdeadbeef)},
ImageData3D{PixelFormat::RGBA8Unorm, {2, 2, 1}, DataFlags{}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})},
ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 3}, DataFlags{}, imageData}
}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image3DCount(), 1);
CORRADE_COMPARE(converter.add({
ImageData3D{PixelFormat::RGBA8Unorm, {2, 1, 2}, DataFlags{}, imageData},
ImageData3D{PixelFormat::RGBA8Unorm, {1, 3, 1}, DataFlags{}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(0xdeadbeef)},
ImageData3D{PixelFormat::RGBA8Unorm, {1, 3, 1}, DataFlags{}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})},
ImageData3D{PixelFormat::RGBA8Unorm, {1, 4, 1}, DataFlags{}, imageData}
}, "hello"), 1);
CORRADE_COMPARE(converter.image3DCount(), 2);
@ -5878,7 +5878,7 @@ void AbstractSceneConverterTest::addImage1DThroughLevels() {
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData1D>& imageLevels, Containers::StringView name) override {
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 1);
CORRADE_COMPARE(imageLevels[0].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(imageLevels[0].importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -5890,7 +5890,7 @@ void AbstractSceneConverterTest::addImage1DThroughLevels() {
const char imageData[4]{};
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.add(ImageData1D{PixelFormat::RGBA8Unorm, 1, {}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(ImageData1D{PixelFormat::RGBA8Unorm, 1, {}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image1DCount(), 1);
}
@ -5908,7 +5908,7 @@ void AbstractSceneConverterTest::addImage2DThroughLevels() {
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData2D>& imageLevels, Containers::StringView name) override {
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 1);
CORRADE_COMPARE(imageLevels[0].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(imageLevels[0].importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -5920,7 +5920,7 @@ void AbstractSceneConverterTest::addImage2DThroughLevels() {
const char imageData[4]{};
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.add(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, {}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, {}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image2DCount(), 1);
}
@ -5938,7 +5938,7 @@ void AbstractSceneConverterTest::addImage3DThroughLevels() {
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData3D>& imageLevels, Containers::StringView name) override {
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 1);
CORRADE_COMPARE(imageLevels[0].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_COMPARE(imageLevels[0].importerState(), reinterpret_cast<const void*>(std::size_t{0xdeadbeef}));
addCalled = true;
return true;
@ -5950,7 +5950,7 @@ void AbstractSceneConverterTest::addImage3DThroughLevels() {
const char imageData[4]{};
CORRADE_VERIFY(converter.begin());
CORRADE_COMPARE(converter.add(ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, {}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_COMPARE(converter.add(ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, {}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(std::size_t{0xdeadbeef})}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image3DCount(), 1);
}
@ -5994,7 +5994,7 @@ void AbstractSceneConverterTest::addImporterContents() {
return Utility::format("Scene {}", id);
}
Containers::Optional<SceneData> doScene(UnsignedInt id) override {
return SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {}, reinterpret_cast<const void*>(0x5ce00000 + id)};
return SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {}, reinterpret_cast<const void*>(std::size_t{0x5ce00000 + id})};
}
UnsignedInt doAnimationCount() const override {
@ -6009,7 +6009,7 @@ void AbstractSceneConverterTest::addImporterContents() {
return Utility::format("Animation {}", id);
}
Containers::Optional<AnimationData> doAnimation(UnsignedInt id) override {
return AnimationData{nullptr, {}, reinterpret_cast<const void*>(0x40100000 + id)};
return AnimationData{nullptr, {}, reinterpret_cast<const void*>(std::size_t{0x40100000 + id})};
}
UnsignedInt doLightCount() const override {
@ -6024,7 +6024,7 @@ void AbstractSceneConverterTest::addImporterContents() {
return Utility::format("Light {}", id);
}
Containers::Optional<LightData> doLight(UnsignedInt id) override {
return LightData{LightType::Point, {}, {}, reinterpret_cast<const void*>(0x11600000 + id)};
return LightData{LightType::Point, {}, {}, reinterpret_cast<const void*>(std::size_t{0x11600000 + id})};
}
UnsignedInt doCameraCount() const override {
@ -6039,7 +6039,7 @@ void AbstractSceneConverterTest::addImporterContents() {
return Utility::format("Camera {}", id);
}
Containers::Optional<CameraData> doCamera(UnsignedInt id) override {
return CameraData{CameraType::Orthographic2D, {}, 0.0f, 0.0f, reinterpret_cast<const void*>(0xca0e0000 + id)};
return CameraData{CameraType::Orthographic2D, {}, 0.0f, 0.0f, reinterpret_cast<const void*>(std::size_t{0xca0e0000 + id})};
}
UnsignedInt doSkin2DCount() const override {
@ -6054,7 +6054,7 @@ void AbstractSceneConverterTest::addImporterContents() {
return Utility::format("2D skin {}", id);
}
Containers::Optional<SkinData2D> doSkin2D(UnsignedInt id) override {
return SkinData2D{{}, {}, reinterpret_cast<const void*>(0x50102d00 + id)};
return SkinData2D{{}, {}, reinterpret_cast<const void*>(std::size_t{0x50102d00 + id})};
}
UnsignedInt doSkin3DCount() const override {
@ -6069,7 +6069,7 @@ void AbstractSceneConverterTest::addImporterContents() {
return Utility::format("3D skin {}", id);
}
Containers::Optional<SkinData3D> doSkin3D(UnsignedInt id) override {
return SkinData3D{{}, {}, reinterpret_cast<const void*>(0x50103d00 + id)};
return SkinData3D{{}, {}, reinterpret_cast<const void*>(std::size_t{0x50103d00 + id})};
}
UnsignedInt doMeshCount() const override {
@ -6088,7 +6088,7 @@ void AbstractSceneConverterTest::addImporterContents() {
return Utility::format("Mesh {}", id);
}
Containers::Optional<MeshData> doMesh(UnsignedInt id, UnsignedInt level) override {
return MeshData{{}, 0, reinterpret_cast<const void*>(0x0e500000 + id + level*16)};
return MeshData{{}, 0, reinterpret_cast<const void*>(std::size_t{0x0e500000 + id + level*16})};
}
UnsignedInt doMaterialCount() const override {
@ -6103,7 +6103,7 @@ void AbstractSceneConverterTest::addImporterContents() {
return Utility::format("Material {}", id);
}
Containers::Optional<MaterialData> doMaterial(UnsignedInt id) override {
return MaterialData{{}, {}, reinterpret_cast<const void*>(0x0a7e0000 + id)};
return MaterialData{{}, {}, reinterpret_cast<const void*>(std::size_t{0x0a7e0000 + id})};
}
UnsignedInt doTextureCount() const override {
@ -6118,7 +6118,7 @@ void AbstractSceneConverterTest::addImporterContents() {
return Utility::format("Texture {}", id);
}
Containers::Optional<TextureData> doTexture(UnsignedInt id) override {
return TextureData{TextureType::Texture1D, SamplerFilter::Nearest, SamplerFilter::Nearest, SamplerMipmap::Nearest, SamplerWrapping::ClampToEdge, 0, reinterpret_cast<const void*>(0x7e070000 + id)};
return TextureData{TextureType::Texture1D, SamplerFilter::Nearest, SamplerFilter::Nearest, SamplerMipmap::Nearest, SamplerWrapping::ClampToEdge, 0, reinterpret_cast<const void*>(std::size_t{0x7e070000 + id})};
}
UnsignedInt doImage1DCount() const override {
@ -6137,7 +6137,7 @@ void AbstractSceneConverterTest::addImporterContents() {
return Utility::format("1D image {}", id);
}
Containers::Optional<ImageData1D> doImage1D(UnsignedInt id, UnsignedInt level) override {
return ImageData1D{PixelFormat::RGBA8Unorm, 1, {}, "yes", {}, reinterpret_cast<const void*>(0x10a91d00 + id + level*16)};
return ImageData1D{PixelFormat::RGBA8Unorm, 1, {}, "yes", {}, reinterpret_cast<const void*>(std::size_t{0x10a91d00 + id + level*16})};
}
UnsignedInt doImage2DCount() const override {
@ -6156,7 +6156,7 @@ void AbstractSceneConverterTest::addImporterContents() {
return Utility::format("2D image {}", id);
}
Containers::Optional<ImageData2D> doImage2D(UnsignedInt id, UnsignedInt level) override {
return ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, {}, "yes", {}, reinterpret_cast<const void*>(0x10a92d00 + id + level*16)};
return ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, {}, "yes", {}, reinterpret_cast<const void*>(std::size_t{0x10a92d00 + id + level*16})};
}
UnsignedInt doImage3DCount() const override {
@ -6175,7 +6175,7 @@ void AbstractSceneConverterTest::addImporterContents() {
return Utility::format("3D image {}", id);
}
Containers::Optional<ImageData3D> doImage3D(UnsignedInt id, UnsignedInt level) override {
return ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, {}, "yes", {}, reinterpret_cast<const void*>(0x10a93d00 + id + level*16)};
return ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, {}, "yes", {}, reinterpret_cast<const void*>(std::size_t{0x10a93d00 + id + level*16})};
}
SceneContents contents;

4
src/Magnum/Trade/Test/MeshDataTest.cpp
Unescape View File

@ -2782,7 +2782,7 @@ void MeshDataTest::constructAttributelessNotOwned() {
#ifndef CORRADE_TARGET_32BIT
void MeshDataTest::constructIndicesOver4GB() {
/* For some reason 2500 doesn't trigger an assertion, 3000 does */
Containers::ArrayView<UnsignedInt> indices{reinterpret_cast<UnsignedInt*>(0xdeadbeef), 3000ull*1000*1000};
Containers::ArrayView<UnsignedInt> indices{reinterpret_cast<UnsignedInt*>(std::size_t{0xdeadbeef}), 3000ull*1000*1000};
MeshData data{MeshPrimitive::Triangles,
{}, indices, MeshIndexData{indices}, 5};
@ -2792,7 +2792,7 @@ void MeshDataTest::constructIndicesOver4GB() {
void MeshDataTest::constructAttributeOver4GB() {
/* For some reason 2500 doesn't trigger an assertion, 3000 does */
Containers::ArrayView<UnsignedInt> vertices{reinterpret_cast<UnsignedInt*>(0xdeadbeef), 3000ull*1000*1000};
Containers::ArrayView<UnsignedInt> vertices{reinterpret_cast<UnsignedInt*>(std::size_t{0xdeadbeef}), 3000ull*1000*1000};
MeshData data{MeshPrimitive::Triangles, {}, vertices, {
MeshAttributeData{meshAttributeCustom(15), vertices}

20
src/Magnum/Trade/Test/SceneDataTest.cpp
Unescape View File

@ -3586,7 +3586,7 @@ void SceneDataTest::constructDeprecatedBoth2DAnd3D() {
#ifndef CORRADE_TARGET_32BIT
void SceneDataTest::constructMappingOver4GB() {
Containers::ArrayView<UnsignedInt> mappingData{reinterpret_cast<UnsignedInt*>(0xdeadbeef), 3000ull*1000*1000};
Containers::ArrayView<UnsignedInt> mappingData{reinterpret_cast<UnsignedInt*>(std::size_t{0xdeadbeef}), 3000ull*1000*1000};
Containers::StridedArrayView1D<UnsignedByte> fieldData{mappingData, reinterpret_cast<UnsignedByte*>(mappingData.data()), 3000ull*1000*1000, 0};
SceneData data{SceneMappingType::UnsignedInt, 1, {}, mappingData, {
@ -3597,7 +3597,7 @@ void SceneDataTest::constructMappingOver4GB() {
}
void SceneDataTest::constructFieldOver4GB() {
Containers::ArrayView<UnsignedInt> fieldData{reinterpret_cast<UnsignedInt*>(0xdeadbeef), 3000ull*1000*1000};
Containers::ArrayView<UnsignedInt> fieldData{reinterpret_cast<UnsignedInt*>(std::size_t{0xdeadbeef}), 3000ull*1000*1000};
Containers::StridedArrayView1D<UnsignedByte> mappingData{fieldData, reinterpret_cast<UnsignedByte*>(fieldData.data()), 3000ull*1000*1000, 0};
SceneData data{SceneMappingType::UnsignedByte, 1, {}, fieldData, {
@ -3773,11 +3773,11 @@ void SceneDataTest::constructBitFieldDataNotContained() {
const Containers::Array<char> data{reinterpret_cast<char*>(0xbadda9), 10, [](char*, std::size_t){}};
Containers::Array<char> sameDataButMovable{reinterpret_cast<char*>(0xbadda9), 10, [](char*, std::size_t){}};
Containers::ArrayView<UnsignedByte> mappingData{reinterpret_cast<UnsignedByte*>(0xbadda9), 10};
Containers::StridedBitArrayView1D dataOneByteOut{Containers::BitArrayView{reinterpret_cast<void*>(0xbaddaa), 0, 80}, 10, 8};
Containers::StridedBitArrayView1D dataTwoBitsOut{Containers::BitArrayView{reinterpret_cast<void*>(0xbadda9), 0, 90}, 10, 9};
Containers::StridedBitArrayView1D dataOneBitOffsetOut{Containers::BitArrayView{reinterpret_cast<void*>(0xbadda9), 4, 95}, 5, 19};
Containers::StridedBitArrayView1D dataOneBitOffsetBeforeOut{Containers::BitArrayView{reinterpret_cast<void*>(0xbadda8), 7, 80}, 10, 8};
Containers::BitArrayView dataOut{reinterpret_cast<void*>(0xdead), 7, 10};
Containers::StridedBitArrayView1D dataOneByteOut{Containers::BitArrayView{reinterpret_cast<void*>(std::size_t{0xbaddaa}), 0, 80}, 10, 8};
Containers::StridedBitArrayView1D dataTwoBitsOut{Containers::BitArrayView{reinterpret_cast<void*>(std::size_t{0xbadda9}), 0, 90}, 10, 9};
Containers::StridedBitArrayView1D dataOneBitOffsetOut{Containers::BitArrayView{reinterpret_cast<void*>(std::size_t{0xbadda9}), 4, 95}, 5, 19};
Containers::StridedBitArrayView1D dataOneBitOffsetBeforeOut{Containers::BitArrayView{reinterpret_cast<void*>(std::size_t{0xbadda8}), 7, 80}, 10, 8};
Containers::BitArrayView dataOut{reinterpret_cast<void*>(std::size_t{0xdead}), 7, 10};
std::ostringstream out;
Error redirectError{&out};
@ -3807,7 +3807,7 @@ void SceneDataTest::constructBitFieldDataNotContained() {
/* Verify array size is taken into account as well. If not, the data would
span only 9 bytes instead of 11, which would pass. */
SceneData{SceneMappingType::UnsignedByte, 10, {}, data, {
SceneFieldData{sceneFieldCustom(773), mappingData.prefix(9), Containers::StridedBitArrayView2D{Containers::BitArrayView{reinterpret_cast<void*>(0xbadda9), 0, 81}, {9, 9}}}
SceneFieldData{sceneFieldCustom(773), mappingData.prefix(9), Containers::StridedBitArrayView2D{Containers::BitArrayView{reinterpret_cast<void*>(std::size_t{0xbadda9}), 0, 81}, {9, 9}}}
}};
/* Not checking for nullptr data, since that got checked for mapping view
already and there's no way to trigger it for fields */
@ -3934,7 +3934,7 @@ void SceneDataTest::constructNotOwnedFlagOwned() {
void SceneDataTest::constructMismatchedTRSViews() {
CORRADE_SKIP_IF_NO_ASSERT();
Containers::ArrayView<const char> data{reinterpret_cast<char*>(0xcafe0000),
Containers::ArrayView<const char> data{reinterpret_cast<char*>(std::size_t{0xcafe0000}),
4 + 3*24 + 3*4};
Containers::ArrayView<const UnsignedInt> mappingData{
reinterpret_cast<const UnsignedInt*>(data.data() + 4 + 3*24), 3};
@ -4163,7 +4163,7 @@ void SceneDataTest::constructMismatchedMeshMaterialView() {
/* Different sizes, strides and offset-only field handling tested
thoroughly in constructMismatchedTRSViews() already */
Containers::ArrayView<const char> data{reinterpret_cast<char*>(0xcafe0000),
Containers::ArrayView<const char> data{reinterpret_cast<char*>(std::size_t{0xcafe0000}),
4 + 3*8 + 3*4};
Containers::ArrayView<const UnsignedInt> mappingData{
reinterpret_cast<const UnsignedInt*>(data.data() + 4 + 3*8), 3};

4
src/Magnum/Vk/Test/BufferTest.cpp
Unescape View File

@ -219,8 +219,8 @@ void BufferTest::bufferCopyConvertDisallowed() {
void BufferTest::copyBufferInfoConstruct() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
auto a = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead));
auto b = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xcafe));
auto a = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead}));
auto b = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xcafe}));
CopyBufferInfo info{a, b, {
{3, 0, 0},

26
src/Magnum/Vk/Test/DescriptorSetLayoutTest.cpp
Unescape View File

@ -112,14 +112,14 @@ void DescriptorSetLayoutTest::bindingConstructFlags() {
void DescriptorSetLayoutTest::bindingConstructImmutableSamplers() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
DescriptorSetLayoutBinding binding{15, DescriptorType::SampledImage, {reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xdead)), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xcafe))}, ShaderStage::Fragment, DescriptorSetLayoutBinding::Flag::UpdateAfterBind};
DescriptorSetLayoutBinding binding{15, DescriptorType::SampledImage, {reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xdead})), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xbeef})), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xcafe}))}, ShaderStage::Fragment, DescriptorSetLayoutBinding::Flag::UpdateAfterBind};
CORRADE_COMPARE(binding->binding, 15);
CORRADE_COMPARE(binding->descriptorType, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
CORRADE_COMPARE(binding->descriptorCount, 3);
CORRADE_VERIFY(binding->pImmutableSamplers);
CORRADE_COMPARE(binding->pImmutableSamplers[0], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(binding->pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(binding->pImmutableSamplers[2], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xcafe)));
CORRADE_COMPARE(binding->pImmutableSamplers[0], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xdead})));
CORRADE_COMPARE(binding->pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xbeef})));
CORRADE_COMPARE(binding->pImmutableSamplers[2], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xcafe})));
CORRADE_COMPARE(binding->stageFlags, VK_SHADER_STAGE_FRAGMENT_BIT);
CORRADE_COMPARE(binding.flags(), VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT);
}
@ -155,16 +155,16 @@ void DescriptorSetLayoutTest::bindingConstructCopy() {
void DescriptorSetLayoutTest::bindingConstructMove() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
DescriptorSetLayoutBinding a{15, DescriptorType::SampledImage, {reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xdead)), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xcafe))}, ShaderStage::Fragment, DescriptorSetLayoutBinding::Flag::UpdateAfterBind};
DescriptorSetLayoutBinding a{15, DescriptorType::SampledImage, {reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xdead})), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xbeef})), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xcafe}))}, ShaderStage::Fragment, DescriptorSetLayoutBinding::Flag::UpdateAfterBind};
CORRADE_COMPARE(a->descriptorCount, 3);
CORRADE_VERIFY(a->pImmutableSamplers);
CORRADE_COMPARE(a->pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(a->pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xbeef})));
DescriptorSetLayoutBinding b = Utility::move(a);
CORRADE_VERIFY(!a->pImmutableSamplers);
CORRADE_COMPARE(b->descriptorCount, 3);
CORRADE_VERIFY(b->pImmutableSamplers);
CORRADE_COMPARE(b->pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(b->pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xbeef})));
CORRADE_COMPARE(b.flags(), VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT);
DescriptorSetLayoutBinding c{3, {}};
@ -172,7 +172,7 @@ void DescriptorSetLayoutTest::bindingConstructMove() {
CORRADE_VERIFY(!b->pImmutableSamplers);
CORRADE_COMPARE(c->descriptorCount, 3);
CORRADE_VERIFY(c->pImmutableSamplers);
CORRADE_COMPARE(c->pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(c->pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xbeef})));
CORRADE_COMPARE(c.flags(), VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT);
}
@ -219,12 +219,12 @@ void DescriptorSetLayoutTest::createInfoConstructBindingFlags() {
void DescriptorSetLayoutTest::createInfoConstructBindingImmutableSamplers() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
DescriptorSetLayoutBinding binding{3, DescriptorType::Sampler, {reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xdead)), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef))}};
DescriptorSetLayoutBinding binding{3, DescriptorType::Sampler, {reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xdead})), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xbeef}))}};
DescriptorSetLayoutCreateInfo info{{
{{7, DescriptorType::UniformBuffer}},
binding,
{{12, DescriptorType::CombinedImageSampler, {reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xcafe))}}},
{{12, DescriptorType::CombinedImageSampler, {reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xcafe}))}}},
}};
CORRADE_COMPARE(info->bindingCount, 3);
CORRADE_VERIFY(info->pBindings);
@ -240,14 +240,14 @@ void DescriptorSetLayoutTest::createInfoConstructBindingImmutableSamplers() {
CORRADE_VERIFY(info->pBindings[1].pImmutableSamplers);
/* The samplers should get copied, not referenced */
CORRADE_VERIFY(info->pBindings[1].pImmutableSamplers != binding->pImmutableSamplers);
CORRADE_COMPARE(info->pBindings[1].pImmutableSamplers[0], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(info->pBindings[1].pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(info->pBindings[1].pImmutableSamplers[0], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xdead})));
CORRADE_COMPARE(info->pBindings[1].pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xbeef})));
CORRADE_COMPARE(info->pBindings[2].binding, 12);
CORRADE_COMPARE(info->pBindings[2].descriptorType, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
CORRADE_COMPARE(info->pBindings[2].descriptorCount, 1);
CORRADE_VERIFY(info->pBindings[2].pImmutableSamplers);
CORRADE_COMPARE(info->pBindings[2].pImmutableSamplers[0], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xcafe)));
CORRADE_COMPARE(info->pBindings[2].pImmutableSamplers[0], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xcafe})));
CORRADE_VERIFY(!info->pNext);
}

44
src/Magnum/Vk/Test/FramebufferTest.cpp
Unescape View File

@ -64,20 +64,20 @@ void FramebufferTest::createInfoConstruct() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
Device device{NoCreate};
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xdeadbeef));
auto a = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe1)), {});
auto b = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe2)), {});
auto c = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe3)), {});
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xdeadbeef}));
auto a = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe1})), {});
auto b = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe2})), {});
auto c = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe3})), {});
/** @todo use a real flag once it exists */
FramebufferCreateInfo info{renderPass, {a, b, c}, {256, 512}, FramebufferCreateInfo::Flag(0xbadda9)};
CORRADE_COMPARE(info->flags, 0xbadda9);
CORRADE_COMPARE(info->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xdeadbeef)));
CORRADE_COMPARE(info->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xdeadbeef})));
CORRADE_COMPARE(info->attachmentCount, 3);
CORRADE_VERIFY(info->pAttachments);
CORRADE_COMPARE(info->pAttachments[0], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe1)));
CORRADE_COMPARE(info->pAttachments[1], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe2)));
CORRADE_COMPARE(info->pAttachments[2], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe3)));
CORRADE_COMPARE(info->pAttachments[0], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe1})));
CORRADE_COMPARE(info->pAttachments[1], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe2})));
CORRADE_COMPARE(info->pAttachments[2], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe3})));
CORRADE_COMPARE(info->width, 256);
CORRADE_COMPARE(info->height, 512);
CORRADE_COMPARE(info->layers, 1);
@ -87,20 +87,20 @@ void FramebufferTest::createInfoConstructLayered() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
Device device{NoCreate};
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xdeadbeef));
auto a = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe1)), {});
auto b = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe2)), {});
auto c = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe3)), {});
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xdeadbeef}));
auto a = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe1})), {});
auto b = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe2})), {});
auto c = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe3})), {});
/** @todo use a real flag once it exists */
FramebufferCreateInfo info{renderPass, {a, b, c}, {256, 512, 5}, FramebufferCreateInfo::Flag(0xbadda9)};
CORRADE_COMPARE(info->flags, 0xbadda9);
CORRADE_COMPARE(info->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xdeadbeef)));
CORRADE_COMPARE(info->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xdeadbeef})));
CORRADE_COMPARE(info->attachmentCount, 3);
CORRADE_VERIFY(info->pAttachments);
CORRADE_COMPARE(info->pAttachments[0], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe1)));
CORRADE_COMPARE(info->pAttachments[1], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe2)));
CORRADE_COMPARE(info->pAttachments[2], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe3)));
CORRADE_COMPARE(info->pAttachments[0], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe1})));
CORRADE_COMPARE(info->pAttachments[1], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe2})));
CORRADE_COMPARE(info->pAttachments[2], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe3})));
CORRADE_COMPARE(info->width, 256);
CORRADE_COMPARE(info->height, 512);
CORRADE_COMPARE(info->layers, 5);
@ -135,27 +135,27 @@ void FramebufferTest::createInfoConstructMove() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
Device device{NoCreate};
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xdeadbeef));
auto view = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe)), {});
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xdeadbeef}));
auto view = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe})), {});
FramebufferCreateInfo a{renderPass, {view}, {256, 512}};
FramebufferCreateInfo b = Utility::move(a);
CORRADE_COMPARE(a->attachmentCount, 0);
CORRADE_VERIFY(!a->pAttachments);
CORRADE_COMPARE(b->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xdeadbeef)));
CORRADE_COMPARE(b->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xdeadbeef})));
CORRADE_COMPARE(b->attachmentCount, 1);
CORRADE_VERIFY(b->pAttachments);
CORRADE_COMPARE(b->pAttachments[0], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe)));
CORRADE_COMPARE(b->pAttachments[0], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe})));
FramebufferCreateInfo c{VkFramebufferCreateInfo{}};
c = Utility::move(b);
CORRADE_COMPARE(b->attachmentCount, 0);
CORRADE_VERIFY(!b->pAttachments);
CORRADE_COMPARE(c->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xdeadbeef)));
CORRADE_COMPARE(c->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xdeadbeef})));
CORRADE_COMPARE(c->attachmentCount, 1);
CORRADE_VERIFY(c->pAttachments);
CORRADE_COMPARE(c->pAttachments[0], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe)));
CORRADE_COMPARE(c->pAttachments[0], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe})));
CORRADE_VERIFY(std::is_nothrow_move_constructible<FramebufferCreateInfo>::value);
CORRADE_VERIFY(std::is_nothrow_move_assignable<FramebufferCreateInfo>::value);

12
src/Magnum/Vk/Test/ImageTest.cpp
Unescape View File

@ -481,8 +481,8 @@ void ImageTest::imageCopyConvertDisallowed() {
void ImageTest::copyImageInfoConstruct() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
auto a = reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xdead));
auto b = reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xcafe));
auto a = reinterpret_cast<VkImage>(reinterpret_cast<void*>(std::size_t{0xdead}));
auto b = reinterpret_cast<VkImage>(reinterpret_cast<void*>(std::size_t{0xcafe}));
CopyImageInfo info{a, ImageLayout::Preinitialized, b, ImageLayout::General, {
{ImageAspect::Color, 3, 0, 0, {}, 0, 0, 0, {}, {}},
@ -716,8 +716,8 @@ void ImageTest::bufferImageCopyConvertDisallowed() {
void ImageTest::copyBufferToImageInfoConstruct() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
auto a = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead));
auto b = reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xcafe));
auto a = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead}));
auto b = reinterpret_cast<VkImage>(reinterpret_cast<void*>(std::size_t{0xcafe}));
CopyBufferToImageInfo info{a, b, ImageLayout::TransferDestination, {
BufferImageCopy1D{5, ImageAspect::Color, 0, {}},
@ -771,8 +771,8 @@ void ImageTest::copyBufferToImageInfoConvertToVk() {
void ImageTest::copyImageToBufferInfoConstruct() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
auto a = reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xcafe));
auto b = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead));
auto a = reinterpret_cast<VkImage>(reinterpret_cast<void*>(std::size_t{0xcafe}));
auto b = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead}));
CopyImageToBufferInfo info{a, ImageLayout::TransferSource, b, {
BufferImageCopy1D{5, ImageAspect::Color, 0, {}},

2
src/Magnum/Vk/Test/ImageViewTest.cpp
Unescape View File

@ -109,7 +109,7 @@ ImageViewTest::ImageViewTest() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
const VkImage imageHandle{reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xdeadbeef))};
const VkImage imageHandle{reinterpret_cast<VkImage>(reinterpret_cast<void*>(std::size_t{0xdeadbeef}))};
template<class T> void ImageViewTest::createInfoConstruct() {
/** @todo use a real flag once it exists */

26
src/Magnum/Vk/Test/MeshTest.cpp
Unescape View File

@ -184,9 +184,9 @@ void MeshTest::addVertexBuffer() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
mesh.addVertexBuffer(5, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)), 15);
mesh.addVertexBuffer(5, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead})), 15);
CORRADE_COMPARE_AS(mesh.vertexBuffers(), Containers::arrayView({
VkBuffer{}, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead))
VkBuffer{}, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead}))
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mesh.vertexBufferOffsets(), Containers::arrayView<UnsignedLong>({
0, 15
@ -195,10 +195,10 @@ void MeshTest::addVertexBuffer() {
0, 3
}), TestSuite::Compare::Container);
mesh.addVertexBuffer(1, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xbeef)), 37);
mesh.addVertexBuffer(1, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xbeef})), 37);
CORRADE_COMPARE_AS(mesh.vertexBuffers(), Containers::arrayView({
reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xbeef)),
reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead))
reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xbeef})),
reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead}))
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mesh.vertexBufferOffsets(), Containers::arrayView<UnsignedLong>({
37, 15
@ -217,16 +217,16 @@ void MeshTest::addVertexBufferOwned() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
Device device{NoCreate};
Buffer a = Buffer::wrap(device, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)));
Buffer b = Buffer::wrap(device, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xbeef)));
Buffer a = Buffer::wrap(device, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead})));
Buffer b = Buffer::wrap(device, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xbeef})));
mesh.addVertexBuffer(5, Utility::move(a), 15)
.addVertexBuffer(1, Utility::move(b), 37);
CORRADE_VERIFY(!a.handle());
CORRADE_VERIFY(!b.handle());
CORRADE_COMPARE_AS(mesh.vertexBuffers(), Containers::arrayView({
reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xbeef)),
reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead))
reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xbeef})),
reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead}))
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mesh.vertexBufferOffsets(), Containers::arrayView<UnsignedLong>({
37, 15
@ -261,9 +261,9 @@ template<class T> void MeshTest::setIndexBuffer() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
mesh.setIndexBuffer(reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)), 15, T::UnsignedByte);
mesh.setIndexBuffer(reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead})), 15, T::UnsignedByte);
CORRADE_VERIFY(mesh.isIndexed());
CORRADE_COMPARE(mesh.indexBuffer(), reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(mesh.indexBuffer(), reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead})));
CORRADE_COMPARE(mesh.indexBufferOffset(), 15);
CORRADE_COMPARE(mesh.indexType(), MeshIndexType::UnsignedByte);
}
@ -274,13 +274,13 @@ template<class T> void MeshTest::setIndexBufferOwned() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
Device device{NoCreate};
Buffer a = Buffer::wrap(device, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)));
Buffer a = Buffer::wrap(device, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead})));
Mesh mesh{MeshLayout{MeshPrimitive::Triangles}};
mesh.setIndexBuffer(Utility::move(a), 15, T::UnsignedByte);
CORRADE_VERIFY(!a.handle());
CORRADE_VERIFY(mesh.isIndexed());
CORRADE_COMPARE(mesh.indexBuffer(), reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(mesh.indexBuffer(), reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead})));
CORRADE_COMPARE(mesh.indexBufferOffset(), 15);
CORRADE_COMPARE(mesh.indexType(), MeshIndexType::UnsignedByte);
}

12
src/Magnum/Vk/Test/PipelineLayoutTest.cpp
Unescape View File

@ -66,15 +66,15 @@ void PipelineLayoutTest::createInfoConstruct() {
void PipelineLayoutTest::createInfoConstructDescriptorSetLayouts() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
VkDescriptorSetLayout layouts[]{reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xdead)), reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xbeef))};
VkDescriptorSetLayout layouts[]{reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(std::size_t{0xdead})), reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(std::size_t{0xbeef}))};
PipelineLayoutCreateInfo info{layouts};
CORRADE_COMPARE(info->setLayoutCount, 2);
CORRADE_VERIFY(info->pSetLayouts);
/* The contents should be copied */
CORRADE_VERIFY(info->pSetLayouts != layouts);
CORRADE_COMPARE(info->pSetLayouts[0], reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(info->pSetLayouts[1], reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(info->pSetLayouts[0], reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(std::size_t{0xdead})));
CORRADE_COMPARE(info->pSetLayouts[1], reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(std::size_t{0xbeef})));
}
void PipelineLayoutTest::createInfoConstructNoInit() {
@ -105,7 +105,7 @@ void PipelineLayoutTest::createInfoConstructCopy() {
void PipelineLayoutTest::createInfoConstructMove() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
PipelineLayoutCreateInfo a{reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xdead)), reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xbeef))};
PipelineLayoutCreateInfo a{reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(std::size_t{0xdead})), reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(std::size_t{0xbeef}))};
CORRADE_COMPARE(a->setLayoutCount, 2);
CORRADE_VERIFY(a->pSetLayouts);
@ -114,7 +114,7 @@ void PipelineLayoutTest::createInfoConstructMove() {
CORRADE_VERIFY(!a->pSetLayouts);
CORRADE_COMPARE(b->setLayoutCount, 2);
CORRADE_VERIFY(b->pSetLayouts);
CORRADE_COMPARE(b->pSetLayouts[1], reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(b->pSetLayouts[1], reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(std::size_t{0xbeef})));
PipelineLayoutCreateInfo c;
c = Utility::move(b);
@ -122,7 +122,7 @@ void PipelineLayoutTest::createInfoConstructMove() {
CORRADE_VERIFY(!b->pSetLayouts);
CORRADE_COMPARE(c->setLayoutCount, 2);
CORRADE_VERIFY(c->pSetLayouts);
CORRADE_COMPARE(c->pSetLayouts[1], reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(c->pSetLayouts[1], reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(std::size_t{0xbeef})));
}
void PipelineLayoutTest::constructNoCreate() {

26
src/Magnum/Vk/Test/PipelineTest.cpp
Unescape View File

@ -191,7 +191,7 @@ void PipelineTest::rasterizationCreateInfoConstruct() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
RasterizationPipelineCreateInfo info{shaderSet, meshLayout, reinterpret_cast<VkPipelineLayout>(reinterpret_cast<void*>(0xdead)), reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xbeef)), 15, 3, RasterizationPipelineCreateInfo::Flag::DisableOptimization|RasterizationPipelineCreateInfo::Flag::AllowDerivatives};
RasterizationPipelineCreateInfo info{shaderSet, meshLayout, reinterpret_cast<VkPipelineLayout>(reinterpret_cast<void*>(std::size_t{0xdead})), reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xbeef})), 15, 3, RasterizationPipelineCreateInfo::Flag::DisableOptimization|RasterizationPipelineCreateInfo::Flag::AllowDerivatives};
CORRADE_COMPARE(info->flags, VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT|VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT);
CORRADE_COMPARE(info->stageCount, 2);
CORRADE_COMPARE(info->pStages, shaderSet.stages());
@ -215,8 +215,8 @@ void PipelineTest::rasterizationCreateInfoConstruct() {
CORRADE_COMPARE(info->pColorBlendState->pAttachments[i].colorWriteMask, VK_COLOR_COMPONENT_R_BIT|VK_COLOR_COMPONENT_G_BIT|VK_COLOR_COMPONENT_B_BIT|VK_COLOR_COMPONENT_A_BIT);
}
CORRADE_VERIFY(!info->pDynamicState);
CORRADE_COMPARE(info->layout, reinterpret_cast<VkPipelineLayout>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(info->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(info->layout, reinterpret_cast<VkPipelineLayout>(reinterpret_cast<void*>(std::size_t{0xdead})));
CORRADE_COMPARE(info->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xbeef})));
CORRADE_COMPARE(info->subpass, 15);
}
@ -544,14 +544,14 @@ void PipelineTest::computeCreateInfoConstruct() {
/* Yes, I know Fragment is wrong, it's just for testing */
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
shaderSet.addShader(ShaderStage::Fragment, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xbeef)), name);
shaderSet.addShader(ShaderStage::Fragment, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(std::size_t{0xbeef})), name);
ComputePipelineCreateInfo info{shaderSet, reinterpret_cast<VkPipelineLayout>(reinterpret_cast<void*>(0xdead)), ComputePipelineCreateInfo::Flag::DisableOptimization|ComputePipelineCreateInfo::Flag::AllowDerivatives};
ComputePipelineCreateInfo info{shaderSet, reinterpret_cast<VkPipelineLayout>(reinterpret_cast<void*>(std::size_t{0xdead})), ComputePipelineCreateInfo::Flag::DisableOptimization|ComputePipelineCreateInfo::Flag::AllowDerivatives};
CORRADE_COMPARE(info->flags, VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT|VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT);
CORRADE_COMPARE(info->stage.stage, VK_SHADER_STAGE_FRAGMENT_BIT);
CORRADE_COMPARE(info->stage.module, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(info->stage.module, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(std::size_t{0xbeef})));
CORRADE_COMPARE(info->stage.pName, name.data());
CORRADE_COMPARE(info->layout, reinterpret_cast<VkPipelineLayout>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(info->layout, reinterpret_cast<VkPipelineLayout>(reinterpret_cast<void*>(std::size_t{0xdead})));
}
void PipelineTest::computeCreateInfoConstructOwnedEntrypoint() {
@ -641,10 +641,10 @@ void PipelineTest::memoryBarrierConstructFromVk() {
void PipelineTest::bufferMemoryBarrierConstruct() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
BufferMemoryBarrier barrier{Access::ColorAttachmentWrite|Access::DepthStencilAttachmentWrite, Access::TransferRead, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)), 3, 5};
BufferMemoryBarrier barrier{Access::ColorAttachmentWrite|Access::DepthStencilAttachmentWrite, Access::TransferRead, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead})), 3, 5};
CORRADE_COMPARE(barrier->srcAccessMask, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
CORRADE_COMPARE(barrier->dstAccessMask, VK_ACCESS_TRANSFER_READ_BIT);
CORRADE_COMPARE(barrier->buffer, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(barrier->buffer, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead})));
CORRADE_COMPARE(barrier->offset, 3);
CORRADE_COMPARE(barrier->size, 5);
}
@ -672,12 +672,12 @@ void PipelineTest::bufferMemoryBarrierConstructFromVk() {
void PipelineTest::imageMemoryBarrierConstruct() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
ImageMemoryBarrier barrier{Access::ColorAttachmentWrite|Access::DepthStencilAttachmentWrite, Access::TransferRead, ImageLayout::Preinitialized, ImageLayout::TransferSource, reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xdead)), ImageAspect::Color|ImageAspect::Depth, 3, 5, 7, 9};
ImageMemoryBarrier barrier{Access::ColorAttachmentWrite|Access::DepthStencilAttachmentWrite, Access::TransferRead, ImageLayout::Preinitialized, ImageLayout::TransferSource, reinterpret_cast<VkImage>(reinterpret_cast<void*>(std::size_t{0xdead})), ImageAspect::Color|ImageAspect::Depth, 3, 5, 7, 9};
CORRADE_COMPARE(barrier->srcAccessMask, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
CORRADE_COMPARE(barrier->dstAccessMask, VK_ACCESS_TRANSFER_READ_BIT);
CORRADE_COMPARE(barrier->oldLayout, VK_IMAGE_LAYOUT_PREINITIALIZED);
CORRADE_COMPARE(barrier->newLayout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
CORRADE_COMPARE(barrier->image, reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(barrier->image, reinterpret_cast<VkImage>(reinterpret_cast<void*>(std::size_t{0xdead})));
CORRADE_COMPARE(barrier->subresourceRange.aspectMask, VK_IMAGE_ASPECT_COLOR_BIT|VK_IMAGE_ASPECT_DEPTH_BIT);
CORRADE_COMPARE(barrier->subresourceRange.baseMipLevel, 7);
CORRADE_COMPARE(barrier->subresourceRange.levelCount, 9);
@ -689,7 +689,7 @@ void PipelineTest::imageMemoryBarrierConstructImplicitAspect() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
Device device{NoCreate};
Image image = Image::wrap(device, reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xdead)), PixelFormat::Depth24UnormStencil8UI);
Image image = Image::wrap(device, reinterpret_cast<VkImage>(reinterpret_cast<void*>(std::size_t{0xdead})), PixelFormat::Depth24UnormStencil8UI);
ImageMemoryBarrier barrier{
Access::ColorAttachmentRead, Access::TransferWrite,
@ -699,7 +699,7 @@ void PipelineTest::imageMemoryBarrierConstructImplicitAspect() {
CORRADE_COMPARE(barrier->dstAccessMask, VK_ACCESS_TRANSFER_WRITE_BIT);
CORRADE_COMPARE(barrier->oldLayout, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
CORRADE_COMPARE(barrier->newLayout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
CORRADE_COMPARE(barrier->image, reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(barrier->image, reinterpret_cast<VkImage>(reinterpret_cast<void*>(std::size_t{0xdead})));
CORRADE_COMPARE(barrier->subresourceRange.aspectMask, VK_IMAGE_ASPECT_DEPTH_BIT|VK_IMAGE_ASPECT_STENCIL_BIT);
CORRADE_COMPARE(barrier->subresourceRange.baseMipLevel, 7);
CORRADE_COMPARE(barrier->subresourceRange.levelCount, 9);

14
src/Magnum/Vk/Test/QueueTest.cpp
Unescape View File

@ -131,14 +131,14 @@ void QueueTest::submitInfoConstructCommandBuffers() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
info.setCommandBuffers({
reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xbadbeef)),
reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xcafecafe))
reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(std::size_t{0xbadbeef})),
reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(std::size_t{0xcafecafe}))
});
CORRADE_COMPARE(info->commandBufferCount, 2);
CORRADE_VERIFY(info->pCommandBuffers);
CORRADE_COMPARE(info->pCommandBuffers[0], reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xbadbeef)));
CORRADE_COMPARE(info->pCommandBuffers[1], reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xcafecafe)));
CORRADE_COMPARE(info->pCommandBuffers[0], reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(std::size_t{0xbadbeef})));
CORRADE_COMPARE(info->pCommandBuffers[1], reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(std::size_t{0xcafecafe})));
}
void QueueTest::submitInfoConstructFromVk() {
@ -158,14 +158,14 @@ void QueueTest::submitInfoConstructMove() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
SubmitInfo a;
a.setCommandBuffers({{}, reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xcafecafe))});
a.setCommandBuffers({{}, reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(std::size_t{0xcafecafe}))});
SubmitInfo b = Utility::move(a);
CORRADE_COMPARE(a->commandBufferCount, 0);
CORRADE_VERIFY(!a->pCommandBuffers);
CORRADE_COMPARE(b->commandBufferCount, 2);
CORRADE_VERIFY(b->pCommandBuffers);
CORRADE_COMPARE(b->pCommandBuffers[1], reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xcafecafe)));
CORRADE_COMPARE(b->pCommandBuffers[1], reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(std::size_t{0xcafecafe})));
SubmitInfo c{VkSubmitInfo{}};
c = Utility::move(b);
@ -173,7 +173,7 @@ void QueueTest::submitInfoConstructMove() {
CORRADE_VERIFY(!b->pCommandBuffers);
CORRADE_COMPARE(c->commandBufferCount, 2);
CORRADE_VERIFY(c->pCommandBuffers);
CORRADE_COMPARE(c->pCommandBuffers[1], reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xcafecafe)));
CORRADE_COMPARE(c->pCommandBuffers[1], reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(std::size_t{0xcafecafe})));
}
}}}}

8
src/Magnum/Vk/Test/RenderPassTest.cpp
Unescape View File

@ -1122,8 +1122,8 @@ void RenderPassTest::constructCopy() {
void RenderPassTest::beginInfoConstruct() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xbadbeef));
auto framebuffer = reinterpret_cast<VkFramebuffer>(reinterpret_cast<void*>(0xdeadcafe));
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xbadbeef}));
auto framebuffer = reinterpret_cast<VkFramebuffer>(reinterpret_cast<void*>(std::size_t{0xdeadcafe}));
RenderPassBeginInfo info{renderPass, framebuffer, Range2Di{{3, 7}, {15, 78}}};
CORRADE_COMPARE(info->renderPass, renderPass);
@ -1136,9 +1136,9 @@ void RenderPassTest::beginInfoConstruct() {
void RenderPassTest::beginInfoConstructImplicitSize() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xbadbeef));
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xbadbeef}));
Device device{NoCreate};
auto framebuffer = Framebuffer::wrap(device, reinterpret_cast<VkFramebuffer>(reinterpret_cast<void*>(0xdeadcafe)), {256, 384, 16});
auto framebuffer = Framebuffer::wrap(device, reinterpret_cast<VkFramebuffer>(reinterpret_cast<void*>(std::size_t{0xdeadcafe})), {256, 384, 16});
RenderPassBeginInfo info{renderPass, framebuffer};
CORRADE_COMPARE(info->renderPass, renderPass);

12
src/Magnum/Vk/Test/ShaderSetTest.cpp
Unescape View File

@ -126,13 +126,13 @@ void ShaderSetTest::constructMove() {
/* The double reinterpret_cast is needed because the handle is an
uint64_t instead of a pointer on 32-bit builds and only this works
on both */
a.addShader(ShaderStage::Geometry, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xdeadbeef)), "main!"_s.exceptSuffix(1), {
a.addShader(ShaderStage::Geometry, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(std::size_t{0xdeadbeef})), "main!"_s.exceptSuffix(1), {
{42, 1.15f}
});
/* This one has an externally-supplied specialization pointer, to
verify it's preserved on move (others will have it redirected) */
a.addShader(ShaderStage::Fragment, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xbadf00d)), "yours");
a.addShader(ShaderStage::Fragment, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(std::size_t{0xbadf00d})), "yours");
a.stages()[1].pSpecializationInfo = &externalSpecializationInfo2;
CORRADE_COMPARE(a.stages().size(), 2);
@ -221,10 +221,10 @@ void ShaderSetTest::addShader() {
Containers::StringView entrypoint = "enterHere"_s;
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
set.addShader(ShaderStage::Geometry, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xdeadbeef)), entrypoint);
set.addShader(ShaderStage::Geometry, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(std::size_t{0xdeadbeef})), entrypoint);
CORRADE_COMPARE(set.stages().size(), 1);
CORRADE_COMPARE(set.stages()[0].stage, VK_SHADER_STAGE_GEOMETRY_BIT);
CORRADE_COMPARE(set.stages()[0].module, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xdeadbeef)));
CORRADE_COMPARE(set.stages()[0].module, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(std::size_t{0xdeadbeef})));
/* The name should not be copied if it's null-terminated and global */
CORRADE_COMPARE(set.stages()[0].pName, entrypoint.data());
CORRADE_VERIFY(!set.stages()[0].pSpecializationInfo);
@ -342,7 +342,7 @@ void ShaderSetTest::addShaderOwnershipTransfer() {
Device device{NoCreate};
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
auto shader = Shader::wrap(device, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xdeadbeef)));
auto shader = Shader::wrap(device, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(std::size_t{0xdeadbeef})));
ShaderSet set;
set.addShader(ShaderStage::RayAnyHit, Utility::move(shader), "main"_s, {
@ -351,7 +351,7 @@ void ShaderSetTest::addShaderOwnershipTransfer() {
CORRADE_COMPARE(set.stages()[0].stage, VK_SHADER_STAGE_ANY_HIT_BIT_KHR);
CORRADE_COMPARE(set.stages()[0].pName, "main"_s);
CORRADE_COMPARE(set.stages()[0].module, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xdeadbeef)));
CORRADE_COMPARE(set.stages()[0].module, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(std::size_t{0xdeadbeef})));
CORRADE_VERIFY(set.stages()[0].pSpecializationInfo);
CORRADE_COMPARE(set.stages()[0].pSpecializationInfo->mapEntryCount, 1);
CORRADE_VERIFY(set.stages()[0].pSpecializationInfo->pMapEntries);

Write Preview
Loading…
Cancel
Save