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

Should fix the remaining MSVC C4312 warnings.

src/Magnum/DebugTools/Test/CompareMaterialTest.cpp

@@ -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)},
+            {"pointer", reinterpret_cast<const void*>(std::size_t{0xbeef})},
-            {"pointerMutable", reinterpret_cast<void*>(0xdead)},
+            {"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)},
+            {"pointer", reinterpret_cast<const void*>(std::size_t{0xbeef})},
-            {"pointerMutable", reinterpret_cast<void*>(0xdead)},
+            {"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"

src/Magnum/MaterialTools/Test/CopyTest.cpp

@@ -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);

src/Magnum/SceneTools/Test/SceneConverterImplementationTest.cpp

@@ -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)},
+                {"deadBeef", reinterpret_cast<const void*>(std::size_t(0xdeadbeef))},
-                {"undeadBeef", reinterpret_cast<void*>(0xbeefbeef)},
+                {"undeadBeef", reinterpret_cast<void*>(std::size_t(0xbeefbeef))},
             }};
 
             /* Second has layers, custom layers, unnamed layers and a name */

src/Magnum/Text/Test/AbstractGlyphCacheTest.cpp

@@ -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);

src/Magnum/Text/Test/AbstractShaperTest.cpp

@@ -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);

src/Magnum/Trade/Test/AbstractImporterTest.cpp

@@ -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();

src/Magnum/Trade/Test/AbstractSceneConverterTest.cpp

@@ -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;

src/Magnum/Trade/Test/MeshDataTest.cpp

@@ -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}

src/Magnum/Trade/Test/SceneDataTest.cpp

@@ -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 dataOneByteOut{Containers::BitArrayView{reinterpret_cast<void*>(std::size_t{0xbaddaa}), 0, 80}, 10, 8};
-    Containers::StridedBitArrayView1D dataTwoBitsOut{Containers::BitArrayView{reinterpret_cast<void*>(0xbadda9), 0, 90}, 10, 9};
+    Containers::StridedBitArrayView1D dataTwoBitsOut{Containers::BitArrayView{reinterpret_cast<void*>(std::size_t{0xbadda9}), 0, 90}, 10, 9};
-    Containers::StridedBitArrayView1D dataOneBitOffsetOut{Containers::BitArrayView{reinterpret_cast<void*>(0xbadda9), 4, 95}, 5, 19};
+    Containers::StridedBitArrayView1D dataOneBitOffsetOut{Containers::BitArrayView{reinterpret_cast<void*>(std::size_t{0xbadda9}), 4, 95}, 5, 19};
-    Containers::StridedBitArrayView1D dataOneBitOffsetBeforeOut{Containers::BitArrayView{reinterpret_cast<void*>(0xbadda8), 7, 80}, 10, 8};
+    Containers::StridedBitArrayView1D dataOneBitOffsetBeforeOut{Containers::BitArrayView{reinterpret_cast<void*>(std::size_t{0xbadda8}), 7, 80}, 10, 8};
-    Containers::BitArrayView dataOut{reinterpret_cast<void*>(0xdead), 7, 10};
+    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};

src/Magnum/Vk/Test/BufferTest.cpp

@@ -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 a = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead}));
-    auto b = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xcafe));
+    auto b = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xcafe}));
 
     CopyBufferInfo info{a, b, {
         {3, 0, 0},

src/Magnum/Vk/Test/DescriptorSetLayoutTest.cpp

@@ -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[0], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xdead})));
-    CORRADE_COMPARE(binding->pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)));
+    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*>(0xcafe)));
+    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[0], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(std::size_t{0xdead})));
-    CORRADE_COMPARE(info->pBindings[1].pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)));
+    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);
 }

src/Magnum/Vk/Test/FramebufferTest.cpp

@@ -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 renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xdeadbeef}));
-    auto a = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe1)), {});
+    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*>(0xcafe2)), {});
+    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*>(0xcafe3)), {});
+    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[0], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe1})));
-    CORRADE_COMPARE(info->pAttachments[1], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe2)));
+    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*>(0xcafe3)));
+    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 renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xdeadbeef}));
-    auto a = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe1)), {});
+    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*>(0xcafe2)), {});
+    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*>(0xcafe3)), {});
+    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[0], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(std::size_t{0xcafe1})));
-    CORRADE_COMPARE(info->pAttachments[1], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe2)));
+    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*>(0xcafe3)));
+    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 renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xdeadbeef}));
-    auto view = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe)), {});
+    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);

src/Magnum/Vk/Test/ImageTest.cpp

@@ -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 a = reinterpret_cast<VkImage>(reinterpret_cast<void*>(std::size_t{0xdead}));
-    auto b = reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xcafe));
+    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 a = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead}));
-    auto b = reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xcafe));
+    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 a = reinterpret_cast<VkImage>(reinterpret_cast<void*>(std::size_t{0xcafe}));
-    auto b = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead));
+    auto b = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(std::size_t{0xdead}));
 
     CopyImageToBufferInfo info{a, ImageLayout::TransferSource, b, {
         BufferImageCopy1D{5, ImageAspect::Color, 0, {}},

src/Magnum/Vk/Test/ImageViewTest.cpp

@@ -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 */

src/Magnum/Vk/Test/MeshTest.cpp

@@ -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*>(std::size_t{0xbeef})),
-        reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead))
+        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 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*>(0xbeef)));
+    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*>(std::size_t{0xbeef})),
-        reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead))
+        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);
 }

src/Magnum/Vk/Test/PipelineLayoutTest.cpp

@@ -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[0], reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(std::size_t{0xdead})));
-    CORRADE_COMPARE(info->pSetLayouts[1], reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xbeef)));
+    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() {

src/Magnum/Vk/Test/PipelineTest.cpp

@@ -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->layout, reinterpret_cast<VkPipelineLayout>(reinterpret_cast<void*>(std::size_t{0xdead})));
-    CORRADE_COMPARE(info->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xbeef)));
+    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);

src/Magnum/Vk/Test/QueueTest.cpp

@@ -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*>(std::size_t{0xbadbeef})),
-        reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xcafecafe))
+        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[0], reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(std::size_t{0xbadbeef})));
-    CORRADE_COMPARE(info->pCommandBuffers[1], reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xcafecafe)));
+    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})));
 }
 
 }}}}

src/Magnum/Vk/Test/RenderPassTest.cpp

@@ -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 renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(std::size_t{0xbadbeef}));
-    auto framebuffer = reinterpret_cast<VkFramebuffer>(reinterpret_cast<void*>(0xdeadcafe));
+    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);

src/Magnum/Vk/Test/ShaderSetTest.cpp

@@ -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);