Adapt to Corrade::Containers Array[View] API deprecation.

And, exactly as expected, there's many cases that used the (implicit)
ValueInit while NoInit is a better choice. So yeah, minor speedups in
various places such as GL image download.

doc/snippets/SceneTools.cpp

@@ -146,7 +146,8 @@ Trade::SceneData scene = DOXYGEN_ELLIPSIS(Trade::SceneData{{}, 0, nullptr, {}});
 /* Put all transformations into an array indexed by object ID. Objects
    implicitly have an identity transformation, first element is reserved for
    the global transformation. */
-Containers::Array<Matrix4> transformations{std::size_t(scene.mappingBound() + 1)};
+Containers::Array<Matrix4> transformations{ValueInit,
+    std::size_t(scene.mappingBound() + 1)};
 for(const Containers::Pair<UnsignedInt, Matrix4>& transformation:
     scene.transformations3DAsArray())
 {

doc/snippets/Shaders-gl.cpp

@@ -789,7 +789,7 @@ shader.setColor(0x2f83cc_rgbf)
 /* [MeshVisualizerGL3D-usage-geom2] */
 
 /* [MeshVisualizerGL3D-usage-no-geom-old] */
-Containers::Array<Float> vertexIndex{Containers::arraySize(vertices)};
+Containers::Array<Float> vertexIndex{NoInit, Containers::arraySize(vertices)};
 std::iota(vertexIndex.begin(), vertexIndex.end(), 0.0f);
 
 GL::Buffer vertexIndices;

doc/snippets/Trade.cpp

@@ -920,8 +920,8 @@ struct Vertex {
     Vector4 color;
 };
 
-Containers::Array<char> indexData{indexCount*sizeof(UnsignedShort)};
-Containers::Array<char> vertexData{vertexCount*sizeof(Vertex)};
+Containers::Array<char> indexData{ValueInit, indexCount*sizeof(UnsignedShort)};
+Containers::Array<char> vertexData{ValueInit, vertexCount*sizeof(Vertex)};
 DOXYGEN_ELLIPSIS()
 Containers::StridedArrayView1D<const Vertex> vertices =
     Containers::arrayCast<const Vertex>(vertexData);
@@ -980,7 +980,7 @@ constexpr Trade::MeshAttributeData attributes[]{
 };
 
 /* Actual data populated later */
-Containers::Array<char> vertexData{vertexCount*sizeof(Vertex)};
+Containers::Array<char> vertexData{ValueInit, vertexCount*sizeof(Vertex)};
 DOXYGEN_ELLIPSIS()
 
 /* Using the statically defined attribute layout together with explicitly
@@ -1148,7 +1148,7 @@ if(!data.is3D() ||
     Fatal{} << "Oh noes!";
 
 Scene3D scene;
-Containers::Array<Object3D*> objects{std::size_t(data.mappingBound())};
+Containers::Array<Object3D*> objects{ValueInit, std::size_t(data.mappingBound())};
 /* [SceneData-usage1] */
 
 /* [SceneData-usage2] */
@@ -1318,7 +1318,7 @@ constexpr Trade::SceneFieldData fields[]{
 };
 
 /* Actual data populated later */
-Containers::Array<char> data{objectCount*sizeof(Data)};
+Containers::Array<char> data{ValueInit, objectCount*sizeof(Data)};
 DOXYGEN_ELLIPSIS()
 
 /* Using the statically defined field layout */

src/Magnum/Animation/Test/Benchmark.cpp

@@ -83,7 +83,7 @@ Benchmark::Benchmark() {
                    &Benchmark::playerAdvanceRawCallback,
                    &Benchmark::playerAdvanceRawCallbackDirectInterpolator}, 10);
 
-    _keys = Containers::Array<Float>{DataSize};
+    _keys = Containers::Array<Float>{NoInit, DataSize};
     _values = Containers::Array<Int>{DirectInit, DataSize, 1};
     _interleaved = Containers::Array<std::pair<Float, Int>>{DirectInit, DataSize, 0.0f, 1};
     for(std::size_t i = 0; i != DataSize; ++i)

src/Magnum/Audio/Buffer.h

@@ -96,7 +96,7 @@ class MAGNUM_AUDIO_EXPORT Buffer {
          * @see @fn_al_keyword{BufferData}
          */
         Buffer& setData(BufferFormat format, Containers::ArrayView<const void> data, ALsizei frequency) {
-            alBufferData(_id, ALenum(format), data, data.size(), frequency);
+            alBufferData(_id, ALenum(format), data.data(), data.size(), frequency);
             return *this;
         }
 

src/Magnum/Audio/Source.cpp

@@ -43,7 +43,7 @@ Source& Source::setBuffer(Buffer* buffer) {
 }
 
 Source& Source::queueBuffers(Containers::ArrayView<Containers::Reference<Buffer>> buffers) {
-    Containers::Array<ALuint> ids(buffers.size());
+    Containers::Array<ALuint> ids(NoInit, buffers.size());
     for(std::size_t i = 0; i < ids.size(); i++)
         ids[i] = buffers[i]->id();
     alSourceQueueBuffers(_id, ids.size(), ids.data());
@@ -57,7 +57,7 @@ std::size_t Source::unqueueBuffers(Containers::ArrayView<Containers::Reference<B
     if(!processedBuffers)
         return 0;
 
-    Containers::Array<ALuint> unqueuedIds(processedBuffers);
+    Containers::Array<ALuint> unqueuedIds(NoInit, processedBuffers);
     alSourceUnqueueBuffers(_id, unqueuedIds.size(), unqueuedIds.data());
     auto isNotUnqueued = [&unqueuedIds](Buffer& buffer) {
         for(ALuint id : unqueuedIds) {
@@ -72,14 +72,14 @@ std::size_t Source::unqueueBuffers(Containers::ArrayView<Containers::Reference<B
 namespace {
 
 Containers::Array<ALuint> sourceIds(const std::initializer_list<std::reference_wrapper<Source>>& sources) {
-    Containers::Array<ALuint> ids(sources.size());
+    Containers::Array<ALuint> ids(NoInit, sources.size());
     for(auto it = sources.begin(); it != sources.end(); ++it)
         ids[it-sources.begin()] = it->get().id();
     return ids;
 }
 
 Containers::Array<ALuint> sourceIds(const std::vector<std::reference_wrapper<Source>>& sources) {
-    Containers::Array<ALuint> ids(sources.size());
+    Containers::Array<ALuint> ids(NoInit, sources.size());
     for(auto it = sources.begin(); it != sources.end(); ++it)
         ids[it-sources.begin()] = it->get().id();
     return ids;
@@ -89,42 +89,42 @@ Containers::Array<ALuint> sourceIds(const std::vector<std::reference_wrapper<Sou
 
 void Source::play(std::initializer_list<std::reference_wrapper<Source>> sources) {
     const auto ids = sourceIds(sources);
-    alSourcePlayv(ids.size(), ids);
+    alSourcePlayv(ids.size(), ids.data());
 }
 
 void Source::play(const std::vector<std::reference_wrapper<Source>>& sources) {
     const auto ids = sourceIds(sources);
-    alSourcePlayv(ids.size(), ids);
+    alSourcePlayv(ids.size(), ids.data());
 }
 
 void Source::pause(std::initializer_list<std::reference_wrapper<Source>> sources) {
     const auto ids = sourceIds(sources);
-    alSourcePausev(ids.size(), ids);
+    alSourcePausev(ids.size(), ids.data());
 }
 
 void Source::pause(const std::vector<std::reference_wrapper<Source>>& sources) {
     const auto ids = sourceIds(sources);
-    alSourcePausev(ids.size(), ids);
+    alSourcePausev(ids.size(), ids.data());
 }
 
 void Source::stop(std::initializer_list<std::reference_wrapper<Source>> sources) {
     const auto ids = sourceIds(sources);
-    alSourceStopv(ids.size(), ids);
+    alSourceStopv(ids.size(), ids.data());
 }
 
 void Source::stop(const std::vector<std::reference_wrapper<Source>>& sources) {
     const auto ids = sourceIds(sources);
-    alSourceStopv(ids.size(), ids);
+    alSourceStopv(ids.size(), ids.data());
 }
 
 void Source::rewind(std::initializer_list<std::reference_wrapper<Source>> sources) {
     const auto ids = sourceIds(sources);
-    alSourceRewindv(ids.size(), ids);
+    alSourceRewindv(ids.size(), ids.data());
 }
 
 void Source::rewind(const std::vector<std::reference_wrapper<Source>>& sources) {
     const auto ids = sourceIds(sources);
-    alSourceRewindv(ids.size(), ids);
+    alSourceRewindv(ids.size(), ids.data());
 }
 
 Debug& operator<<(Debug& debug, const Source::State value) {

src/Magnum/Audio/Test/AbstractImporterTest.cpp

@@ -332,9 +332,7 @@ void AbstractImporterTest::data() {
         BufferFormat doFormat() const override { return {}; }
         UnsignedInt doFrequency() const override { return {}; }
         Containers::Array<char> doData() override {
-            Containers::Array<char> out{1};
-            out[0] = 'H';
-            return out;
+            return Containers::Array<char>{InPlaceInit, {'H'}};
         }
     } importer;
 

src/Magnum/DebugTools/CompareImage.cpp

@@ -775,7 +775,7 @@ void ImageComparatorBase::saveDiagnostic(TestSuite::ComparisonStatusFlags, Utili
     /* Tightly pack the actual pixels into a new array and create an image from
        it -- the array view might have totally arbitrary strides that can't
        be represented in an Image */
-    Containers::Array<char> data{_state->actualPixels.size()[0]*_state->actualPixels.size()[1]*_state->actualPixels.size()[2]};
+    Containers::Array<char> data{NoInit, _state->actualPixels.size()[0]*_state->actualPixels.size()[1]*_state->actualPixels.size()[2]};
     Containers::StridedArrayView3D<char> pixels{data, _state->actualPixels.size()};
     for(std::size_t i = 0, iMax = _state->actualPixels.size()[0]; i != iMax; ++i) {
         Containers::StridedArrayView2D<const char> inRow = _state->actualPixels[i];

src/Magnum/DebugTools/Test/CompareImageTest.cpp

@@ -456,7 +456,7 @@ void CompareImageTest::calculateDeltaSpecials3() {
 }
 
 void CompareImageTest::deltaImage() {
-    Containers::Array<Float> delta{32*32};
+    Containers::Array<Float> delta{NoInit, 32*32};
 
     for(std::int_fast32_t x = 0; x != 32; ++x)
         for(std::int_fast32_t y = 0; y != 32; ++y)
@@ -489,7 +489,7 @@ void CompareImageTest::deltaImage() {
 }
 
 void CompareImageTest::deltaImageScaling() {
-    Containers::Array<Float> delta{65*40};
+    Containers::Array<Float> delta{NoInit, 65*40};
     for(std::int_fast32_t x = 0; x != 65; ++x)
         for(std::int_fast32_t y = 0; y != 40; ++y)
             delta[y*65 + x] = Vector2{Float(x), Float(y)}.length()/Vector2{65.0f, 40.0f}.length();

src/Magnum/GL/AbstractFramebuffer.cpp

@@ -379,7 +379,7 @@ void AbstractFramebuffer::read(const Range2Di& rectangle, const MutableImageView
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     #endif
     Context::current().state().renderer.applyPixelStoragePack(image.storage());
-    (Context::current().state().framebuffer.readImplementation)(rectangle, pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().size(), image.data()
+    (Context::current().state().framebuffer.readImplementation)(rectangle, pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().size(), image.data().data()
         #ifdef MAGNUM_TARGET_GLES2
         + Magnum::Implementation::pixelStorageSkipOffsetFor(image, rectangle.size())
         #endif
@@ -391,7 +391,7 @@ void AbstractFramebuffer::read(const Range2Di& rectangle, Image2D& image) {
     const std::size_t dataSize = Magnum::Implementation::imageDataSizeFor(image, rectangle.size());
     Containers::Array<char> data{image.release()};
     if(data.size() < dataSize)
-        data = Containers::Array<char>{dataSize};
+        data = Containers::Array<char>{NoInit, dataSize};
 
     /* Replace the storage, proxy to the function taking a view */
     image = Image2D{image.storage(), image.format(), image.formatExtra(), image.pixelSize(), rectangle.size(), Utility::move(data), ImageFlags2D{}};

src/Magnum/GL/AbstractShaderProgram.cpp

@@ -644,7 +644,7 @@ void AbstractShaderProgram::transformFeedbackVaryingsImplementationDefault(Abstr
         names[i] = nameData[i].data();
     }
 
-    glTransformFeedbackVaryings(self._id, outputs.size(), names, GLenum(bufferMode));
+    glTransformFeedbackVaryings(self._id, outputs.size(), names.data(), GLenum(bufferMode));
 }
 
 #ifdef CORRADE_TARGET_WINDOWS
@@ -669,7 +669,7 @@ void AbstractShaderProgram::transformFeedbackVaryingsImplementationDanglingWorka
         names[i] = nameData[i].data();
     }
 
-    glTransformFeedbackVaryings(self._id, outputs.size(), names, GLenum(bufferMode));
+    glTransformFeedbackVaryings(self._id, outputs.size(), names.data(), GLenum(bufferMode));
 }
 #endif
 #endif

src/Magnum/GL/AbstractTexture.cpp

@@ -178,7 +178,7 @@ void AbstractTexture::bindImplementationMulti(const GLint firstTextureUnit, cons
 
     /* Create array of IDs and also update bindings in state tracker */
     /** @todo VLAs */
-    Containers::Array<GLuint> ids{textures ? textures.size() : 0};
+    Containers::Array<GLuint> ids{NoInit, textures ? textures.size() : 0};
     bool different = false;
     for(std::size_t i = 0; i != textures.size(); ++i) {
         const GLuint id = textures && textures[i] ? textures[i]->_id : 0;
@@ -197,7 +197,7 @@ void AbstractTexture::bindImplementationMulti(const GLint firstTextureUnit, cons
 
     /* Avoid doing the binding if there is nothing different */
     if(different)
-        glBindTextures(firstTextureUnit, textures.size(), ids);
+        glBindTextures(firstTextureUnit, textures.size(), ids.data());
 }
 #endif
 
@@ -317,7 +317,7 @@ void AbstractTexture::bindImages(const Int firstImageUnit, const Containers::Arr
     Implementation::TextureState& textureState = Context::current().state().texture;
 
     /* Create array of IDs and also update bindings in state tracker */
-    Containers::Array<GLuint> ids{textures ? textures.size() : 0};
+    Containers::Array<GLuint> ids{NoInit, textures ? textures.size() : 0};
     bool different = false;
     for(std::size_t i = 0; i != textures.size(); ++i) {
         const Implementation::TextureState::ImageBinding state = textures && textures[i] ?
@@ -339,7 +339,7 @@ void AbstractTexture::bindImages(const Int firstImageUnit, const Containers::Arr
 
     /* Avoid doing the binding if there is nothing different */
     if(different)
-        glBindImageTextures(firstImageUnit, textures.size(), ids);
+        glBindImageTextures(firstImageUnit, textures.size(), ids.data());
 }
 
 void AbstractTexture::bindImages(const Int firstImageUnit, const std::initializer_list<AbstractTexture*> textures) {
@@ -1775,11 +1775,11 @@ template<UnsignedInt dimensions> void AbstractTexture::image(const GLint level,
     /* Reallocate only if needed */
     Containers::Array<char> data{image.release()};
     if(data.size() < dataSize)
-        data = Containers::Array<char>{dataSize};
+        data = Containers::Array<char>{NoInit, dataSize};
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyPixelStoragePack(image.storage());
-    Context::current().state().texture.getImageImplementation(*this, level, pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), data.size(), data);
+    Context::current().state().texture.getImageImplementation(*this, level, pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), data.size(), data.data());
     image = Image<dimensions>{image.storage(), image.format(), image.formatExtra(), image.pixelSize(), size, Utility::move(data), flags};
 }
 
@@ -1798,7 +1798,7 @@ template<UnsignedInt dimensions> void AbstractTexture::image(GLint level, const
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyPixelStoragePack(image.storage());
-    Context::current().state().texture.getImageImplementation(*this, level, pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().size(), image.data());
+    Context::current().state().texture.getImageImplementation(*this, level, pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().size(), image.data().data());
 }
 
 template void MAGNUM_GL_EXPORT AbstractTexture::image<1>(GLint, const BasicMutableImageView<1>&);
@@ -1848,11 +1848,11 @@ template<UnsignedInt dimensions> void AbstractTexture::compressedImage(const GLi
     /* Reallocate only if needed */
     Containers::Array<char> data{image.release()};
     if(data.size() < dataSize)
-        data = Containers::Array<char>{dataSize};
+        data = Containers::Array<char>{NoInit, dataSize};
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyCompressedPixelStoragePack(image.storage(), blockSize, blockDataSize);
-    Context::current().state().texture.getCompressedImageImplementation(*this, level, data.size(), data);
+    Context::current().state().texture.getCompressedImageImplementation(*this, level, data.size(), data.data());
     image = CompressedImage<dimensions>{image.storage(), UnsignedInt(format), blockSize, blockDataSize, size, Utility::move(data), flags};
 }
 
@@ -1884,7 +1884,7 @@ template<UnsignedInt dimensions> void AbstractTexture::compressedImage(const GLi
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyCompressedPixelStoragePack(image);
-    Context::current().state().texture.getCompressedImageImplementation(*this, level, image.data().size(), image.data());
+    Context::current().state().texture.getCompressedImageImplementation(*this, level, image.data().size(), image.data().data());
 }
 
 template void MAGNUM_GL_EXPORT AbstractTexture::compressedImage<1>(GLint, const BasicMutableCompressedImageView<1>&);
@@ -1937,7 +1937,7 @@ template<UnsignedInt dimensions> void AbstractTexture::subImage(const GLint leve
     const std::size_t dataSize = Magnum::Implementation::imageDataSizeFor(image, size);
     Containers::Array<char> data{image.release()};
     if(data.size() < dataSize)
-        data = Containers::Array<char>{dataSize};
+        data = Containers::Array<char>{NoInit, dataSize};
 
     image = Image<dimensions>{image.storage(), image.format(), image.formatExtra(), image.pixelSize(), size, Utility::move(data), flags};
     subImage(level, range, BasicMutableImageView<dimensions>(image));
@@ -1963,7 +1963,7 @@ template<UnsignedInt dimensions> void AbstractTexture::subImage(const GLint leve
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyPixelStoragePack(image.storage());
-    glGetTextureSubImage(_id, level, paddedOffset.x(), paddedOffset.y(), paddedOffset.z(), paddedSize.x(), paddedSize.y(), paddedSize.z(), GLenum(pixelFormat(image.format())), GLenum(pixelType(image.format(), image.formatExtra())), image.data().size(), image.data());
+    glGetTextureSubImage(_id, level, paddedOffset.x(), paddedOffset.y(), paddedOffset.z(), paddedSize.x(), paddedSize.y(), paddedSize.z(), GLenum(pixelFormat(image.format())), GLenum(pixelType(image.format(), image.formatExtra())), image.data().size(), image.data().data());
 }
 
 template void MAGNUM_GL_EXPORT AbstractTexture::subImage<1>(GLint, const Range1Di&, const BasicMutableImageView<1>&);
@@ -2025,11 +2025,11 @@ template<UnsignedInt dimensions> void AbstractTexture::compressedSubImage(const
     /* Reallocate only if needed */
     Containers::Array<char> data{image.release()};
     if(data.size() < dataSize)
-        data = Containers::Array<char>{dataSize};
+        data = Containers::Array<char>{NoInit, dataSize};
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyCompressedPixelStoragePack(image.storage(), blockSize, blockDataSize);
-    glGetCompressedTextureSubImage(_id, level, paddedOffset.x(), paddedOffset.y(), paddedOffset.z(), paddedSize.x(), paddedSize.y(), paddedSize.z(), data.size(), data);
+    glGetCompressedTextureSubImage(_id, level, paddedOffset.x(), paddedOffset.y(), paddedOffset.z(), paddedSize.x(), paddedSize.y(), paddedSize.z(), data.size(), data.data());
     image = CompressedImage<dimensions>{CompressedPixelFormat(format), size, Utility::move(data), flags};
 }
 
@@ -2067,7 +2067,7 @@ template<UnsignedInt dimensions> void AbstractTexture::compressedSubImage(const
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyCompressedPixelStoragePack(image);
-    glGetCompressedTextureSubImage(_id, level, paddedOffset.x(), paddedOffset.y(), paddedOffset.z(), paddedSize.x(), paddedSize.y(), paddedSize.z(), image.data().size(), image.data());
+    glGetCompressedTextureSubImage(_id, level, paddedOffset.x(), paddedOffset.y(), paddedOffset.z(), paddedSize.x(), paddedSize.y(), paddedSize.z(), image.data().size(), image.data().data());
 }
 
 template void MAGNUM_GL_EXPORT AbstractTexture::compressedSubImage<1>(GLint, const Range1Di&, const BasicMutableCompressedImageView<1>&);
@@ -2204,14 +2204,14 @@ void AbstractTexture::DataHelper<1>::setImage(AbstractTexture& texture, const GL
     Buffer::unbindInternal(Buffer::TargetHint::PixelUnpack);
     Context::current().state().renderer.applyPixelStorageUnpack(image.storage());
     texture.bindInternal();
-    glTexImage1D(texture._target, level, GLint(internalFormat), image.size()[0], 0, GLenum(pixelFormat(image.format())), GLenum(pixelType(image.format(), image.formatExtra())), image.data());
+    glTexImage1D(texture._target, level, GLint(internalFormat), image.size()[0], 0, GLenum(pixelFormat(image.format())), GLenum(pixelType(image.format(), image.formatExtra())), image.data().data());
 }
 
 void AbstractTexture::DataHelper<1>::setCompressedImage(AbstractTexture& texture, const GLint level, const CompressedImageView1D& image) {
     Buffer::unbindInternal(Buffer::TargetHint::PixelUnpack);
     Context::current().state().renderer.applyCompressedPixelStorageUnpack(image);
     texture.bindInternal();
-    glCompressedTexImage1D(texture._target, level, GLenum(compressedPixelFormat(image.format())), image.size()[0], 0, Implementation::occupiedCompressedImageDataSize(image), image.data());
+    glCompressedTexImage1D(texture._target, level, GLenum(compressedPixelFormat(image.format())), image.size()[0], 0, Implementation::occupiedCompressedImageDataSize(image), image.data().data());
 }
 
 void AbstractTexture::DataHelper<1>::setImage(AbstractTexture& texture, const GLint level, const TextureFormat internalFormat, BufferImage1D& image) {
@@ -2231,13 +2231,13 @@ void AbstractTexture::DataHelper<1>::setCompressedImage(AbstractTexture& texture
 void AbstractTexture::DataHelper<1>::setSubImage(AbstractTexture& texture, const GLint level, const Math::Vector<1, GLint>& offset, const ImageView1D& image) {
     Buffer::unbindInternal(Buffer::TargetHint::PixelUnpack);
     Context::current().state().renderer.applyPixelStorageUnpack(image.storage());
-    Context::current().state().texture.subImage1DImplementation(texture, level, offset, image.size(), pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data());
+    Context::current().state().texture.subImage1DImplementation(texture, level, offset, image.size(), pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().data());
 }
 
 void AbstractTexture::DataHelper<1>::setCompressedSubImage(AbstractTexture& texture, const GLint level, const Math::Vector<1, GLint>& offset, const CompressedImageView1D& image) {
     Buffer::unbindInternal(Buffer::TargetHint::PixelUnpack);
     Context::current().state().renderer.applyCompressedPixelStorageUnpack(image);
-    Context::current().state().texture.compressedSubImage1DImplementation(texture, level, offset, image.size(), compressedPixelFormat(image.format()), image.data(), Implementation::occupiedCompressedImageDataSize(image));
+    Context::current().state().texture.compressedSubImage1DImplementation(texture, level, offset, image.size(), compressedPixelFormat(image.format()), image.data().data(), Implementation::occupiedCompressedImageDataSize(image));
 }
 
 void AbstractTexture::DataHelper<1>::setSubImage(AbstractTexture& texture, const GLint level, const Math::Vector<1, GLint>& offset, BufferImage1D& image) {
@@ -2258,7 +2258,7 @@ void AbstractTexture::DataHelper<2>::setImage(AbstractTexture& texture, const GL
     Buffer::unbindInternal(Buffer::TargetHint::PixelUnpack);
     #endif
     Context::current().state().renderer.applyPixelStorageUnpack(image.storage());
-    Context::current().state().texture.image2DImplementation(texture, target, level, internalFormat, image.size(), pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data()
+    Context::current().state().texture.image2DImplementation(texture, target, level, internalFormat, image.size(), pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().data()
         #ifdef MAGNUM_TARGET_GLES2
         + Magnum::Implementation::pixelStorageSkipOffset(image)
         #endif
@@ -2271,7 +2271,7 @@ void AbstractTexture::DataHelper<2>::setCompressedImage(AbstractTexture& texture
     #endif
     Context::current().state().renderer.applyCompressedPixelStorageUnpack(image);
     texture.bindInternal();
-    glCompressedTexImage2D(target, level, GLenum(compressedPixelFormat(image.format())), image.size().x(), image.size().y(), 0, Implementation::occupiedCompressedImageDataSize(image), image.data());
+    glCompressedTexImage2D(target, level, GLenum(compressedPixelFormat(image.format())), image.size().x(), image.size().y(), 0, Implementation::occupiedCompressedImageDataSize(image), image.data().data());
 }
 
 #ifndef MAGNUM_TARGET_GLES2
@@ -2295,7 +2295,7 @@ void AbstractTexture::DataHelper<2>::setSubImage(AbstractTexture& texture, const
     Buffer::unbindInternal(Buffer::TargetHint::PixelUnpack);
     #endif
     Context::current().state().renderer.applyPixelStorageUnpack(image.storage());
-    Context::current().state().texture.subImage2DImplementation(texture, level, offset, image.size(), pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data()
+    Context::current().state().texture.subImage2DImplementation(texture, level, offset, image.size(), pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().data()
         #ifdef MAGNUM_TARGET_GLES2
         + Magnum::Implementation::pixelStorageSkipOffset(image)
         #endif
@@ -2307,7 +2307,7 @@ void AbstractTexture::DataHelper<2>::setCompressedSubImage(AbstractTexture& text
     Buffer::unbindInternal(Buffer::TargetHint::PixelUnpack);
     #endif
     Context::current().state().renderer.applyCompressedPixelStorageUnpack(image);
-    Context::current().state().texture.compressedSubImage2DImplementation(texture, level, offset, image.size(), compressedPixelFormat(image.format()), image.data(), Implementation::occupiedCompressedImageDataSize(image));
+    Context::current().state().texture.compressedSubImage2DImplementation(texture, level, offset, image.size(), compressedPixelFormat(image.format()), image.data().data(), Implementation::occupiedCompressedImageDataSize(image));
 }
 
 #ifndef MAGNUM_TARGET_GLES2
@@ -2330,7 +2330,7 @@ void AbstractTexture::DataHelper<3>::setImage(AbstractTexture& texture, const GL
     Buffer::unbindInternal(Buffer::TargetHint::PixelUnpack);
     #endif
     Context::current().state().renderer.applyPixelStorageUnpack(image.storage());
-    Context::current().state().texture.image3DImplementation(texture, level, internalFormat, image.size(), pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data()
+    Context::current().state().texture.image3DImplementation(texture, level, internalFormat, image.size(), pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().data()
         #ifdef MAGNUM_TARGET_GLES2
         + Magnum::Implementation::pixelStorageSkipOffset(image)
         #endif
@@ -2344,9 +2344,9 @@ void AbstractTexture::DataHelper<3>::setCompressedImage(AbstractTexture& texture
     Context::current().state().renderer.applyCompressedPixelStorageUnpack(image);
     texture.bindInternal();
     #ifndef MAGNUM_TARGET_GLES2
-    glCompressedTexImage3D(texture._target, level, GLenum(compressedPixelFormat(image.format())), image.size().x(), image.size().y(), image.size().z(), 0, Implementation::occupiedCompressedImageDataSize(image), image.data());
+    glCompressedTexImage3D(texture._target, level, GLenum(compressedPixelFormat(image.format())), image.size().x(), image.size().y(), image.size().z(), 0, Implementation::occupiedCompressedImageDataSize(image), image.data().data());
     #else
-    glCompressedTexImage3DOES(texture._target, level, GLenum(compressedPixelFormat(image.format())), image.size().x(), image.size().y(), image.size().z(), 0, Implementation::occupiedCompressedImageDataSize(image), image.data());
+    glCompressedTexImage3DOES(texture._target, level, GLenum(compressedPixelFormat(image.format())), image.size().x(), image.size().y(), image.size().z(), 0, Implementation::occupiedCompressedImageDataSize(image), image.data().data());
     #endif
 }
 #endif
@@ -2373,7 +2373,7 @@ void AbstractTexture::DataHelper<3>::setSubImage(AbstractTexture& texture, const
     Buffer::unbindInternal(Buffer::TargetHint::PixelUnpack);
     #endif
     Context::current().state().renderer.applyPixelStorageUnpack(image.storage());
-    Context::current().state().texture.subImage3DImplementation(texture, level, offset, image.size(), pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data()
+    Context::current().state().texture.subImage3DImplementation(texture, level, offset, image.size(), pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().data()
         #ifdef MAGNUM_TARGET_GLES2
         + Magnum::Implementation::pixelStorageSkipOffset(image)
         #endif
@@ -2385,7 +2385,7 @@ void AbstractTexture::DataHelper<3>::setCompressedSubImage(AbstractTexture& text
     Buffer::unbindInternal(Buffer::TargetHint::PixelUnpack);
     #endif
     Context::current().state().renderer.applyCompressedPixelStorageUnpack(image);
-    Context::current().state().texture.compressedSubImage3DImplementation(texture, level, offset, image.size(), compressedPixelFormat(image.format()), image.data(), Implementation::occupiedCompressedImageDataSize(image));
+    Context::current().state().texture.compressedSubImage3DImplementation(texture, level, offset, image.size(), compressedPixelFormat(image.format()), image.data().data(), Implementation::occupiedCompressedImageDataSize(image));
 }
 #endif
 

src/Magnum/GL/Buffer.cpp

@@ -401,12 +401,12 @@ Containers::Array<char> Buffer::data() {
 #endif
 
 Buffer& Buffer::setData(const Containers::ArrayView<const void> data, const BufferUsage usage) {
-    Context::current().state().buffer.dataImplementation(*this, data.size(), data, usage);
+    Context::current().state().buffer.dataImplementation(*this, data.size(), data.data(), usage);
     return *this;
 }
 
 Buffer& Buffer::setSubData(const GLintptr offset, const Containers::ArrayView<const void> data) {
-    Context::current().state().buffer.subDataImplementation(*this, offset, data.size(), data);
+    Context::current().state().buffer.subDataImplementation(*this, offset, data.size(), data.data());
     return *this;
 }
 
@@ -441,7 +441,7 @@ bool Buffer::unmap() { return Context::current().state().buffer.unmapImplementat
 Containers::Array<char> Buffer::subData(const GLintptr offset, const GLsizeiptr size) {
     Containers::Array<char> data{NoInit, std::size_t(size)};
     if(size)
-        Context::current().state().buffer.getSubDataImplementation(*this, offset, size, data);
+        Context::current().state().buffer.getSubDataImplementation(*this, offset, size, data.data());
     return data;
 }
 #endif
@@ -458,7 +458,7 @@ void Buffer::bindImplementationFallback(const Target target, const GLuint firstI
 #ifndef MAGNUM_TARGET_GLES
 void Buffer::bindImplementationMulti(const Target target, const GLuint firstIndex, Containers::ArrayView<Buffer* const> buffers) {
     /** @todo C++1z: VLAs? */
-    Containers::Array<GLuint> ids{buffers ? buffers.size() : 0};
+    Containers::Array<GLuint> ids{NoInit, buffers ? buffers.size() : 0};
     if(buffers) for(std::size_t i = 0; i != buffers.size(); ++i) {
         if(buffers[i]) {
             buffers[i]->createIfNotAlready();
@@ -472,7 +472,7 @@ void Buffer::bindImplementationMulti(const Target target, const GLuint firstInde
        binding points:
         https://registry.khronos.org/OpenGL-Refpages/gl4/html/glBindBuffersBase.xhtml
        See the comment in that function for details. */
-    glBindBuffersBase(GLenum(target), firstIndex, buffers.size(), ids);
+    glBindBuffersBase(GLenum(target), firstIndex, buffers.size(), ids.data());
 }
 #endif
 
@@ -487,8 +487,8 @@ void Buffer::bindImplementationFallback(const Target target, const GLuint firstI
 #ifndef MAGNUM_TARGET_GLES
 void Buffer::bindImplementationMulti(const Target target, const GLuint firstIndex, Containers::ArrayView<const Containers::Triple<Buffer*, GLintptr, GLsizeiptr>> buffers) {
     /** @todo use ArrayTuple */
-    Containers::Array<GLuint> ids{buffers ? buffers.size() : 0};
-    Containers::Array<GLintptr> offsetsSizes{buffers ? buffers.size()*2 : 0};
+    Containers::Array<GLuint> ids{NoInit, buffers ? buffers.size() : 0};
+    Containers::Array<GLintptr> offsetsSizes{NoInit, buffers ? buffers.size()*2 : 0};
     if(buffers) for(std::size_t i = 0; i != buffers.size(); ++i) {
         if(buffers[i].first()) {
             buffers[i].first()->createIfNotAlready();
@@ -503,7 +503,7 @@ void Buffer::bindImplementationMulti(const Target target, const GLuint firstInde
         }
     }
 
-    glBindBuffersRange(GLenum(target), firstIndex, buffers.size(), ids, offsetsSizes, offsetsSizes + buffers.size());
+    glBindBuffersRange(GLenum(target), firstIndex, buffers.size(), ids.data(), offsetsSizes.data(), offsetsSizes.data() + buffers.size());
 }
 #endif
 

src/Magnum/GL/Context.cpp

@@ -1170,7 +1170,7 @@ Containers::Array<Containers::StringView> Context::shadingLanguageVersionStrings
         /* If on GL 4.3+, there should be always at least one */
         CORRADE_INTERNAL_ASSERT(versionCount);
 
-        Containers::Array<Containers::StringView> versions{std::size_t(versionCount)};
+        Containers::Array<Containers::StringView> versions{ValueInit, std::size_t(versionCount)};
         for(GLint i = 0; i != versionCount; ++i)
             versions[i] = {reinterpret_cast<const char*>(glGetStringi(GL_SHADING_LANGUAGE_VERSION, i)), Containers::StringViewFlag::Global};
         return versions;
@@ -1193,7 +1193,7 @@ Containers::Array<Containers::StringView> Context::extensionStrings() const {
     {
         GLint extensionCount = 0;
         glGetIntegerv(GL_NUM_EXTENSIONS, &extensionCount);
-        Containers::Array<Containers::StringView> extensions{std::size_t(extensionCount)};
+        Containers::Array<Containers::StringView> extensions{ValueInit, std::size_t(extensionCount)};
         for(GLint i = 0; i != extensionCount; ++i)
             extensions[i] = {reinterpret_cast<const char*>(glGetStringi(GL_EXTENSIONS, i)), Containers::StringViewFlag::Global};
         return extensions;

src/Magnum/GL/CubeMapTexture.cpp

@@ -105,11 +105,11 @@ void CubeMapTexture::image(const Int level, Image3D& image) {
     /* Reallocate only if needed */
     Containers::Array<char> data{image.release()};
     if(data.size() < dataSize)
-        data = Containers::Array<char>{dataSize};
+        data = Containers::Array<char>{NoInit, dataSize};
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyPixelStoragePack(image.storage());
-    Context::current().state().texture.getCubeImage3DImplementation(*this, level, size, pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), data.size(), data, image.storage());
+    Context::current().state().texture.getCubeImage3DImplementation(*this, level, size, pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), data.size(), data.data(), image.storage());
     image = Image3D{image.storage(), image.format(), image.formatExtra(), image.pixelSize(), size, Utility::move(data), ImageFlag3D::CubeMap};
 }
 
@@ -127,7 +127,7 @@ void CubeMapTexture::image(const Int level, const MutableImageView3D& image) {
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyPixelStoragePack(image.storage());
-    Context::current().state().texture.getCubeImage3DImplementation(*this, level, size, pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().size(), image.data(), image.storage());
+    Context::current().state().texture.getCubeImage3DImplementation(*this, level, size, pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().size(), image.data().data(), image.storage());
 }
 
 void CubeMapTexture::image(const Int level, BufferImage3D& image, const BufferUsage usage) {
@@ -181,11 +181,11 @@ void CubeMapTexture::compressedImage(const Int level, CompressedImage3D& image)
     /* Reallocate only if needed */
     Containers::Array<char> data{image.release()};
     if(data.size() < dataOffsetSize.first + dataOffsetSize.second)
-        data = Containers::Array<char>{dataOffsetSize.first + dataOffsetSize.second};
+        data = Containers::Array<char>{NoInit, dataOffsetSize.first + dataOffsetSize.second};
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyCompressedPixelStoragePack(image.storage(), blockSize, blockDataSize);
-    Context::current().state().texture.getCompressedCubeImage3DImplementation(*this, level, size.xy(), dataOffsetSize.first, dataOffsetSize.second, data);
+    Context::current().state().texture.getCompressedCubeImage3DImplementation(*this, level, size.xy(), dataOffsetSize.first, dataOffsetSize.second, data.data());
     image = CompressedImage3D{image.storage(), CompressedPixelFormat(format), size, Utility::move(data), ImageFlag3D::CubeMap};
 }
 
@@ -230,7 +230,7 @@ void CubeMapTexture::compressedImage(const Int level, const MutableCompressedIma
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyCompressedPixelStoragePack(image);
-    Context::current().state().texture.getCompressedCubeImage3DImplementation(*this, level, size.xy(), dataOffsetSize.first, dataOffsetSize.second, image.data());
+    Context::current().state().texture.getCompressedCubeImage3DImplementation(*this, level, size.xy(), dataOffsetSize.first, dataOffsetSize.second, image.data().data());
 }
 
 void CubeMapTexture::compressedImage(const Int level, CompressedBufferImage3D& image, const BufferUsage usage) {
@@ -288,11 +288,11 @@ void CubeMapTexture::image(const CubeMapCoordinate coordinate, const Int level,
     /* Reallocate only if needed */
     Containers::Array<char> data{image.release()};
     if(data.size() < dataSize)
-        data = Containers::Array<char>{dataSize};
+        data = Containers::Array<char>{NoInit, dataSize};
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyPixelStoragePack(image.storage());
-    Context::current().state().texture.getCubeImageImplementation(*this, coordinate, level, size, pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), data.size(), data);
+    Context::current().state().texture.getCubeImageImplementation(*this, coordinate, level, size, pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), data.size(), data.data());
     image = Image2D{image.storage(), image.format(), image.formatExtra(), image.pixelSize(), size, Utility::move(data), ImageFlags2D{}};
 }
 
@@ -310,7 +310,7 @@ void CubeMapTexture::image(const CubeMapCoordinate coordinate, const Int level,
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyPixelStoragePack(image.storage());
-    Context::current().state().texture.getCubeImageImplementation(*this, coordinate, level, size, pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().size(), image.data());
+    Context::current().state().texture.getCubeImageImplementation(*this, coordinate, level, size, pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().size(), image.data().data());
 }
 
 void CubeMapTexture::image(const CubeMapCoordinate coordinate, const Int level, BufferImage2D& image, const BufferUsage usage) {
@@ -361,11 +361,11 @@ void CubeMapTexture::compressedImage(const CubeMapCoordinate coordinate, const I
     /* Reallocate only if needed */
     Containers::Array<char> data{image.release()};
     if(data.size() < dataSize)
-        data = Containers::Array<char>{dataSize};
+        data = Containers::Array<char>{NoInit, dataSize};
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyCompressedPixelStoragePack(image.storage(), blockSize, blockDataSize);
-    Context::current().state().texture.getCompressedCubeImageImplementation(*this, coordinate, level, size, data.size(), data);
+    Context::current().state().texture.getCompressedCubeImageImplementation(*this, coordinate, level, size, data.size(), data.data());
     image = CompressedImage2D{image.storage(), CompressedPixelFormat(format), size, Utility::move(data), ImageFlags2D{}};
 }
 
@@ -401,7 +401,7 @@ void CubeMapTexture::compressedImage(const CubeMapCoordinate coordinate, const I
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyCompressedPixelStoragePack(image);
-    Context::current().state().texture.getCompressedCubeImageImplementation(*this, coordinate, level, size, image.data().size(), image.data());
+    Context::current().state().texture.getCompressedCubeImageImplementation(*this, coordinate, level, size, image.data().size(), image.data().data());
 }
 
 void CubeMapTexture::compressedImage(const CubeMapCoordinate coordinate, const Int level, CompressedBufferImage2D& image, const BufferUsage usage) {
@@ -487,11 +487,11 @@ void CubeMapTexture::compressedSubImage(const Int level, const Range3Di& range,
     /* Reallocate only if needed */
     Containers::Array<char> data{image.release()};
     if(data.size() < dataSize)
-        data = Containers::Array<char>{dataSize};
+        data = Containers::Array<char>{NoInit, dataSize};
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyCompressedPixelStoragePack(image.storage(), blockSize, blockDataSize);
-    glGetCompressedTextureSubImage(_id, level, range.min().x(), range.min().y(), range.min().z(), range.size().x(), range.size().y(), range.size().z(), data.size(), data);
+    glGetCompressedTextureSubImage(_id, level, range.min().x(), range.min().y(), range.min().z(), range.size().x(), range.size().y(), range.size().z(), data.size(), data.data());
     /* Would be CubeMap if the whole image was queried, but then we'd have to
        query the size and compare, which is extra work. So it's Array
        instead. */
@@ -532,7 +532,7 @@ void CubeMapTexture::compressedSubImage(const Int level, const Range3Di& range,
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
     Context::current().state().renderer.applyCompressedPixelStoragePack(image);
-    glGetCompressedTextureSubImage(_id, level, range.min().x(), range.min().y(), range.min().z(), range.size().x(), range.size().y(), range.size().z(), image.data().size(), image.data());
+    glGetCompressedTextureSubImage(_id, level, range.min().x(), range.min().y(), range.min().z(), range.size().x(), range.size().y(), range.size().z(), image.data().size(), image.data().data());
 }
 
 void CubeMapTexture::compressedSubImage(const Int level, const Range3Di& range, CompressedBufferImage3D& image, const BufferUsage usage) {
@@ -587,7 +587,7 @@ CubeMapTexture& CubeMapTexture::setSubImage(const Int level, const Vector3i& off
     Buffer::unbindInternal(Buffer::TargetHint::PixelUnpack);
     #endif
     Context::current().state().renderer.applyPixelStorageUnpack(image.storage());
-    Context::current().state().texture.cubeSubImage3DImplementation(*this, level, offset, image.size(), pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data()
+    Context::current().state().texture.cubeSubImage3DImplementation(*this, level, offset, image.size(), pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().data()
         #ifdef MAGNUM_TARGET_GLES2
         + Magnum::Implementation::pixelStorageSkipOffset(image)
         #endif
@@ -612,7 +612,7 @@ CubeMapTexture& CubeMapTexture::setCompressedSubImage(const Int level, const Vec
 
     Buffer::unbindInternal(Buffer::TargetHint::PixelUnpack);
     Context::current().state().renderer.applyCompressedPixelStorageUnpack(image);
-    glCompressedTextureSubImage3D(_id, level, offset.x(), offset.y(), offset.z(), image.size().x(), image.size().y(), image.size().z(), GLenum(compressedPixelFormat(image.format())), Implementation::occupiedCompressedImageDataSize(image), image.data());
+    glCompressedTextureSubImage3D(_id, level, offset.x(), offset.y(), offset.z(), image.size().x(), image.size().y(), image.size().z(), GLenum(compressedPixelFormat(image.format())), Implementation::occupiedCompressedImageDataSize(image), image.data().data());
     return *this;
 }
 
@@ -633,7 +633,7 @@ CubeMapTexture& CubeMapTexture::setSubImage(const CubeMapCoordinate coordinate,
     Buffer::unbindInternal(Buffer::TargetHint::PixelUnpack);
     #endif
     Context::current().state().renderer.applyPixelStorageUnpack(image.storage());
-    Context::current().state().texture.cubeSubImageImplementation(*this, coordinate, level, offset, image.size(), pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data()
+    Context::current().state().texture.cubeSubImageImplementation(*this, coordinate, level, offset, image.size(), pixelFormat(image.format()), pixelType(image.format(), image.formatExtra()), image.data().data()
         #ifdef MAGNUM_TARGET_GLES2
         + Magnum::Implementation::pixelStorageSkipOffset(image)
         #endif
@@ -655,7 +655,7 @@ CubeMapTexture& CubeMapTexture::setCompressedSubImage(const CubeMapCoordinate co
     Buffer::unbindInternal(Buffer::TargetHint::PixelUnpack);
     #endif
     Context::current().state().renderer.applyCompressedPixelStorageUnpack(image);
-    Context::current().state().texture.cubeCompressedSubImageImplementation(*this, coordinate, level, offset, image.size(), compressedPixelFormat(image.format()), image.data(), Implementation::occupiedCompressedImageDataSize(image));
+    Context::current().state().texture.cubeCompressedSubImageImplementation(*this, coordinate, level, offset, image.size(), compressedPixelFormat(image.format()), image.data().data(), Implementation::occupiedCompressedImageDataSize(image));
     return *this;
 }
 

src/Magnum/GL/DefaultFramebuffer.cpp

@@ -74,7 +74,7 @@ DefaultFramebuffer& DefaultFramebuffer::mapForDraw(const Containers::ArrayView<c
     for(const auto& attachment: attachments)
         _attachments[attachment.first()] = GLenum(attachment.second());
 
-    Context::current().state().framebuffer.drawBuffersImplementation(*this, max+1, _attachments);
+    Context::current().state().framebuffer.drawBuffersImplementation(*this, max+1, _attachments.data());
     return *this;
 }
 

src/Magnum/GL/Framebuffer.cpp

@@ -199,7 +199,7 @@ Framebuffer& Framebuffer::mapForDraw(const Containers::ArrayView<const Container
     for(const auto& attachment: attachments)
         _attachments[attachment.first()] = GLenum(attachment.second());
 
-    Context::current().state().framebuffer.drawBuffersImplementation(*this, max+1, _attachments);
+    Context::current().state().framebuffer.drawBuffersImplementation(*this, max+1, _attachments.data());
     return *this;
 }
 

src/Magnum/GL/Mesh.cpp

@@ -1501,7 +1501,7 @@ void Mesh::multiDrawElementsBaseVertexImplementationANGLE(const GLenum mode, con
     for(GLsizei& i: instanceCount)
         i = 1;
 
-    glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(mode, count, type, indices, instanceCount, baseVertex, baseInstance, drawCount);
+    glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(mode, count, type, indices, instanceCount.data(), baseVertex, baseInstance.data(), drawCount);
 }
 #endif
 

src/Magnum/GL/Shader.cpp

@@ -895,7 +895,7 @@ void Shader::submitCompile() {
         sizes[i] = _sources[i].size();
     }
 
-    glShaderSource(_id, _sources.size(), pointers, sizes);
+    glShaderSource(_id, _sources.size(), pointers.data(), sizes.data());
     glCompileShader(_id);
 }
 

src/Magnum/GL/Test/BufferImageGLTest.cpp

@@ -428,7 +428,7 @@ void BufferImageGLTest::constructInvalidSize() {
 
     Containers::String out;
     Error redirectError{&out};
-    BufferImage2D{Magnum::PixelFormat::RGB8Unorm, {1, 3}, Containers::Array<char>{11}, BufferUsage::StaticDraw};
+    BufferImage2D{Magnum::PixelFormat::RGB8Unorm, {1, 3}, Containers::Array<char>{NoInit, 11}, BufferUsage::StaticDraw};
     CORRADE_COMPARE(out, "GL::BufferImage: data too small, got 11 but expected at least 12 bytes\n");
 }
 
@@ -477,7 +477,7 @@ void BufferImageGLTest::constructCompressedInvalidSize() {
     {
         Containers::String out;
         Error redirectError{&out};
-        CompressedBufferImage2D{Magnum::CompressedPixelFormat::Bc2RGBAUnorm, {4, 4}, Containers::Array<char>{15}, BufferUsage::StaticDraw};
+        CompressedBufferImage2D{Magnum::CompressedPixelFormat::Bc2RGBAUnorm, {4, 4}, Containers::Array<char>{NoInit, 15}, BufferUsage::StaticDraw};
         /* Here it's assuming the buffer is already filled, of given size */
         CompressedBufferImage2D{Magnum::CompressedPixelFormat::Bc2RGBAUnorm, {4, 4}, GL::Buffer{}, 15};
         CORRADE_COMPARE_AS(out,
@@ -489,7 +489,7 @@ void BufferImageGLTest::constructCompressedInvalidSize() {
     } {
         Containers::String out;
         Error redirectError{&out};
-        CompressedBufferImage2D{Magnum::CompressedPixelFormat::Bc2RGBAUnorm, {2, 2}, Containers::Array<char>{15}, BufferUsage::StaticDraw};
+        CompressedBufferImage2D{Magnum::CompressedPixelFormat::Bc2RGBAUnorm, {2, 2}, Containers::Array<char>{NoInit, 15}, BufferUsage::StaticDraw};
         /* Here it's assuming the buffer is already filled, of given size */
         CompressedBufferImage2D{Magnum::CompressedPixelFormat::Bc2RGBAUnorm, {2, 2}, GL::Buffer{}, 15};
         CORRADE_COMPARE_AS(out,
@@ -831,7 +831,7 @@ void BufferImageGLTest::setDataInvalidSize() {
 
     Containers::String out;
     Error redirectError{&out};
-    image.setData(PixelFormat::RGB, PixelType::UnsignedByte, {1, 3},  Containers::Array<char>{11}, BufferUsage::StaticDraw);
+    image.setData(PixelFormat::RGB, PixelType::UnsignedByte, {1, 3},  Containers::Array<char>{NoInit, 11}, BufferUsage::StaticDraw);
     /* Keeping current storage */
     image.setData(PixelFormat::RGBA, PixelType::UnsignedByte, {2, 1},  nullptr, BufferUsage::StaticDraw);
     CORRADE_COMPARE_AS(out,

src/Magnum/GL/Test/BufferTextureGLTest.cpp

@@ -522,10 +522,10 @@ void BufferTextureGLTest::appleSetBufferMapRange() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     /* This also crashes unless worked around. Ugh. */
-    char* ptr = buffer.map(0, 16, Buffer::MapFlag::Write|Buffer::MapFlag::FlushExplicit);
-    CORRADE_VERIFY(ptr);
+    Containers::ArrayView<char> array = buffer.map(0, 16, Buffer::MapFlag::Write|Buffer::MapFlag::FlushExplicit);
+    CORRADE_VERIFY(array.data());
 
-    ptr[12] = 0x35;
+    array[12] = 0x35;
 
     /* This doesn't, it seems (yay!) */
     buffer.flushMappedRange(8, 8);

src/Magnum/GL/Test/ContextGLTest.cpp

@@ -274,7 +274,7 @@ void ContextGLTest::constructConfiguration() {
         Containers::ScopeGuard resetCurrent{current, Context::makeCurrent};
 
         Debug redirectOut{&out};
-        Platform::GLContext ctx{Int(data.args.size()), data.args, Context::Configuration{}
+        Platform::GLContext ctx{Int(data.args.size()), data.args.data(), Context::Configuration{}
             .setFlags(data.flags)
             .addDisabledWorkarounds(data.disabledWorkarounds)
             .addDisabledExtensions(data.disabledExtensions)
@@ -311,7 +311,7 @@ void ContextGLTest::constructMove() {
 
     /* First gather just the command-line parameters. Nothing to verify here as
        it's not initialized yet. */
-    Platform::GLContext a{NoCreate, Int(data.args.size()), data.args};
+    Platform::GLContext a{NoCreate, Int(data.args.size()), data.args.data()};
 
     /* The context is not created yet, so it doesn't set it as current yet */
     CORRADE_VERIFY(!Context::hasCurrent());

src/Magnum/GL/Test/CubeMapTextureArrayGLTest.cpp

@@ -824,7 +824,7 @@ void CubeMapTextureArrayGLTest::imageQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*6*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*6*4};
     MutableImageView3D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, imageData, ImageFlag3D::Array};
     texture.image(0, image);
 
@@ -952,7 +952,7 @@ void CubeMapTextureArrayGLTest::compressedImageQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 6*16};
+    Containers::Array<char> imageData{NoInit, data.offset + 6*16};
     MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, imageData, ImageFlag3D::Array};
     texture.compressedImage(0, image);
 
@@ -1117,7 +1117,7 @@ void CubeMapTextureArrayGLTest::subImageQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*4*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*4*4};
     MutableImageView3D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 4}, imageData, ImageFlag3D::Array};
     texture.subImage(0, Range3Di::fromSize(Vector3i{1}, {2, 2, 4}), image);
 
@@ -1370,7 +1370,7 @@ void CubeMapTextureArrayGLTest::compressedSubImageQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 4*16};
+    Containers::Array<char> imageData{NoInit, data.offset + 4*16};
     MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 4}, imageData, ImageFlag3D::Array};
     texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 1}, Vector3i{4}), image);
 

src/Magnum/GL/Test/CubeMapTextureGLTest.cpp

@@ -1092,7 +1092,7 @@ void CubeMapTextureGLTest::imageQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*4};
     MutableImageView2D image{data.storage,
             PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array};
     texture.image(CubeMapCoordinate::PositiveY, 0, image);
@@ -1367,7 +1367,7 @@ void CubeMapTextureGLTest::compressedImageQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 16};
+    Containers::Array<char> imageData{NoInit, data.offset + 16};
     MutableCompressedImageView2D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, imageData, ImageFlag2D::Array};
     texture.compressedImage(CubeMapCoordinate::PositiveZ, 0, image);
 
@@ -1702,7 +1702,7 @@ void CubeMapTextureGLTest::image3DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*6*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*6*4};
     MutableImageView3D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 6}, imageData, ImageFlag3D::Array};
     texture.image(0, image);
 
@@ -1794,7 +1794,7 @@ void CubeMapTextureGLTest::subImage3DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*4};
     MutableImageView3D image{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, {2, 2, 1}, imageData, ImageFlag3D::Array};
     texture.subImage(0, Range3Di::fromSize({1, 1, 0}, {2, 2, 1}), image);
@@ -1971,7 +1971,7 @@ void CubeMapTextureGLTest::compressedImage3DQueryView() {
             CORRADE_SKIP("Skipping the rest of the test");
     }
 
-    Containers::Array<char> imageData{data.offset + 16*6};
+    Containers::Array<char> imageData{NoInit, data.offset + 16*6};
     MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 6}, imageData, ImageFlag3D::Array};
     texture.compressedImage(0, image);
 
@@ -2104,7 +2104,7 @@ void CubeMapTextureGLTest::compressedSubImage3DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 16};
+    Containers::Array<char> imageData{NoInit, data.offset + 16};
     MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 1}, imageData, ImageFlag3D::Array};
     texture.compressedSubImage(0, Range3Di::fromSize({4, 4, 0}, {4, 4, 1}), image);
 

src/Magnum/GL/Test/RectangleTextureGLTest.cpp

@@ -482,7 +482,7 @@ void RectangleTextureGLTest::imageQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*4};
     MutableImageView2D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array};
     texture.image(image);
 
@@ -602,7 +602,7 @@ void RectangleTextureGLTest::subImageQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*4};
     MutableImageView2D image{data.storage, PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array};
     texture.subImage(Range2Di::fromSize(Vector2i{1}, Vector2i{2}), image);
 

src/Magnum/GL/Test/TextureArrayGLTest.cpp

@@ -1261,7 +1261,7 @@ void TextureArrayGLTest::image1DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*4};
     MutableImageView2D image{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array};
     texture.image(0, image);
@@ -1382,7 +1382,7 @@ void TextureArrayGLTest::subImage1DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*4};
     MutableImageView2D image{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array};
     texture.subImage(0, Range2Di::fromSize(Vector2i{1}, Vector2i{2}), image);
@@ -1541,7 +1541,7 @@ void TextureArrayGLTest::image2DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*2*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*2*4};
     MutableImageView3D image{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, imageData};
     texture.image(0, image);
@@ -1691,7 +1691,7 @@ void TextureArrayGLTest::subImage2DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*2*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*2*4};
     MutableImageView3D image{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, imageData, ImageFlag3D::Array};
     texture.subImage(0, Range3Di::fromSize(Vector3i{1}, Vector3i{2}), image);
@@ -1847,7 +1847,7 @@ void TextureArrayGLTest::compressedImage2DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*16};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*16};
     MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, imageData};
     texture.compressedImage(0, image);
 
@@ -2042,7 +2042,7 @@ void TextureArrayGLTest::compressedSubImage2DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*16};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*16};
     MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, {4, 4, 2}, imageData, ImageFlag3D::Array};
     texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 1}, {4, 4, 2}), image);
 

src/Magnum/GL/Test/TextureGLTest.cpp

@@ -1853,7 +1853,7 @@ void TextureGLTest::image1DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*4};
     MutableImageView1D image{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, 2, imageData};
     texture.image(0, image);
@@ -1961,7 +1961,7 @@ void TextureGLTest::subImage1DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*4};
     MutableImageView1D image{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, 2, imageData};
     texture.subImage(0, Range1Di::fromSize(1, 2), image);
@@ -2121,7 +2121,7 @@ void TextureGLTest::image2DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*4};
     MutableImageView2D image{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array};
     texture.image(0, image);
@@ -2258,7 +2258,7 @@ void TextureGLTest::subImage2DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*4};
     MutableImageView2D image{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, imageData, ImageFlag2D::Array};
     texture.subImage(0, Range2Di::fromSize(Vector2i{1}, Vector2i{2}), image);
@@ -2405,7 +2405,7 @@ void TextureGLTest::compressedImage2DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 1*16};
+    Containers::Array<char> imageData{NoInit, data.offset + 1*16};
     MutableCompressedImageView2D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, imageData, ImageFlag2D::Array};
     texture.compressedImage(0, image);
 
@@ -2571,7 +2571,7 @@ void TextureGLTest::compressedSubImage2DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 1*16};
+    Containers::Array<char> imageData{NoInit, data.offset + 1*16};
     MutableCompressedImageView2D image{data.storage, CompressedPixelFormat::RGBAS3tcDxt3, Vector2i{4}, imageData, ImageFlag2D::Array};
     texture.compressedSubImage(0, Range2Di::fromSize({4, 0}, Vector2i{4}), image);
 
@@ -2694,7 +2694,7 @@ void TextureGLTest::image3DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*2*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*2*4};
     MutableImageView3D image{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, imageData, ImageFlag3D::Array};
     texture.image(0, image);
@@ -2839,7 +2839,7 @@ void TextureGLTest::subImage3DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 2*2*2*4};
+    Containers::Array<char> imageData{NoInit, data.offset + 2*2*2*4};
     MutableImageView3D image{data.storage,
         PixelFormat::RGBA, PixelType::UnsignedByte, Vector3i{2}, imageData, ImageFlag3D::Array};
     texture.subImage(0, Range3Di::fromSize(Vector3i{1}, Vector3i{2}), image);
@@ -2986,7 +2986,7 @@ void TextureGLTest::compressedImage3DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 64};
+    Containers::Array<char> imageData{NoInit, data.offset + 64};
     MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, imageData, ImageFlag3D::Array};
     texture.compressedImage(0, image);
 
@@ -3200,7 +3200,7 @@ void TextureGLTest::compressedSubImage3DQueryView() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
 
-    Containers::Array<char> imageData{data.offset + 64};
+    Containers::Array<char> imageData{NoInit, data.offset + 64};
     MutableCompressedImageView3D image{data.storage, CompressedPixelFormat::RGBABptcUnorm, Vector3i{4}, imageData, ImageFlag3D::Array};
     texture.compressedSubImage(0, Range3Di::fromSize({4, 0, 0}, Vector3i{4}), image);
 

src/Magnum/Implementation/ImageProperties.h

@@ -234,7 +234,7 @@ template<UnsignedInt dimensions, class T, class Image, class Data> Containers::S
 
     static_assert(sizeof(decltype(image.data().front())) == 1,
         "pointer arithmetic expects image data type to have 1 byte");
-    return {data.exceptPrefix(properties.first[dimensions - 1]), data + properties.first.sum(), size, stride};
+    return {data.exceptPrefix(properties.first[dimensions - 1]), data.data() + properties.first.sum(), size, stride};
 }
 
 }}

src/Magnum/MaterialTools/Filter.cpp

@@ -102,7 +102,7 @@ Trade::MaterialData filterAttributesLayersImplementation(const Trade::MaterialDa
 
     /* Copy attributes that aren't filtered away. Not using NoInit in order to
        use the default deleter and have this usable from plugins. */
-    Containers::Array<Trade::MaterialAttributeData> attributes{patchedInputAttributesToKeep.count()};
+    Containers::Array<Trade::MaterialAttributeData> attributes{ValueInit, patchedInputAttributesToKeep.count()};
     Utility::copyMasked(material.attributeData(), patchedInputAttributesToKeep, attributes);
 
     return Trade::MaterialData{material.types() & typesToKeep, Utility::move(attributes), Utility::move(layers)};

src/Magnum/MaterialTools/Test/CopyTest.cpp

@@ -103,7 +103,7 @@ void CopyTest::singleLayerNoLayerData() {
     CORRADE_COMPARE(copy.layerDataFlags(), Trade::DataFlag::Owned|Trade::DataFlag::Mutable);
     CORRADE_COMPARE(copy.layerCount(), 1);
     CORRADE_COMPARE(copy.layerData().size(), 0);
-    CORRADE_COMPARE(copy.layerData(), nullptr);
+    CORRADE_COMPARE(copy.layerData().data(), nullptr);
 
     CORRADE_COMPARE(copy.attributeDataFlags(), Trade::DataFlag::Owned|Trade::DataFlag::Mutable);
     CORRADE_COMPARE(copy.attributeCount(), 3);
@@ -209,7 +209,7 @@ void CopyTest::rvalueOwnedAttributesNoLayerData() {
     CORRADE_COMPARE(copy.layerDataFlags(), Trade::DataFlag::Owned|Trade::DataFlag::Mutable);
     CORRADE_COMPARE(copy.layerCount(), 1);
     CORRADE_COMPARE(copy.layerData().size(), 0);
-    CORRADE_COMPARE(copy.layerData(), nullptr);
+    CORRADE_COMPARE(copy.layerData().data(), nullptr);
 
     CORRADE_COMPARE(copy.attributeDataFlags(), Trade::DataFlag::Owned|Trade::DataFlag::Mutable);
     CORRADE_COMPARE(copy.attributeData().data(), originalAttributes);

src/Magnum/MeshTools/CompressIndices.cpp

@@ -166,7 +166,7 @@ Trade::MeshData compressIndices(Trade::MeshData&& mesh, MeshIndexType atLeast) {
     /* Recreate the attribute array with each attribute being shifted by the
        offset calculated above */
     const UnsignedInt newVertexCount = vertexCount - offset;
-    Containers::Array<Trade::MeshAttributeData> attributeData{mesh.attributeCount()};
+    Containers::Array<Trade::MeshAttributeData> attributeData{ValueInit, mesh.attributeCount()};
     for(UnsignedInt i = 0, max = attributeData.size(); i != max; ++i) {
         attributeData[i] = Implementation::remapAttributeData(mesh.attributeData(i), newVertexCount, originalVertexData, vertexData.exceptPrefix(offset*mesh.attributeStride(i)));
     }
@@ -195,7 +195,7 @@ template<class T> Containers::Array<T> compressIndicesAs(const std::vector<Unsig
     CORRADE_ASSERT(Math::log(256, max) < sizeof(T), "MeshTools::compressIndicesAs(): type too small to represent value" << max, {});
     #endif
 
-    Containers::Array<T> buffer(indices.size());
+    Containers::Array<T> buffer{NoInit, indices.size()};
     for(std::size_t i = 0; i != indices.size(); ++i)
         buffer[i] = T(indices[i]);
 

src/Magnum/MeshTools/GenerateIndices.cpp

@@ -632,7 +632,7 @@ Trade::MeshData generateIndices(Trade::MeshData&& mesh) {
     /* Recreate the attribute array with views on the new vertexData */
     /** @todo if the vertex data were moved and this array is owned, it
         wouldn't need to be recreated, but the logic is a bit complex */
-    Containers::Array<Trade::MeshAttributeData> attributeData{mesh.attributeCount()};
+    Containers::Array<Trade::MeshAttributeData> attributeData{ValueInit, mesh.attributeCount()};
     for(UnsignedInt i = 0, max = attributeData.size(); i != max; ++i)
         attributeData[i] = Implementation::remapAttributeData(mesh.attributeData(i), vertexCount, originalVertexData, vertexData);
 

src/Magnum/MeshTools/Implementation/Tipsify.h

@@ -38,7 +38,7 @@ namespace Magnum { namespace MeshTools { namespace Implementation { namespace {
 template<class T> void buildAdjacency(const Containers::StridedArrayView1D<const T>& indices, const UnsignedInt vertexCount, Containers::Array<UnsignedInt>& liveTriangleCount, Containers::Array<UnsignedInt>& neighborOffset, Containers::Array<UnsignedInt>& neighbors) {
     /* How many times is each vertex referenced == count of neighboring
        triangles for each vertex */
-    liveTriangleCount = Containers::Array<UnsignedInt>{vertexCount};
+    liveTriangleCount = Containers::Array<UnsignedInt>{ValueInit, vertexCount};
     for(std::size_t i = 0; i != indices.size(); ++i)
         ++liveTriangleCount[indices[i]];
 

src/Magnum/MeshTools/Interleave.cpp

@@ -198,7 +198,7 @@ Containers::Array<Trade::MeshAttributeData> interleavedLayout(Trade::MeshData&&
     if(!extraAttributeCount && !originalAttributeData.deleter())
         attributeData = Utility::move(originalAttributeData);
     else {
-        attributeData = Containers::Array<Trade::MeshAttributeData>{originalAttributeCount + extraAttributeCount};
+        attributeData = Containers::Array<Trade::MeshAttributeData>{ValueInit, originalAttributeCount + extraAttributeCount};
         Utility::copy(originalAttributeData, attributeData.prefix(originalAttributeCount));
     }
 

src/Magnum/MeshTools/RemoveDuplicates.cpp

@@ -88,7 +88,7 @@ std::size_t removeDuplicatesInto(const Containers::StridedArrayView2D<const char
         /* Try to insert new entry into the table. The inserted index points
            into the original unchanged data array. */
         const Containers::ArrayView<const char> entry = data[i].asContiguous();
-        const auto result = table.emplace(entry, i);
+        const auto result = table.emplace(entry.data(), i);
 
         /* Put the (either new or already existing) index into the output
            index array */
@@ -146,7 +146,7 @@ std::size_t removeDuplicatesInPlaceInto(const Containers::StridedArrayView2D<cha
 
         /* Insert the new entry into the table. If it succeeds, dst is
            guaranteed to not change anymore. */
-        const auto result = table.emplace(dst, table.size());
+        const auto result = table.emplace(dst.data(), table.size());
 
         /* Put the (either new or already existing) index into the output index
            array */
@@ -280,7 +280,7 @@ template<class IndexType, class T> std::size_t removeDuplicatesFuzzyIndexedInPla
                This is a similar workflow to removeDuplicatesInPlaceInto() with
                the only difference that we're remapping an existing index array
                several times over instead of creating a new one */
-            const auto result = table.emplace(discretizedEntry, table.size());
+            const auto result = table.emplace(discretizedEntry.data(), table.size());
 
             /* Add the (either new or already existing) index into the array */
             remapping[i] = result.first->second;
@@ -459,7 +459,7 @@ Trade::MeshData removeDuplicates(const Trade::MeshData& mesh) {
         Containers::StridedArrayView2D<char>{uniqueVertexData, {uniqueVertexCount, vertexData.size()[1]}});
 
     /* Route all attributes to the new vertex data */
-    Containers::Array<Trade::MeshAttributeData> attributeData{ownedInterleaved.attributeCount()};
+    Containers::Array<Trade::MeshAttributeData> attributeData{ValueInit, ownedInterleaved.attributeCount()};
     for(UnsignedInt i = 0; i != ownedInterleaved.attributeCount(); ++i)
         attributeData[i] = Implementation::remapAttributeData(ownedInterleaved.attributeData(i), uniqueVertexCount, ownedInterleaved.vertexData(), uniqueVertexData);
 

src/Magnum/MeshTools/Test/CompressIndicesTest.cpp

@@ -311,7 +311,7 @@ template<class T> void CompressIndicesTest::compressMeshData() {
 }
 
 void CompressIndicesTest::compressMeshDataMove() {
-    Containers::Array<char> vertexData{103*24};
+    Containers::Array<char> vertexData{NoInit, 103*24};
     Containers::StridedArrayView1D<Vector2> positionView{vertexData,
         reinterpret_cast<Vector2*>(vertexData.data()), 103, 8};
     Containers::StridedArrayView1D<Vector3> normalView{vertexData,

src/Magnum/MeshTools/Test/ConcatenateTest.cpp

@@ -467,16 +467,16 @@ void ConcatenateTest::concatenateNone() {
 }
 
 void ConcatenateTest::concatenateInto() {
-    Containers::Array<Trade::MeshAttributeData> attributeData{2};
+    Containers::Array<Trade::MeshAttributeData> attributeData{ValueInit, 2};
     Containers::Array<char> vertexData;
     Containers::Array<char> indexData;
     arrayResize(vertexData, DirectInit, (sizeof(Vector2) + sizeof(Vector3))*7, '\xff');
     arrayClear(vertexData);
     arrayResize(indexData, DirectInit, sizeof(UnsignedInt)*9, '\xff');
     arrayClear(indexData);
-    const void* attributeDataPointer = attributeData;
-    const void* vertexDataPointer = vertexData;
-    const void* indexDataPointer = indexData;
+    const void* attributeDataPointer = attributeData.data();
+    const void* vertexDataPointer = vertexData.data();
+    const void* indexDataPointer = indexData.data();
 
     attributeData[0] = Trade::MeshAttributeData{Trade::MeshAttribute::Position,
         VertexFormat::Vector2, nullptr};
@@ -549,13 +549,13 @@ void ConcatenateTest::concatenateInto() {
 }
 
 void ConcatenateTest::concatenateIntoNoIndexArray() {
-    Containers::Array<Trade::MeshAttributeData> attributeData{1};
+    Containers::Array<Trade::MeshAttributeData> attributeData{ValueInit, 1};
     Containers::Array<char> vertexData;
     Containers::Array<char> indexData;
     arrayReserve(vertexData, sizeof(Vector2)*3);
     arrayReserve(indexData, sizeof(UnsignedInt));
-    const void* attributeDataPointer = attributeData;
-    const void* vertexDataPointer = vertexData;
+    const void* attributeDataPointer = attributeData.data();
+    const void* vertexDataPointer = vertexData.data();
 
     attributeData[0] = Trade::MeshAttributeData{Trade::MeshAttribute::Position,
         VertexFormat::Vector2, nullptr};
@@ -597,7 +597,7 @@ void ConcatenateTest::concatenateIntoNoIndexArray() {
 void ConcatenateTest::concatenateIntoNonOwnedAttributeArray() {
     Containers::Array<char> vertexData;
     arrayReserve(vertexData, sizeof(Vector2)*3);
-    const void* vertexDataPointer = vertexData;
+    const void* vertexDataPointer = vertexData.data();
 
     const Trade::MeshAttributeData attributeData[]{
         Trade::MeshAttributeData{Trade::MeshAttribute::Position,

src/Magnum/MeshTools/Test/CopyTest.cpp

@@ -314,7 +314,7 @@ void CopyTest::copyRvalueIndicesVerticesAttributesOwned() {
     Containers::Array<Trade::MeshAttributeData> attributes{ValueInit, 1};
     attributes[0] = Trade::MeshAttributeData{Trade::MeshAttribute::Position,
         Containers::arrayView(positions)};
-    const Trade::MeshAttributeData* originalAttributes = attributes;
+    const Trade::MeshAttributeData* originalAttributes = attributes.data();
 
     Trade::MeshData copy = MeshTools::copy(Trade::MeshData{MeshPrimitive::Triangles,
         Utility::move(indexData), Trade::MeshIndexData{indices},
@@ -336,8 +336,8 @@ void CopyTest::copyRvalueIndicesVerticesAttributesOwned() {
         TestSuite::Compare::Container);
 
     /* All data should be transferred without any copy */
-    CORRADE_COMPARE(copy.indexData().data(), static_cast<const void*>(indices));
-    CORRADE_COMPARE(copy.vertexData().data(), static_cast<void*>(positions));
+    CORRADE_COMPARE(copy.indexData().data(), static_cast<const void*>(indices.data()));
+    CORRADE_COMPARE(copy.vertexData().data(), static_cast<void*>(positions.data()));
     CORRADE_COMPARE(copy.attributeData().data(), originalAttributes);
 }
 
@@ -352,7 +352,7 @@ void CopyTest::copyRvalueAttributesOwned() {
     Containers::Array<Trade::MeshAttributeData> attributes{ValueInit, 1};
     attributes[0] = Trade::MeshAttributeData{Trade::MeshAttribute::Position,
         Containers::arrayView(positions)};
-    const Trade::MeshAttributeData* originalAttributes = attributes;
+    const Trade::MeshAttributeData* originalAttributes = attributes.data();
 
     Trade::MeshData copy = MeshTools::copy(Trade::MeshData{MeshPrimitive::Triangles, {}, positions, Utility::move(attributes)});
     CORRADE_COMPARE(copy.primitive(), MeshPrimitive::Triangles);

src/Magnum/MeshTools/Test/FilterTest.cpp

@@ -157,9 +157,9 @@ void FilterTest::attributes() {
     auto&& data = ImplementationSpecificIndexTypeData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
-    Containers::Array<char> indexData{5*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, 5*sizeof(UnsignedShort)};
     Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
-    Containers::Array<char> vertexData{3*sizeof(Vertex)};
+    Containers::Array<char> vertexData{NoInit, 3*sizeof(Vertex)};
     Containers::StridedArrayView1D<Vertex> vertices = Containers::arrayCast<Vertex>(vertexData);
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
@@ -206,7 +206,7 @@ void FilterTest::attributesNoIndexData() {
     /* A trivial subset of filterAttributes() testing it doesn't blow up if the
        mesh is not indexed */
 
-    Containers::Array<char> vertexData{3*sizeof(Vertex)};
+    Containers::Array<char> vertexData{NoInit, 3*sizeof(Vertex)};
     Containers::StridedArrayView1D<Vertex> vertices = Containers::arrayCast<Vertex>(vertexData);
 
     Trade::MeshData mesh{MeshPrimitive::TriangleFan,
@@ -238,9 +238,9 @@ void FilterTest::attributesRvalue() {
 
     /* Subset of attributes() verifying data ownership transfer behavior */
 
-    Containers::Array<char> indexData{5*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, 5*sizeof(UnsignedShort)};
     Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
-    Containers::Array<char> vertexData{3*sizeof(Vertex)};
+    Containers::Array<char> vertexData{NoInit, 3*sizeof(Vertex)};
     Containers::StridedArrayView1D<Vertex> vertices = Containers::arrayCast<Vertex>(vertexData);
 
     Containers::Array<Trade::MeshAttributeData> attributes{InPlaceInit, {
@@ -314,9 +314,9 @@ void FilterTest::onlyAttributes() {
     auto&& data = ImplementationSpecificIndexTypeData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
-    Containers::Array<char> indexData{5*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, 5*sizeof(UnsignedShort)};
     Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
-    Containers::Array<char> vertexData{3*sizeof(Vertex)};
+    Containers::Array<char> vertexData{NoInit, 3*sizeof(Vertex)};
     Containers::StridedArrayView1D<Vertex> vertices = Containers::arrayCast<Vertex>(vertexData);
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
@@ -368,7 +368,7 @@ void FilterTest::onlyAttributesNoIndexData() {
     /* A trivial subset of filterOnlyAttributeNames() testing it doesn't blow
        up if the mesh is not indexed */
 
-    Containers::Array<char> vertexData{3*sizeof(Vertex)};
+    Containers::Array<char> vertexData{NoInit, 3*sizeof(Vertex)};
     Containers::StridedArrayView1D<Vertex> vertices = Containers::arrayCast<Vertex>(vertexData);
 
     Trade::MeshData mesh{MeshPrimitive::TriangleFan,
@@ -397,7 +397,7 @@ void FilterTest::onlyAttributesNoIndexData() {
 }
 
 void FilterTest::onlyAttributesNoAttributeData() {
-    Containers::Array<char> indexData{5*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, 5*sizeof(UnsignedShort)};
     Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
 
     Trade::MeshData mesh{MeshPrimitive::Points,
@@ -428,7 +428,7 @@ void FilterTest::onlyAttributesRvalue() {
        only checks that the r-value gets correctly passed through all overloads
        to keep the index data owned and vertex data not. */
 
-    Containers::Array<char> indexData{5*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, 5*sizeof(UnsignedShort)};
     Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
     Vertex vertexData[3];
     Containers::StridedArrayView1D<Vertex> vertices = vertexData;
@@ -466,9 +466,9 @@ void FilterTest::onlyAttributeIds() {
     auto&& data = ImplementationSpecificIndexTypeData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
-    Containers::Array<char> indexData{5*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, 5*sizeof(UnsignedShort)};
     Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
-    Containers::Array<char> vertexData{3*sizeof(Vertex)};
+    Containers::Array<char> vertexData{NoInit, 3*sizeof(Vertex)};
     Containers::StridedArrayView1D<Vertex> vertices = Containers::arrayCast<Vertex>(vertexData);
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
@@ -537,7 +537,7 @@ void FilterTest::onlyAttributeIdsNoIndexData() {
     /* A trivial subset of filterOnlyAttributeIds() testing it doesn't blow up
        if the mesh is not indexed */
 
-    Containers::Array<char> vertexData{3*sizeof(Vertex)};
+    Containers::Array<char> vertexData{NoInit, 3*sizeof(Vertex)};
     Containers::StridedArrayView1D<Vertex> vertices = Containers::arrayCast<Vertex>(vertexData);
 
     Trade::MeshData mesh{MeshPrimitive::TriangleFan,
@@ -568,7 +568,7 @@ void FilterTest::onlyAttributeIdsNoIndexData() {
 }
 
 void FilterTest::onlyAttributeIdsNoAttributeData() {
-    Containers::Array<char> indexData{5*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, 5*sizeof(UnsignedShort)};
     Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
 
     Trade::MeshData mesh{MeshPrimitive::Points,
@@ -598,9 +598,9 @@ void FilterTest::exceptAttributes() {
     auto&& data = ImplementationSpecificIndexTypeData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
-    Containers::Array<char> indexData{5*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, 5*sizeof(UnsignedShort)};
     Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
-    Containers::Array<char> vertexData{3*sizeof(Vertex)};
+    Containers::Array<char> vertexData{NoInit, 3*sizeof(Vertex)};
     Containers::StridedArrayView1D<Vertex> vertices = Containers::arrayCast<Vertex>(vertexData);
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
@@ -650,7 +650,7 @@ void FilterTest::exceptAttributesNoIndexData() {
     /* A trivial subset of filterExceptAttributeNames() testing it doesn't blow
        up if the mesh is not indexed */
 
-    Containers::Array<char> vertexData{3*sizeof(Vertex)};
+    Containers::Array<char> vertexData{NoInit, 3*sizeof(Vertex)};
     Containers::StridedArrayView1D<Vertex> vertices = Containers::arrayCast<Vertex>(vertexData);
 
     Trade::MeshData mesh{MeshPrimitive::TriangleFan,
@@ -680,7 +680,7 @@ void FilterTest::exceptAttributesNoIndexData() {
 }
 
 void FilterTest::exceptAttributesNoAttributeData() {
-    Containers::Array<char> indexData{5*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, 5*sizeof(UnsignedShort)};
     Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
 
     Trade::MeshData mesh{MeshPrimitive::Points,
@@ -712,7 +712,7 @@ void FilterTest::exceptAttributesRvalue() {
        to keep the vertex data owned and index data not. */
 
     UnsignedShort indices[5];
-    Containers::Array<char> vertexData{3*sizeof(Vertex)};
+    Containers::Array<char> vertexData{NoInit, 3*sizeof(Vertex)};
     Containers::StridedArrayView1D<Vertex> vertices = Containers::arrayCast<Vertex>(vertexData);
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
@@ -750,9 +750,9 @@ void FilterTest::exceptAttributeIds() {
     auto&& data = ImplementationSpecificIndexTypeData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
-    Containers::Array<char> indexData{5*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, 5*sizeof(UnsignedShort)};
     Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
-    Containers::Array<char> vertexData{3*sizeof(Vertex)};
+    Containers::Array<char> vertexData{NoInit, 3*sizeof(Vertex)};
     Containers::StridedArrayView1D<Vertex> vertices = Containers::arrayCast<Vertex>(vertexData);
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
@@ -821,7 +821,7 @@ void FilterTest::exceptAttributeIdsNoIndexData() {
     /* A trivial subset of filterExceptAttributeIds() testing it doesn't blow up
        if the mesh is not indexed */
 
-    Containers::Array<char> vertexData{3*sizeof(Vertex)};
+    Containers::Array<char> vertexData{NoInit, 3*sizeof(Vertex)};
     Containers::StridedArrayView1D<Vertex> vertices = Containers::arrayCast<Vertex>(vertexData);
 
     Trade::MeshData mesh{MeshPrimitive::TriangleFan,
@@ -853,7 +853,7 @@ void FilterTest::exceptAttributeIdsNoIndexData() {
 }
 
 void FilterTest::exceptAttributeIdsNoAttributeData() {
-    Containers::Array<char> indexData{5*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, 5*sizeof(UnsignedShort)};
     Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
 
     Trade::MeshData mesh{MeshPrimitive::Points,

src/Magnum/MeshTools/Test/GenerateIndicesTest.cpp

@@ -1402,7 +1402,7 @@ void GenerateIndicesTest::generateIndicesMeshDataMove() {
         Vector2 textureCoordinates;
     };
 
-    Containers::Array<char> vertexData{5*sizeof(Vertex)};
+    Containers::Array<char> vertexData{NoInit, 5*sizeof(Vertex)};
     auto vertices = Containers::arrayCast<Vertex>(vertexData);
     vertices[0].position = {1.5f, 0.3f};
     vertices[1].position = {2.5f, 1.3f};
@@ -1537,7 +1537,7 @@ void GenerateIndicesTest::generateIndicesMeshDataTrivialIndexedMove() {
         {5.5f, 4.3f},
     };
 
-    Containers::Array<char> indexData{4*sizeof(UnsignedInt)};
+    Containers::Array<char> indexData{NoInit, 4*sizeof(UnsignedInt)};
     Containers::ArrayView<UnsignedInt> indices = Containers::arrayCast<UnsignedInt>(indexData);
     Utility::copy({60, 21, 72, 93}, indices);
 
@@ -1573,7 +1573,7 @@ void GenerateIndicesTest::generateIndicesMeshDataTrivialIndexedMoveDifferentInde
         {5.5f, 4.3f},
     };
 
-    Containers::Array<char> indexData{4*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{NoInit, 4*sizeof(UnsignedShort)};
     Containers::ArrayView<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
     Utility::copy({60, 21, 72, 93}, indices);
 

src/Magnum/MeshTools/Test/InterleaveTest.cpp

@@ -377,7 +377,7 @@ void InterleaveTest::interleaveIntoInvalid() {
 }
 
 void InterleaveTest::interleavedData() {
-    Containers::Array<char> vertexData{100 + 3*20};
+    Containers::Array<char> vertexData{NoInit, 100 + 3*20};
     Containers::StridedArrayView1D<Vector2> positions{vertexData,
         reinterpret_cast<Vector2*>(vertexData.data() + 100), 3, 20};
     Containers::StridedArrayView1D<Vector3> normals{vertexData,
@@ -409,7 +409,7 @@ void InterleaveTest::interleavedData() {
 void InterleaveTest::interleavedDataUnordered() {
     /* Compared to interleavedData() the attribute order in MeshData is
        flipped, but the result should be the same */
-    Containers::Array<char> vertexData{100 + 3*20};
+    Containers::Array<char> vertexData{NoInit, 100 + 3*20};
     Containers::StridedArrayView1D<Vector2> positions{vertexData,
         reinterpret_cast<Vector2*>(vertexData.data() + 100), 3, 20};
     Containers::StridedArrayView1D<Vector3> normals{vertexData,
@@ -432,7 +432,7 @@ void InterleaveTest::interleavedDataUnordered() {
 void InterleaveTest::interleavedDataGaps() {
     /* Compared to interleavedData() there's a few padding bytes in between and
        at the end, the size should tightly wrap the data though */
-    Containers::Array<char> vertexData{100 + 3*40};
+    Containers::Array<char> vertexData{NoInit, 100 + 3*40};
     Containers::StridedArrayView1D<Vector2> positions{vertexData,
         reinterpret_cast<Vector2*>(vertexData.data() + 100 + 5), 3, 40};
     Containers::StridedArrayView1D<Vector3> normals{vertexData,
@@ -457,7 +457,7 @@ void InterleaveTest::interleavedDataGapsTrailingOmitted() {
        MeshData allows that, but StridedArrayView constructors don't (which is
        why this is using offset-only attributes), so verify we don't trip up on
        that. */
-    Containers::Array<char> vertexData{2*48 + 36};
+    Containers::Array<char> vertexData{NoInit, 2*48 + 36};
     const char* vertexDataPointer = vertexData.data();
 
     Trade::MeshData data{MeshPrimitive::Triangles, Utility::move(vertexData), {
@@ -479,7 +479,7 @@ void InterleaveTest::interleavedDataGapsTrailingOmitted() {
 void InterleaveTest::interleavedDataAliased() {
     /* Compared to interleavedData() the normals share first two components
        with positions */
-    Containers::Array<char> vertexData{100 + 3*12};
+    Containers::Array<char> vertexData{NoInit, 100 + 3*12};
     Containers::StridedArrayView1D<Vector2> positions{vertexData,
         reinterpret_cast<Vector2*>(vertexData.data() + 100), 3, 12};
     Containers::StridedArrayView1D<Vector3> normals{vertexData,
@@ -502,7 +502,7 @@ void InterleaveTest::interleavedDataAliased() {
 void InterleaveTest::interleavedDataSingleAttribute() {
     /* Just to ensure it passes also when there's just one tightly-packed
        attribute, which is the same as if it would be interleaved */
-    Containers::Array<char> vertexData{3*8};
+    Containers::Array<char> vertexData{NoInit, 3*8};
     auto positions = Containers::arrayCast<Vector2>(vertexData);
 
     Trade::MeshData data{MeshPrimitive::Triangles, Utility::move(vertexData), {
@@ -522,7 +522,7 @@ void InterleaveTest::interleavedDataArrayAttributes() {
     /* Same as above, except that the MeshData get those as custom Float array
        attribs of size 3 and 2 instead of Vector3 and Vector2. Output should be
        the same for both. */
-    Containers::Array<char> vertexData{100 + 3*40};
+    Containers::Array<char> vertexData{NoInit, 100 + 3*40};
     Containers::StridedArrayView1D<Vector3> normals{vertexData,
         reinterpret_cast<Vector3*>(vertexData.data() + 100 + 24), 3, 40};
     Containers::StridedArrayView1D<Vector2> positions{vertexData,
@@ -594,7 +594,7 @@ void InterleaveTest::interleavedDataNoVertices() {
 void InterleaveTest::interleavedDataNotInterleaved() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
-    Containers::Array<char> vertexData{100 + 3*20};
+    Containers::Array<char> vertexData{NoInit, 100 + 3*20};
     auto positions = Containers::arrayCast<Vector2>(vertexData.exceptPrefix(100).prefix(3*8));
     auto normals = Containers::arrayCast<Vector3>(vertexData.exceptPrefix(100+3*8));
 
@@ -650,7 +650,7 @@ void InterleaveTest::interleavedDataAttributeAcrossStride() {
 }
 
 void InterleaveTest::interleavedDataZeroStride() {
-    Containers::Array<char> vertexData{100 + 20};
+    Containers::Array<char> vertexData{NoInit, 100 + 20};
     Containers::StridedArrayView1D<Vector2> positions{vertexData,
         reinterpret_cast<Vector2*>(vertexData.data() + 100), 3, 0};
     Containers::StridedArrayView1D<Vector3> normals{vertexData,
@@ -667,7 +667,7 @@ void InterleaveTest::interleavedDataZeroStride() {
 }
 
 void InterleaveTest::interleavedDataNegativeStride() {
-    Containers::Array<char> vertexData{100 + 3*20};
+    Containers::Array<char> vertexData{NoInit, 100 + 3*20};
     Containers::StridedArrayView1D<Vector2> positions{vertexData,
         reinterpret_cast<Vector2*>(vertexData.data() + 100), 3, 20};
     Containers::StridedArrayView1D<Vector3> normals{vertexData,
@@ -731,7 +731,7 @@ void InterleaveTest::interleavedDataImplementationSpecificVertexFormat() {
     /* The implementation-specific format is conservatively assumed to occupy
        the whole stride (even if it may be excessive) */
     {
-        Containers::Array<char> vertexData{100 + 3*50};
+        Containers::Array<char> vertexData{NoInit, 100 + 3*50};
         Trade::MeshAttributeData positions{Trade::MeshAttribute::Position,
             Containers::StridedArrayView1D<Vector2>{vertexData,
                 reinterpret_cast<Vector2*>(vertexData.data() + 100), 3, 50}};
@@ -771,7 +771,7 @@ void InterleaveTest::interleavedDataImplementationSpecificVertexFormat() {
 
     /* Fits just into one byte at the end of stride */
     {
-        Containers::Array<char> vertexData{100 + 3*9};
+        Containers::Array<char> vertexData{NoInit, 100 + 3*9};
         Trade::MeshAttributeData positions{Trade::MeshAttribute::Position,
             Containers::StridedArrayView1D<Vector2>{vertexData,
                 reinterpret_cast<Vector2*>(vertexData.data() + 100), 3, 9}};
@@ -791,7 +791,7 @@ void InterleaveTest::interleavedDataImplementationSpecificVertexFormat() {
 
     /* Doesn't have even one byte of space in the stride, invalid */
     {
-        Containers::Array<char> vertexData{100 + 3*8};
+        Containers::Array<char> vertexData{NoInit, 100 + 3*8};
         Trade::MeshAttributeData positions{Trade::MeshAttribute::Position,
             Containers::StridedArrayView1D<Vector2>{vertexData,
                 reinterpret_cast<Vector2*>(vertexData.data() + 100), 3, 8}};
@@ -807,7 +807,7 @@ void InterleaveTest::interleavedDataImplementationSpecificVertexFormat() {
     /* A non-interleaved (or not?) attribute with a implementation-specific
        format after interleaved ones is also invalid */
     {
-        Containers::Array<char> vertexData{100 + 3*20 + 3};
+        Containers::Array<char> vertexData{NoInit, 100 + 3*20 + 3};
         Trade::MeshAttributeData positions{Trade::MeshAttribute::Position,
             Containers::StridedArrayView1D<Vector2>{vertexData,
                 reinterpret_cast<Vector2*>(vertexData.data() + 100), 3, 20}};
@@ -826,8 +826,8 @@ void InterleaveTest::interleavedDataImplementationSpecificVertexFormat() {
 }
 
 void InterleaveTest::interleavedLayout() {
-    Containers::Array<char> indexData{6};
-    Containers::Array<char> vertexData{3*32};
+    Containers::Array<char> indexData{ValueInit, 6};
+    Containers::Array<char> vertexData{NoInit, 3*32};
 
     const Trade::MeshAttributeData attributeData[]{
         Trade::MeshAttributeData{Trade::MeshAttribute::Position,
@@ -901,7 +901,7 @@ void InterleaveTest::interleavedLayoutImplementationSpecificVertexFormat() {
 }
 
 void InterleaveTest::interleavedLayoutExtra() {
-    Containers::Array<char> vertexData{3*20};
+    Containers::Array<char> vertexData{NoInit, 3*20};
     Trade::MeshAttributeData positions{Trade::MeshAttribute::Position,
         Containers::arrayCast<Vector2>(vertexData.prefix(3*8))};
     Trade::MeshAttributeData normals{Trade::MeshAttribute::Normal,
@@ -961,7 +961,7 @@ void InterleaveTest::interleavedLayoutExtra() {
 }
 
 void InterleaveTest::interleavedLayoutExtraAliased() {
-    Containers::Array<char> vertexData{3*12};
+    Containers::Array<char> vertexData{NoInit, 3*12};
     Trade::MeshAttributeData positions{Trade::MeshAttribute::Position,
         Containers::StridedArrayView1D<Vector2>{vertexData, reinterpret_cast<Vector2*>(vertexData.data()), 3, 12}};
     Trade::MeshData data{MeshPrimitive::Triangles,
@@ -990,7 +990,7 @@ void InterleaveTest::interleavedLayoutExtraAliased() {
 void InterleaveTest::interleavedLayoutExtraTooNegativePadding() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
-    Containers::Array<char> vertexData{3*12};
+    Containers::Array<char> vertexData{NoInit, 3*12};
     Trade::MeshAttributeData positions{Trade::MeshAttribute::Position,
         Containers::StridedArrayView1D<Vector2>{vertexData, reinterpret_cast<Vector2*>(vertexData.data()), 3, 12}};
     Trade::MeshData data{MeshPrimitive::Triangles,
@@ -1050,9 +1050,9 @@ void InterleaveTest::interleavedLayoutAlreadyInterleaved() {
     auto&& data = AlreadyInterleavedData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
-    Containers::Array<char> indexData{6};
+    Containers::Array<char> indexData{ValueInit, 6};
     /* Test also removing the initial offset */
-    Containers::Array<char> vertexData{100 + 3*24};
+    Containers::Array<char> vertexData{NoInit, 100 + 3*24};
     Trade::MeshAttributeData positions{Trade::MeshAttribute::Position,
         Containers::StridedArrayView1D<Vector2>{vertexData, reinterpret_cast<Vector2*>(vertexData.data() + 100), 3, 24}};
     Trade::MeshAttributeData normals{Trade::MeshAttribute::Normal,
@@ -1101,8 +1101,8 @@ void InterleaveTest::interleavedLayoutAlreadyInterleavedAliased() {
     auto&& data = AlreadyInterleavedData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
-    Containers::Array<char> indexData{6};
-    Containers::Array<char> vertexData{3*12};
+    Containers::Array<char> indexData{ValueInit, 6};
+    Containers::Array<char> vertexData{NoInit, 3*12};
     Trade::MeshAttributeData positions{Trade::MeshAttribute::Position,
         Containers::StridedArrayView1D<Vector2>{vertexData, reinterpret_cast<Vector2*>(vertexData.data()), 3, 12}};
     Trade::MeshAttributeData normals{Trade::MeshAttribute::Normal,
@@ -1149,7 +1149,7 @@ void InterleaveTest::interleavedLayoutAlreadyInterleavedExtra() {
     auto&& data = AlreadyInterleavedData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
-    Containers::Array<char> vertexData{100 + 3*24};
+    Containers::Array<char> vertexData{NoInit, 100 + 3*24};
     Trade::MeshAttributeData positions{Trade::MeshAttribute::Position,
         Containers::StridedArrayView1D<Vector2>{vertexData, reinterpret_cast<Vector2*>(vertexData.data() + 100), 3, 24}};
     Trade::MeshAttributeData normals{Trade::MeshAttribute::Normal,
@@ -1226,9 +1226,9 @@ void InterleaveTest::interleavedLayoutNothing() {
 }
 
 void InterleaveTest::interleavedLayoutRvalue() {
-    Containers::Array<char> indexData{6};
-    Containers::Array<char> vertexData{3*20};
-    Containers::Array<Trade::MeshAttributeData> attributeData{2};
+    Containers::Array<char> indexData{ValueInit, 6};
+    Containers::Array<char> vertexData{NoInit, 3*20};
+    Containers::Array<Trade::MeshAttributeData> attributeData{ValueInit, 2};
     attributeData[0] = Trade::MeshAttributeData{Trade::MeshAttribute::Position,
         Containers::arrayCast<Vector2>(vertexData.prefix(3*8))};
     attributeData[1] = Trade::MeshAttributeData{Trade::MeshAttribute::Normal,
@@ -1501,9 +1501,9 @@ void InterleaveTest::interleaveMeshDataAlreadyInterleavedMove() {
     auto&& data = AlreadyInterleavedData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
-    Containers::Array<char> indexData{4};
+    Containers::Array<char> indexData{ValueInit, 4};
     auto indexView = Containers::arrayCast<UnsignedShort>(indexData);
-    Containers::Array<char> vertexData{3*24};
+    Containers::Array<char> vertexData{NoInit, 3*24};
     Containers::StridedArrayView1D<Vector2> positionView{vertexData,
         reinterpret_cast<Vector2*>(vertexData.data()), 3, 24};
     Containers::StridedArrayView1D<Vector3> normalView{vertexData,
@@ -1512,7 +1512,7 @@ void InterleaveTest::interleaveMeshDataAlreadyInterleavedMove() {
         Trade::MeshAttributeData{Trade::MeshAttribute::Position, positionView},
         Trade::MeshAttributeData{Trade::MeshAttribute::Normal, data.vertexFormat, normalView}
     });
-    const Trade::MeshAttributeData* attributePointer = attributeData;
+    const Trade::MeshAttributeData* attributePointer = attributeData.data();
 
     Trade::MeshData mesh{MeshPrimitive::TriangleFan,
         Utility::move(indexData), Trade::MeshIndexData{indexView},
@@ -1550,19 +1550,19 @@ void InterleaveTest::interleaveMeshDataAlreadyInterleavedMoveIndices() {
     setTestCaseDescription(data.name);
 
     /* Testing also offset */
-    Containers::Array<char> indexData{(50 + 3)*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, (50 + 3)*sizeof(UnsignedShort)};
     Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData).exceptPrefix(50);
     if(data.flip)
         indices = indices.flipped<0>();
     Utility::copy({0, 2, 1}, indices);
 
-    Containers::Array<char> vertexData{3*8};
+    Containers::Array<char> vertexData{NoInit, 3*8};
     Containers::StridedArrayView1D<Vector2> positionView = Containers::arrayCast<Vector2>(vertexData);
     auto attributeData = Containers::array({
         Trade::MeshAttributeData{Trade::MeshAttribute::Position, positionView},
     });
-    const void* indexPointer = indexData;
-    const Trade::MeshAttributeData* attributePointer = attributeData;
+    const void* indexPointer = indexData.data();
+    const Trade::MeshAttributeData* attributePointer = attributeData.data();
 
     Trade::MeshData mesh{MeshPrimitive::TriangleFan,
         Utility::move(indexData), Trade::MeshIndexData{data.indexType,indices},
@@ -1590,7 +1590,7 @@ void InterleaveTest::interleaveMeshDataAlreadyInterleavedMoveIndices() {
     } else {
         /* Only the actually used part of the index buffer gets transferred and
            is tightly packed */
-        CORRADE_VERIFY(interleaved.indexData().data() != indexData);
+        CORRADE_VERIFY(interleaved.indexData().data() != indexData.data());
         CORRADE_COMPARE(interleaved.indexData().size(), 3*sizeof(UnsignedShort));
         CORRADE_COMPARE(interleaved.indexOffset(), 0);
         CORRADE_COMPARE(interleaved.indexStride(), sizeof(UnsignedShort));
@@ -1605,9 +1605,9 @@ void InterleaveTest::interleaveMeshDataAlreadyInterleavedMoveIndices() {
 }
 
 void InterleaveTest::interleaveMeshDataAlreadyInterleavedMoveNonOwned() {
-    Containers::Array<char> indexData{4};
+    Containers::Array<char> indexData{ValueInit, 4};
     auto indexView = Containers::arrayCast<UnsignedShort>(indexData);
-    Containers::Array<char> vertexData{3*24};
+    Containers::Array<char> vertexData{NoInit, 3*24};
     Containers::StridedArrayView1D<Vector2> positionView{vertexData,
         reinterpret_cast<Vector2*>(vertexData.data()), 3, 24};
     Containers::StridedArrayView1D<Vector3> normalView{vertexData,
@@ -1616,7 +1616,7 @@ void InterleaveTest::interleaveMeshDataAlreadyInterleavedMoveNonOwned() {
         Trade::MeshAttributeData{Trade::MeshAttribute::Position, positionView},
         Trade::MeshAttributeData{Trade::MeshAttribute::Normal, normalView}
     });
-    const Trade::MeshAttributeData* attributePointer = attributeData;
+    const Trade::MeshAttributeData* attributePointer = attributeData.data();
 
     Trade::MeshData data{MeshPrimitive::TriangleFan,
         {}, indexData, Trade::MeshIndexData{indexView},

src/Magnum/MeshTools/Test/RemoveDuplicatesTest.cpp

@@ -1036,7 +1036,7 @@ void RemoveDuplicatesTest::removeDuplicatesMeshDataFuzzy() {
             f = f*data.scale + Math::Vector<6, Float>{data.offset};
         /** @todo i need some feature like "gimme just the top-level dimension" */
         Containers::StridedArrayView1D<const char> floats{unique.vertexData(),
-            unique.vertexData() + unique.attributeOffset(1),
+            unique.vertexData().data() + unique.attributeOffset(1),
             unique.vertexCount(), unique.attributeStride(1)};
         CORRADE_COMPARE_AS((Containers::arrayCast<const Math::Vector<6, Float>>(floats)),
             Containers::arrayView(expectedFloats),
@@ -1163,7 +1163,7 @@ void RemoveDuplicatesTest::removeDuplicatesMeshDataFuzzyDouble() {
     };
     /** @todo i need some feature like "gimme just the top-level dimension" */
     Containers::StridedArrayView1D<const char> floats{unique.vertexData(),
-        unique.vertexData() + unique.attributeOffset(0),
+        unique.vertexData().data() + unique.attributeOffset(0),
         unique.vertexCount(), unique.attributeStride(0)};
     CORRADE_COMPARE_AS((Containers::arrayCast<const Math::Vector<3, Double>>(floats)),
         Containers::arrayView(expectedFloats),

src/Magnum/MeshTools/Test/SubdivideTest.cpp

@@ -115,7 +115,7 @@ void SubdivideTest::subdivideWrongIndexCount() {
     Error redirectError{&out};
 
     Containers::Array<Vector1> positions;
-    Containers::Array<UnsignedInt> indices{2};
+    Containers::Array<UnsignedInt> indices{NoInit, 2};
     MeshTools::subdivide(indices, positions, interpolator1);
     CORRADE_COMPARE(out, "MeshTools::subdivide(): index count is not divisible by 3\n");
 }

src/Magnum/MeshTools/Test/TransformTest.cpp

@@ -643,7 +643,7 @@ void TransformTest::meshData2DRvaluePassthrough() {
     arrayAppend(attributes, {
         Trade::MeshAttributeData{Trade::MeshAttribute::Position, vertices.slice(&Vertex::position), data.morphTargetId}
     });
-    const void* originalAttributeData = attributes;
+    const void* originalAttributeData = attributes.data();
 
     Trade::MeshData mesh{MeshPrimitive::TriangleFan,
         data.indexed ? Utility::move(indexData) : nullptr,
@@ -692,7 +692,7 @@ void TransformTest::meshData2DRvaluePassthroughIndexDataNotOwned() {
     Containers::Array<Trade::MeshAttributeData> attributes{InPlaceInit, {
         Trade::MeshAttributeData{Trade::MeshAttribute::Position, vertices}
     }};
-    const void* originalAttributeData = attributes;
+    const void* originalAttributeData = attributes.data();
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
         {}, indices, Trade::MeshIndexData{indices},
@@ -736,7 +736,7 @@ void TransformTest::meshData2DRvaluePassthroughVertexDataNotOwned() {
     Containers::Array<Trade::MeshAttributeData> attributes{InPlaceInit, {
         Trade::MeshAttributeData{Trade::MeshAttribute::Position, Containers::arrayView(vertices)}
     }};
-    const void* originalAttributeData = attributes;
+    const void* originalAttributeData = attributes.data();
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
         Utility::move(indexData), Trade::MeshIndexData{indices},
@@ -796,7 +796,7 @@ void TransformTest::meshData2DRvaluePassthroughWrongFormat() {
     Containers::Array<Trade::MeshAttributeData> attributes{InPlaceInit, {
         Trade::MeshAttributeData{Trade::MeshAttribute::Position, vertices}
     }};
-    const void* originalAttributeData = attributes;
+    const void* originalAttributeData = attributes.data();
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
         Utility::move(vertexData), Utility::move(attributes)};
@@ -1122,7 +1122,7 @@ void TransformTest::meshData3DRvaluePassthrough() {
         arrayAppend(attributes, Trade::MeshAttributeData{Trade::MeshAttribute::Bitangent, vertices.slice(&Vertex::bitangent), data.morphTargetId});
     if(data.normals)
         arrayAppend(attributes, Trade::MeshAttributeData{Trade::MeshAttribute::Normal, vertices.slice(&Vertex::normal), data.morphTargetId});
-    const void* originalAttributeData = attributes;
+    const void* originalAttributeData = attributes.data();
 
     Trade::MeshData mesh{MeshPrimitive::TriangleFan,
         data.indexed ? Utility::move(indexData) : nullptr,
@@ -1205,7 +1205,7 @@ void TransformTest::meshData3DRvaluePassthroughIndexDataNotOwned() {
     Containers::Array<Trade::MeshAttributeData> attributes{InPlaceInit, {
         Trade::MeshAttributeData{Trade::MeshAttribute::Position, vertices}
     }};
-    const void* originalAttributeData = attributes;
+    const void* originalAttributeData = attributes.data();
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
         {}, indices, Trade::MeshIndexData{indices},
@@ -1249,7 +1249,7 @@ void TransformTest::meshData3DRvaluePassthroughVertexDataNotOwned() {
     Containers::Array<Trade::MeshAttributeData> attributes{InPlaceInit, {
         Trade::MeshAttributeData{Trade::MeshAttribute::Position, Containers::arrayView(vertices)}
     }};
-    const void* originalAttributeData = attributes;
+    const void* originalAttributeData = attributes.data();
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
         Utility::move(indexData), Trade::MeshIndexData{indices},
@@ -1333,7 +1333,7 @@ void TransformTest::meshData3DRvaluePassthroughWrongFormat() {
         arrayAppend(attributes, Trade::MeshAttributeData{Trade::MeshAttribute::Bitangent, vertices.slice(&Vertex::bitangent)});
     if(data.normalFormat != VertexFormat{})
         arrayAppend(attributes, Trade::MeshAttributeData{Trade::MeshAttribute::Normal, VertexFormat::Vector3sNormalized, vertices.slice(&Vertex::normal)});
-    const void* originalAttributeData = attributes;
+    const void* originalAttributeData = attributes.data();
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
         Utility::move(vertexData), Utility::move(attributes)};
@@ -1596,7 +1596,7 @@ void TransformTest::meshDataTextureCoordinates2DRvaluePassthrough() {
     arrayAppend(attributes, {
         Trade::MeshAttributeData{Trade::MeshAttribute::TextureCoordinates, vertices.slice(&Vertex::textureCoordinates), data.morphTargetId}
     });
-    const void* originalAttributeData = attributes;
+    const void* originalAttributeData = attributes.data();
 
     Trade::MeshData mesh{MeshPrimitive::TriangleFan,
         data.indexed ? Utility::move(indexData) : nullptr,
@@ -1645,7 +1645,7 @@ void TransformTest::meshDataTextureCoordinates2DRvaluePassthroughIndexDataNotOwn
     Containers::Array<Trade::MeshAttributeData> attributes{InPlaceInit, {
         Trade::MeshAttributeData{Trade::MeshAttribute::TextureCoordinates, vertices}
     }};
-    const void* originalAttributeData = attributes;
+    const void* originalAttributeData = attributes.data();
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
         {}, indices, Trade::MeshIndexData{indices},
@@ -1689,7 +1689,7 @@ void TransformTest::meshDataTextureCoordinates2DRvaluePassthroughVertexDataNotOw
     Containers::Array<Trade::MeshAttributeData> attributes{InPlaceInit, {
         Trade::MeshAttributeData{Trade::MeshAttribute::TextureCoordinates, Containers::arrayView(vertices)}
     }};
-    const void* originalAttributeData = attributes;
+    const void* originalAttributeData = attributes.data();
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
         Utility::move(indexData), Trade::MeshIndexData{indices},
@@ -1749,7 +1749,7 @@ void TransformTest::meshDataTextureCoordinates2DRvaluePassthroughWrongFormat() {
     Containers::Array<Trade::MeshAttributeData> attributes{InPlaceInit, {
         Trade::MeshAttributeData{Trade::MeshAttribute::TextureCoordinates, vertices}
     }};
-    const void* originalAttributeData = attributes;
+    const void* originalAttributeData = attributes.data();
 
     Trade::MeshData mesh{MeshPrimitive::TriangleStrip,
         Utility::move(vertexData), Utility::move(attributes)};

src/Magnum/MeshTools/Tipsify.cpp

@@ -42,9 +42,9 @@ template<class T> void tipsifyInPlaceImplementation(const Containers::StridedArr
 
     /* Global time, per-vertex caching timestamps, per-triangle emitted flag */
     UnsignedInt time = cacheSize+1;
-    Containers::Array<UnsignedInt> timestamp{vertexCount};
+    Containers::Array<UnsignedInt> timestamp{ValueInit, vertexCount};
     /** @todo Have some bitset/staticbitset class for this */
-    Containers::Array<bool> emitted{indices.size()/3};
+    Containers::Array<bool> emitted{ValueInit, indices.size()/3};
 
     /* Dead-end vertex stack */
     Containers::Array<UnsignedInt> deadEndStack;

src/Magnum/MeshTools/Transform.cpp

@@ -56,7 +56,7 @@ Trade::MeshData transform2D(const Trade::MeshData& mesh, const Matrix3& transfor
        position attribute format, if needed. Not using Utility::copy() here as
        the view returned by attributeData() might have offset-only attributes
        which interleave() doesn't want. */
-    Containers::Array<Trade::MeshAttributeData> attributes{mesh.attributeCount()};
+    Containers::Array<Trade::MeshAttributeData> attributes{ValueInit, mesh.attributeCount()};
     for(UnsignedInt i = 0; i != mesh.attributeCount(); ++i)
         attributes[i] = mesh.attributeData(i);
 
@@ -156,7 +156,7 @@ Trade::MeshData transform3D(const Trade::MeshData& mesh, const Matrix4& transfor
        position attribute format, if needed. Not using Utility::copy() here as
        the view returned by attributeData() might have offset-only attributes
        which interleave() doesn't want. */
-    Containers::Array<Trade::MeshAttributeData> attributes{mesh.attributeCount()};
+    Containers::Array<Trade::MeshAttributeData> attributes{ValueInit, mesh.attributeCount()};
     for(UnsignedInt i = 0; i != mesh.attributeCount(); ++i)
         attributes[i] = mesh.attributeData(i);
 
@@ -331,7 +331,7 @@ Trade::MeshData transformTextureCoordinates2D(const Trade::MeshData& mesh, const
        position attribute format, if needed. Not using Utility::copy() here as
        the view returned by attributeData() might have offset-only attributes
        which interleave() doesn't want. */
-    Containers::Array<Trade::MeshAttributeData> attributes{mesh.attributeCount()};
+    Containers::Array<Trade::MeshAttributeData> attributes{ValueInit, mesh.attributeCount()};
     for(UnsignedInt i = 0; i != mesh.attributeCount(); ++i)
         attributes[i] = mesh.attributeData(i);
 

src/Magnum/Platform/GlfwApplication.cpp

@@ -322,7 +322,7 @@ void GlfwApplication::setWindowIcon(const Containers::ArrayView<const ImageView2
     std::size_t size = 0;
     for(const ImageView2D& image: images)
         size += sizeof(GLFWimage) + 4*image.size().product();
-    Containers::Array<char> data{size};
+    Containers::Array<char> data{NoInit, size};
 
     /* Pack array of GLFWimages and pixel data together into the memory
        allocated above */
@@ -355,7 +355,7 @@ void GlfwApplication::setWindowIcon(const Containers::ArrayView<const ImageView2
         offset += target.size();
     }
 
-    glfwSetWindowIcon(_window, glfwImages.size(), glfwImages);
+    glfwSetWindowIcon(_window, glfwImages.size(), glfwImages.data());
 }
 
 void GlfwApplication::setWindowIcon(std::initializer_list<ImageView2D> images) {

src/Magnum/Platform/WindowlessEglApplication.cpp

@@ -99,7 +99,7 @@ namespace {
 
 bool extensionSupported(const char* const extensions, Containers::ArrayView<const char> extension) {
     CORRADE_INTERNAL_ASSERT(extensions);
-    const char* pos = std::strstr(extensions, extension);
+    const char* pos = std::strstr(extensions, extension.data());
     /* Extension is supported if its string is delimited by a space or end of
        the extension list. The extension.size() is the whole C array including
        a 0-terminator, so subtract 1 to look at one character after. */
@@ -196,10 +196,10 @@ WindowlessEglContext::WindowlessEglContext(const Configuration& configuration, G
                     return;
                 }
 
-                devices = Containers::Array<EGLDeviceEXT>{std::size_t(count)};
+                devices = Containers::Array<EGLDeviceEXT>{NoInit, std::size_t(count)};
                 /* Assuming the same thing won't suddenly start failing when
                    called the second time */
-                CORRADE_INTERNAL_ASSERT_OUTPUT(eglQueryDevices(devices.size(), devices, &count));
+                CORRADE_INTERNAL_ASSERT_OUTPUT(eglQueryDevices(devices.size(), devices.data(), &count));
 
                 auto eglQueryDeviceAttribEXT = reinterpret_cast<EGLBoolean (*)(EGLDeviceEXT, EGLint, EGLAttrib*)>(eglGetProcAddress("eglQueryDeviceAttribEXT"));
                 auto eglQueryDeviceStringEXT = reinterpret_cast<const char* (*)(EGLDeviceEXT, EGLint)>(eglGetProcAddress("eglQueryDeviceStringEXT"));
@@ -247,10 +247,10 @@ WindowlessEglContext::WindowlessEglContext(const Configuration& configuration, G
                 }
 
                 selectedDevice = configuration.device();
-                devices = Containers::Array<EGLDeviceEXT>{configuration.device() + 1};
+                devices = Containers::Array<EGLDeviceEXT>{NoInit, configuration.device() + 1};
                 /* Assuming the same thing won't suddenly start failing when
                    called the second time */
-                CORRADE_INTERNAL_ASSERT_OUTPUT(eglQueryDevices(configuration.device() + 1, devices, &count));
+                CORRADE_INTERNAL_ASSERT_OUTPUT(eglQueryDevices(configuration.device() + 1, devices.data(), &count));
             }
 
             if(!(_display = reinterpret_cast<EGLDisplay(*)(EGLenum, void*, const EGLint*)>(eglGetProcAddress("eglGetPlatformDisplayEXT"))(EGL_PLATFORM_DEVICE_EXT, devices[selectedDevice], nullptr))) {

src/Magnum/Primitives/Circle.cpp

@@ -134,7 +134,7 @@ Trade::MeshData circle3DSolid(const UnsignedInt segments, const Circle3DFlags fl
 
     /* Set up the layout */
     Containers::Array<char> vertexData{NoInit, (segments + 2)*stride};
-    Containers::Array<Trade::MeshAttributeData> attributeData{attributeCount};
+    Containers::Array<Trade::MeshAttributeData> attributeData{ValueInit, attributeCount};
     std::size_t attributeIndex = 0;
     std::size_t attributeOffset = 0;
 

src/Magnum/Primitives/Cube.cpp

@@ -522,7 +522,7 @@ Trade::MeshData cubeSolid(const CubeFlags flags) {
 
     /* Set up the layout */
     Containers::Array<char> vertexData{NoInit, 24*stride};
-    Containers::Array<Trade::MeshAttributeData> attributeData{attributeCount};
+    Containers::Array<Trade::MeshAttributeData> attributeData{ValueInit, attributeCount};
     std::size_t attributeIndex = 0;
     std::size_t attributeOffset = 0;
 

src/Magnum/Primitives/Grid.cpp

@@ -73,7 +73,7 @@ Trade::MeshData grid3DSolid(const Vector2i& subdivisions, const GridFlags flags)
         ++attributeCount;
     }
     Containers::Array<char> vertexData{NoInit, stride*vertexCount.product()};
-    Containers::Array<Trade::MeshAttributeData> attributes{attributeCount};
+    Containers::Array<Trade::MeshAttributeData> attributes{ValueInit, attributeCount};
     std::size_t attributeIndex = 0;
     std::size_t attributeOffset = 0;
 

src/Magnum/Primitives/Implementation/Spheroid.cpp

@@ -245,7 +245,7 @@ Trade::MeshData Spheroid::finalize() {
     Trade::MeshIndexData indices{_indexData};
 
     std::size_t attributeOffset = 0;
-    Containers::Array<Trade::MeshAttributeData> attributes{_attributeCount};
+    Containers::Array<Trade::MeshAttributeData> attributes{ValueInit, _attributeCount};
     attributes[attributeOffset++] = Trade::MeshAttributeData{
         Trade::MeshAttribute::Position, VertexFormat::Vector3,
         Containers::StridedArrayView1D<const void>{_vertexData,

src/Magnum/Primitives/Plane.cpp

@@ -83,7 +83,7 @@ Trade::MeshData planeSolid(const PlaneFlags flags) {
 
     /* Set up the layout */
     Containers::Array<char> vertexData{NoInit, 4*stride};
-    Containers::Array<Trade::MeshAttributeData> attributeData{attributeCount};
+    Containers::Array<Trade::MeshAttributeData> attributeData{ValueInit, attributeCount};
     std::size_t attributeIndex = 0;
     std::size_t attributeOffset = 0;
 

src/Magnum/SceneTools/Implementation/combine.h

@@ -148,7 +148,7 @@ inline Trade::SceneData combineFields(const Trade::SceneMappingType mappingType,
        reallocation so the array is made with an upper bound on size. */
     /** @todo once never-reallocating allocators are present, use them instead
         of the manual offset */
-    Containers::Array<CombineItemView> itemViews{fields.size()*3};
+    Containers::Array<CombineItemView> itemViews{ValueInit, fields.size()*3};
     std::size_t itemViewOffset = 0;
 
     const std::size_t mappingTypeSize = sceneMappingTypeSize(mappingType);
@@ -362,7 +362,7 @@ inline Trade::SceneData combineFields(const Trade::SceneMappingType mappingType,
     }
 
     /* Map the fields to the new data */
-    Containers::Array<Trade::SceneFieldData> outFields{fields.size()};
+    Containers::Array<Trade::SceneFieldData> outFields{ValueInit, fields.size()};
     for(std::size_t i = 0; i != fields.size(); ++i) {
         const Trade::SceneFieldData& field = fields[i];
         const Trade::SceneFieldType fieldType = field.fieldType();

src/Magnum/SceneTools/Implementation/convertToSingleFunctionObjects.h

@@ -118,7 +118,7 @@ inline Trade::SceneData convertToSingleFunctionObjects(const Trade::SceneData& s
 
     /* Copy the fields over, enlarging them as necessary */
     const UnsignedInt parentFieldId = scene.fieldId(Trade::SceneField::Parent);
-    Containers::Array<Trade::SceneFieldData> fields{scene.fieldCount()};
+    Containers::Array<Trade::SceneFieldData> fields{ValueInit, scene.fieldCount()};
     for(std::size_t i = 0; i != scene.fieldCount(); ++i) {
         const Trade::SceneFieldData& field = scene.fieldData(i);
 

src/Magnum/SceneTools/Implementation/sceneConverterUtilities.h

@@ -179,7 +179,7 @@ bool printInfo(const Debug::Flags useColor, const bool useColor24, const Utility
     /* Object properties */
     Containers::Array<ObjectInfo> objectInfos;
     if(args.isSet("info") || args.isSet("info-objects")) {
-        objectInfos = Containers::Array<ObjectInfo>{std::size_t(importer.objectCount())};
+        objectInfos = Containers::Array<ObjectInfo>{ValueInit, std::size_t(importer.objectCount())};
 
         for(UnsignedLong i = 0; i != importer.objectCount(); ++i) {
             objectInfos[i].object = i;
@@ -205,12 +205,12 @@ bool printInfo(const Debug::Flags useColor, const bool useColor24, const Utility
     Containers::Array<UnsignedInt> skin3DReferenceCount;
     if((args.isSet("info") || args.isSet("info-scenes") || args.isSet("object-hierarchy")) && importer.sceneCount()) {
         if(args.isSet("info") || args.isSet("info-scenes")) {
-            materialReferenceCount = Containers::Array<UnsignedInt>{importer.materialCount()};
-            lightReferenceCount = Containers::Array<UnsignedInt>{importer.lightCount()};
-            cameraReferenceCount = Containers::Array<UnsignedInt>{importer.cameraCount()};
-            meshReferenceCount = Containers::Array<UnsignedInt>{importer.meshCount()};
-            skin2DReferenceCount = Containers::Array<UnsignedInt>{importer.skin2DCount()};
-            skin3DReferenceCount = Containers::Array<UnsignedInt>{importer.skin3DCount()};
+            materialReferenceCount = Containers::Array<UnsignedInt>{ValueInit, importer.materialCount()};
+            lightReferenceCount = Containers::Array<UnsignedInt>{ValueInit, importer.lightCount()};
+            cameraReferenceCount = Containers::Array<UnsignedInt>{ValueInit, importer.cameraCount()};
+            meshReferenceCount = Containers::Array<UnsignedInt>{ValueInit, importer.meshCount()};
+            skin2DReferenceCount = Containers::Array<UnsignedInt>{ValueInit, importer.skin2DCount()};
+            skin3DReferenceCount = Containers::Array<UnsignedInt>{ValueInit, importer.skin3DCount()};
         }
 
         for(UnsignedInt i = 0; i != importer.sceneCount(); ++i) {
@@ -424,7 +424,7 @@ bool printInfo(const Debug::Flags useColor, const bool useColor24, const Utility
     Containers::Array<MaterialInfo> materialInfos;
     Containers::Array<UnsignedInt> textureReferenceCount;
     if((args.isSet("info") || args.isSet("info-materials")) && importer.materialCount()) {
-        textureReferenceCount = Containers::Array<UnsignedInt>{importer.textureCount()};
+        textureReferenceCount = Containers::Array<UnsignedInt>{ValueInit, importer.textureCount()};
 
         for(UnsignedInt i = 0; i != importer.materialCount(); ++i) {
             Containers::Optional<Trade::MaterialData> material;
@@ -563,9 +563,9 @@ bool printInfo(const Debug::Flags useColor, const bool useColor24, const Utility
     Containers::Array<UnsignedInt> image2DReferenceCount;
     Containers::Array<UnsignedInt> image3DReferenceCount;
     if((args.isSet("info") || args.isSet("info-textures")) && importer.textureCount()) {
-        image1DReferenceCount = Containers::Array<UnsignedInt>{importer.image1DCount()};
-        image2DReferenceCount = Containers::Array<UnsignedInt>{importer.image2DCount()};
-        image3DReferenceCount = Containers::Array<UnsignedInt>{importer.image3DCount()};
+        image1DReferenceCount = Containers::Array<UnsignedInt>{ValueInit, importer.image1DCount()};
+        image2DReferenceCount = Containers::Array<UnsignedInt>{ValueInit, importer.image2DCount()};
+        image3DReferenceCount = Containers::Array<UnsignedInt>{ValueInit, importer.image3DCount()};
         for(UnsignedInt i = 0; i != importer.textureCount(); ++i) {
             Containers::Optional<Trade::TextureData> texture;
             {

src/Magnum/SceneTools/Test/CombineTest.cpp

@@ -607,10 +607,10 @@ void CombineTest::fieldsAlignment() {
         Containers::arrayView(meshFieldData),
         TestSuite::Compare::Container);
     CORRADE_COMPARE_AS(reinterpret_cast<std::ptrdiff_t>(scene.mapping(0).data()), 2, TestSuite::Compare::Divisible);
-    CORRADE_COMPARE(scene.mapping(0).data(), scene.data());
+    CORRADE_COMPARE(scene.mapping(0).data(), scene.data().data());
     CORRADE_COMPARE(scene.mapping(0).stride()[0], 2);
     CORRADE_COMPARE_AS(reinterpret_cast<std::ptrdiff_t>(scene.field(0).data()), 1, TestSuite::Compare::Divisible);
-    CORRADE_COMPARE(scene.field(0).data(), scene.data() + 3*2);
+    CORRADE_COMPARE(scene.field(0).data(), scene.data().data() + 3*2);
     CORRADE_COMPARE(scene.field(0).stride()[0], 1);
 
     CORRADE_COMPARE(scene.fieldName(1), Trade::SceneField::Translation);
@@ -623,10 +623,10 @@ void CombineTest::fieldsAlignment() {
         Containers::arrayView(translationFieldData),
         TestSuite::Compare::Container);
     CORRADE_COMPARE_AS(reinterpret_cast<std::ptrdiff_t>(scene.mapping(1).data()), 2, TestSuite::Compare::Divisible);
-    CORRADE_COMPARE(scene.mapping(1).data(), scene.data() + 3*2 + 3 + 1);
+    CORRADE_COMPARE(scene.mapping(1).data(), scene.data().data() + 3*2 + 3 + 1);
     CORRADE_COMPARE(scene.mapping(1).stride()[0], 2);
     CORRADE_COMPARE_AS(reinterpret_cast<std::ptrdiff_t>(scene.field(1).data()), 8, TestSuite::Compare::Divisible);
-    CORRADE_COMPARE(scene.field(1).data(), scene.data() + 3*2 + 3 + 1 + 2 + 4);
+    CORRADE_COMPARE(scene.field(1).data(), scene.data().data() + 3*2 + 3 + 1 + 2 + 4);
     CORRADE_COMPARE(scene.field(1).stride()[0], 16);
 }
 
@@ -750,9 +750,9 @@ void CombineTest::fieldsMappingPlaceholderFieldPlaceholder() {
     CORRADE_COMPARE(scene.fieldType(Trade::SceneField::Camera), Trade::SceneFieldType::UnsignedShort);
     CORRADE_COMPARE(scene.fieldSize(Trade::SceneField::Camera), 1);
     CORRADE_COMPARE(scene.fieldArraySize(Trade::SceneField::Camera), 0);
-    CORRADE_COMPARE(scene.mapping(Trade::SceneField::Camera).data(), scene.data());
+    CORRADE_COMPARE(scene.mapping(Trade::SceneField::Camera).data(), scene.data().data());
     CORRADE_COMPARE(scene.mapping(Trade::SceneField::Camera).stride()[0], 2);
-    CORRADE_COMPARE(scene.field(Trade::SceneField::Camera).data(), scene.data() + 2);
+    CORRADE_COMPARE(scene.field(Trade::SceneField::Camera).data(), scene.data().data() + 2);
     CORRADE_COMPARE(scene.field(Trade::SceneField::Camera).stride()[0], 2);
 
     CORRADE_COMPARE(scene.fieldType(Trade::SceneField::Mesh), Trade::SceneFieldType::UnsignedByte);
@@ -768,30 +768,30 @@ void CombineTest::fieldsMappingPlaceholderFieldPlaceholder() {
     CORRADE_COMPARE(scene.fieldSize(Trade::SceneField::Light), 2);
     CORRADE_COMPARE(scene.fieldArraySize(Trade::SceneField::Light), 0);
     CORRADE_COMPARE(scene.mapping(Trade::SceneField::Light).data(),
-        scene.data() + 2 + 2 + 3*2 + 3 + 1);
+        scene.data().data() + 2 + 2 + 3*2 + 3 + 1);
     CORRADE_COMPARE(scene.mapping(Trade::SceneField::Light).stride()[0], 2);
     CORRADE_COMPARE(scene.field(Trade::SceneField::Light).data(),
-        scene.data() + 2 + 2 + 3*2 + 3 + 1 + 2*2 + 2);
+        scene.data().data() + 2 + 2 + 3*2 + 3 + 1 + 2*2 + 2);
     CORRADE_COMPARE(scene.field(Trade::SceneField::Light).stride()[0], 4);
 
     CORRADE_COMPARE(scene.fieldType(Trade::sceneFieldCustom(15)), Trade::SceneFieldType::Short);
     CORRADE_COMPARE(scene.fieldSize(Trade::sceneFieldCustom(15)), 2);
     CORRADE_COMPARE(scene.fieldArraySize(Trade::sceneFieldCustom(15)), 4);
     CORRADE_COMPARE(scene.mapping(Trade::sceneFieldCustom(15)).data(),
-        scene.data() + 2 + 2 + 3*2 + 3 + 1 + 2*2 + 2 + 2*4);
+        scene.data().data() + 2 + 2 + 3*2 + 3 + 1 + 2*2 + 2 + 2*4);
     CORRADE_COMPARE(scene.mapping(Trade::sceneFieldCustom(15)).stride()[0], 2);
     CORRADE_COMPARE(scene.field(Trade::sceneFieldCustom(15)).data(),
-        scene.data() + 2 + 2 + 3*2 + 3 + 1 + 2*2 + 2 + 2*4 + 2*2);
+        scene.data().data() + 2 + 2 + 3*2 + 3 + 1 + 2*2 + 2 + 2*4 + 2*2);
     CORRADE_COMPARE(scene.field(Trade::sceneFieldCustom(15)).stride()[0], 4*2);
 
     CORRADE_COMPARE(scene.fieldType(Trade::sceneFieldCustom(16)), Trade::SceneFieldType::Bit);
     CORRADE_COMPARE(scene.fieldSize(Trade::sceneFieldCustom(16)), 3);
     CORRADE_COMPARE(scene.fieldArraySize(Trade::sceneFieldCustom(16)), 2);
     CORRADE_COMPARE(scene.mapping(Trade::sceneFieldCustom(16)).data(),
-        scene.data() + 2 + 2 + 3*2 + 3 + 1 + 2*2 + 2 + 2*4 + 2*2 + 2*8);
+        scene.data().data() + 2 + 2 + 3*2 + 3 + 1 + 2*2 + 2 + 2*4 + 2*2 + 2*8);
     CORRADE_COMPARE(scene.mapping(Trade::sceneFieldCustom(16)).stride()[0], 2);
     CORRADE_COMPARE(scene.fieldBitArrays(Trade::sceneFieldCustom(16)).data(),
-        scene.data() + 2 + 2 + 3*2 + 3 + 1 + 2*2 + 2 + 2*4 + 2*2 + 2*8 + 3*2);
+        scene.data().data() + 2 + 2 + 3*2 + 3 + 1 + 2*2 + 2 + 2*4 + 2*2 + 2*8 + 3*2);
     CORRADE_COMPARE(scene.fieldBitArrays(Trade::sceneFieldCustom(16)).offset(), 0);
     CORRADE_COMPARE(scene.fieldBitArrays(Trade::sceneFieldCustom(16)).stride()[0], 2);
 }
@@ -830,7 +830,7 @@ void CombineTest::fieldsMappingSharedFieldPlaceholder() {
     CORRADE_COMPARE_AS(scene.mapping<UnsignedInt>(Trade::SceneField::MeshMaterial),
         Containers::arrayView(meshMappingData),
         TestSuite::Compare::Container);
-    CORRADE_COMPARE(scene.field(Trade::SceneField::MeshMaterial).data(), scene.data() + 3*4 + 3 + 1);
+    CORRADE_COMPARE(scene.field(Trade::SceneField::MeshMaterial).data(), scene.data().data() + 3*4 + 3 + 1);
     CORRADE_COMPARE(scene.field(Trade::SceneField::MeshMaterial).stride()[0], 4);
 }
 

src/Magnum/SceneTools/Test/CopyTest.cpp

@@ -241,7 +241,7 @@ void CopyTest::copyRvalueDataFieldsOwned() {
     fields[0] = Trade::SceneFieldData{Trade::SceneField::Parent,
         Containers::arrayView(view[0].parentMapping),
         Containers::arrayView(view[0].parent)};
-    const Trade::SceneFieldData* originalFields = fields;
+    const Trade::SceneFieldData* originalFields = fields.data();
 
     Trade::SceneData copy = SceneTools::copy(Trade::SceneData{Trade::SceneMappingType::UnsignedShort, 12,
         Utility::move(data), Utility::move(fields)});
@@ -316,7 +316,7 @@ void CopyTest::copyRvalueFieldsOwned() {
     fields[0] = Trade::SceneFieldData{Trade::SceneField::Parent,
         Containers::arrayView(data->parentMapping),
         Containers::arrayView(data->parent)};
-    const Trade::SceneFieldData* originalFields = fields;
+    const Trade::SceneFieldData* originalFields = fields.data();
 
     Trade::SceneData copy = SceneTools::copy(Trade::SceneData{Trade::SceneMappingType::UnsignedShort, 12,
         Trade::DataFlag::ExternallyOwned, data, Utility::move(fields)});

src/Magnum/SceneTools/Test/FilterTest.cpp

@@ -202,7 +202,7 @@ void FilterTest::fieldsRvalue() {
         UnsignedInt light[3];
         bool visible[3];
     };
-    Containers::Array<char> sceneData{sizeof(Data)};
+    Containers::Array<char> sceneData{ValueInit, sizeof(Data)};
     Data& d = *reinterpret_cast<Data*>(sceneData.data());
     Containers::Array<Trade::SceneFieldData> fields{InPlaceInit, {
         Trade::SceneFieldData{Trade::SceneField::Mesh,
@@ -338,7 +338,7 @@ void FilterTest::onlyFieldsRvalue() {
         UnsignedByte lightMapping[3];
         UnsignedInt light[3];
     };
-    Containers::Array<char> data{sizeof(Data)};
+    Containers::Array<char> data{ValueInit, sizeof(Data)};
     Data& d = *reinterpret_cast<Data*>(data.data());
 
     Trade::SceneData scene{Trade::SceneMappingType::UnsignedByte, 133, Utility::move(data), {
@@ -447,7 +447,7 @@ void FilterTest::exceptFieldsRvalue() {
         UnsignedInt light[3];
         bool visible[3];
     };
-    Containers::Array<char> data{sizeof(Data)};
+    Containers::Array<char> data{ValueInit, sizeof(Data)};
     Data& d = *reinterpret_cast<Data*>(data.data());
 
     Trade::SceneData scene{Trade::SceneMappingType::UnsignedLong, 12, Utility::move(data), {

src/Magnum/SceneTools/Test/MapTest.cpp

@@ -554,7 +554,7 @@ void MapTest::indexFieldRvalue() {
             Containers::arrayView(view[0].mapping),
             Containers::arrayView(view[0].mesh)},
     }};
-    const Trade::SceneFieldData* originalFields = scene.fieldData();
+    const Trade::SceneFieldData* originalFields = scene.fieldData().data();
 
     const UnsignedInt mapping[]{
         15, 16, 0xffffffffu, 7, 9
@@ -611,7 +611,7 @@ void MapTest::indexFieldRvalueSigned() {
             Containers::arrayView(view[0].mapping),
             Containers::arrayView(view[0].meshMaterial)},
     }};
-    const Trade::SceneFieldData* originalFields = scene.fieldData();
+    const Trade::SceneFieldData* originalFields = scene.fieldData().data();
 
     const UnsignedInt mapping[]{
         15, 0xffffffffu, 16, 7
@@ -667,7 +667,7 @@ void MapTest::indexFieldRvalueNotOwned() {
             Containers::arrayView(sceneData->mapping),
             Containers::arrayView(sceneData->mesh)},
     }};
-    const Trade::SceneFieldData* originalFields = scene.fieldData();
+    const Trade::SceneFieldData* originalFields = scene.fieldData().data();
 
     const UnsignedInt mapping[]{
         15, 16, 0xffffffffu, 7, 9
@@ -721,7 +721,7 @@ void MapTest::indexFieldRvalueNotFullType() {
             Containers::arrayView(view[0].mapping),
             Containers::arrayView(view[0].mesh)},
     }};
-    const Trade::SceneFieldData* originalFields = scene.fieldData();
+    const Trade::SceneFieldData* originalFields = scene.fieldData().data();
 
     const UnsignedInt mapping[]{
         15, 16, 0xffffffffu, 7, 9
@@ -749,7 +749,7 @@ void MapTest::indexFieldRvalueNotFullType() {
     }), TestSuite::Compare::Container);
 
     /* Data should be copied */
-    CORRADE_VERIFY(mapped.data().data() != static_cast<void*>(sceneData));
+    CORRADE_VERIFY(mapped.data().data() != static_cast<void*>(sceneData.data()));
     CORRADE_VERIFY(mapped.fieldData().data() != originalFields);
 }
 

src/Magnum/SceneTools/Test/SceneConverterImplementationTest.cpp

@@ -325,7 +325,7 @@ void SceneConverterImplementationTest::infoScenesObjects() {
         bool _omitParent;
     } importer{data.defaultScene, data.omitParent};
 
-    CORRADE_VERIFY(_infoArgs.tryParse(data.args.size(), data.args));
+    CORRADE_VERIFY(_infoArgs.tryParse(data.args.size(), data.args.data()));
 
     std::chrono::high_resolution_clock::duration time;
 

src/Magnum/ShaderTools/AbstractConverter.cpp

@@ -708,7 +708,7 @@ bool AbstractConverter::doLinkFilesToFile(const Containers::ArrayView<const Cont
 
     /* Otherwise open the files directly */
     } else {
-        Containers::Array<Containers::Array<char>> fileData{from.size()};
+        Containers::Array<Containers::Array<char>> fileData{ValueInit, from.size()};
         for(std::size_t i = 0; i != from.size(); ++i) {
             Containers::Optional<Containers::Array<char>> data = Utility::Path::read(from[i].second());
             if(!data) {
@@ -806,7 +806,7 @@ Containers::Optional<Containers::Array<char>> AbstractConverter::doLinkFilesToDa
 
     /* Otherwise open the files directly */
     } else {
-        Containers::Array<Containers::Array<char>> fileData{filenames.size()};
+        Containers::Array<Containers::Array<char>> fileData{ValueInit, filenames.size()};
         for(std::size_t i = 0; i != filenames.size(); ++i) {
             Containers::Optional<Containers::Array<char>> data = Utility::Path::read(filenames[i].second());
             if(!data) {

src/Magnum/ShaderTools/Implementation/spirv.h

@@ -121,8 +121,8 @@ Containers::Optional<SpirvEntrypoint> spirvNextEntrypoint(Containers::ArrayView<
         }
 
         return SpirvEntrypoint{
-            *reinterpret_cast<const SpvExecutionModel*>(entryPoint + 1),
-            reinterpret_cast<const char*>(entryPoint + 3),
+            *reinterpret_cast<const SpvExecutionModel*>(entryPoint.data() + 1),
+            reinterpret_cast<const char*>(entryPoint.data() + 3),
             interfaces
         };
     }
@@ -157,7 +157,7 @@ void spirvEntrypointInterface(Containers::ArrayView<const UnsignedInt> data, con
 
         for(std::size_t i = 0; i != entrypoint.interfaces.size(); ++i) {
             if(decoration[1] == entrypoint.interfaces[i]) {
-                out[i].location = decoration + 3;
+                out[i].location = decoration.data() + 3;
                 break;
             }
         }
@@ -175,7 +175,7 @@ void spirvEntrypointInterface(Containers::ArrayView<const UnsignedInt> data, con
 
         for(std::size_t i = 0; i != entrypoint.interfaces.size(); ++i) {
             if(variable[2] == entrypoint.interfaces[i]) {
-                out[i].storageClass = reinterpret_cast<const SpvStorageClass*>(variable + 3);
+                out[i].storageClass = reinterpret_cast<const SpvStorageClass*>(variable.data() + 3);
                 break;
             }
         }

src/Magnum/ShaderTools/Test/AbstractConverterTest.cpp

@@ -1255,7 +1255,7 @@ void AbstractConverterTest::convertDataToFileThroughDataNotWritable() {
         void doSetOutputFormat(Format, Containers::StringView) override {}
 
         Containers::Optional<Containers::Array<char>> doConvertDataToData(Stage, Containers::ArrayView<const char>) override {
-            return Containers::Array<char>{1};
+            return Containers::Array<char>{NoInit, 1};
         }
     } converter;
 
@@ -1438,7 +1438,7 @@ void AbstractConverterTest::convertFileToFileThroughDataNotWritable() {
         void doSetOutputFormat(Format, Containers::StringView) override {}
 
         Containers::Optional<Containers::Array<char>> doConvertDataToData(Stage, Containers::ArrayView<const char>) override {
-            return Containers::Array<char>{1};
+            return Containers::Array<char>{NoInit, 1};
         }
     } converter;
 
@@ -1869,7 +1869,7 @@ void AbstractConverterTest::linkDataToFileThroughDataNotWritable() {
         void doSetOutputFormat(Format, Containers::StringView) override {}
 
         Containers::Optional<Containers::Array<char>> doLinkDataToData(Containers::ArrayView<const Containers::Pair<Stage, Containers::ArrayView<const char>>>) override {
-            return Containers::Array<char>{1};
+            return Containers::Array<char>{NoInit, 1};
         }
     } converter;
 
@@ -2108,7 +2108,7 @@ void AbstractConverterTest::linkFilesToFileThroughDataNotWritable() {
         void doSetOutputFormat(Format, Containers::StringView) override {}
 
         Containers::Optional<Containers::Array<char>> doLinkDataToData(Containers::ArrayView<const Containers::Pair<Stage, Containers::ArrayView<const char>>>) override {
-            return Containers::Array<char>{1};
+            return Containers::Array<char>{NoInit, 1};
         }
     } converter;
 
@@ -2946,7 +2946,7 @@ void AbstractConverterTest::setInputFileCallbackConvertFileToFileAsDataNotWritab
         }
 
         Containers::Optional<Containers::Array<char>> doConvertDataToData(Stage, Containers::ArrayView<const char>) override {
-            return Containers::Array<char>{1};
+            return Containers::Array<char>{NoInit, 1};
         }
     } converter;
 
@@ -3459,7 +3459,7 @@ void AbstractConverterTest::setInputFileCallbackLinkFilesToFileAsDataNotWritable
         }
 
         Containers::Optional<Containers::Array<char>> doLinkDataToData(Containers::ArrayView<const Containers::Pair<Stage, Containers::ArrayView<const char>>>) override {
-            return Containers::Array<char>{1};
+            return Containers::Array<char>{NoInit, 1};
         }
     } converter;
 

src/Magnum/ShaderTools/Test/SpirvTest.cpp

@@ -94,13 +94,14 @@ SpirvTest::SpirvTest() {
 }
 
 void SpirvTest::data() {
-    CORRADE_COMPARE(Implementation::spirvData(Data, sizeof(Data)), Containers::arrayView(Data + 5, 1));
+    CORRADE_COMPARE(Implementation::spirvData(Data, sizeof(Data)).data(), Data + 5);
+    CORRADE_COMPARE(Implementation::spirvData(Data, sizeof(Data)).size(), 1);
 }
 
 void SpirvTest::dataInvalid() {
     auto&& data = InvalidData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
-    CORRADE_VERIFY(!Implementation::spirvData(data.data, data.data.size()));
+    CORRADE_VERIFY(!Implementation::spirvData(data.data.data(), data.data.size()));
 }
 
 UnsignedInt op(UnsignedInt length, SpvOp op) {
@@ -155,7 +156,7 @@ void SpirvTest::nextEntrypoint() {
     CORRADE_VERIFY(data);
 
     /* The file is a full SPIR-V, strip the header first */
-    Containers::ArrayView<const UnsignedInt> view = Implementation::spirvData(*data, data->size());
+    Containers::ArrayView<const UnsignedInt> view = Implementation::spirvData(data->data(), data->size());
     CORRADE_VERIFY(view);
 
     Containers::Optional<Implementation::SpirvEntrypoint> vert = Implementation::spirvNextEntrypoint(view);
@@ -194,7 +195,7 @@ void SpirvTest::entrypointInterface() {
     CORRADE_VERIFY(data);
 
     /* The file is a full SPIR-V, strip the header first */
-    Containers::ArrayView<const UnsignedInt> view = Implementation::spirvData(*data, data->size());
+    Containers::ArrayView<const UnsignedInt> view = Implementation::spirvData(data->data(), data->size());
     CORRADE_VERIFY(view);
 
     Containers::Optional<Implementation::SpirvEntrypoint> vert = Implementation::spirvNextEntrypoint(view);

src/Magnum/ShaderTools/shaderconverter.cpp

@@ -361,7 +361,7 @@ see documentation of a particular converter for more information.)")
             return 24;
         }
 
-        if(Containers::ArrayView<const UnsignedInt> spirv = ShaderTools::Implementation::spirvData(*data, data->size())) {
+        if(Containers::ArrayView<const UnsignedInt> spirv = ShaderTools::Implementation::spirvData(data->data(), data->size())) {
             printSpirvInfo(spirv);
             return 0;
         }
@@ -523,7 +523,7 @@ see documentation of a particular converter for more information.)")
                 return 20; /* same code as the same message below */
             }
 
-            Containers::ArrayView<const UnsignedInt> spirv = ShaderTools::Implementation::spirvData(data, data.size());
+            Containers::ArrayView<const UnsignedInt> spirv = ShaderTools::Implementation::spirvData(data.data(), data.size());
             if(!spirv) {
                 Error{} << "The output is not a SPIR-V binary, can't print info";
                 return 23;

src/Magnum/Shaders/Test/DistanceFieldVectorGLTest.cpp

@@ -1683,7 +1683,7 @@ void DistanceFieldVectorGLTest::renderMulti2D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<DistanceFieldVectorMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<DistanceFieldVectorMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = DistanceFieldVectorMaterialUniform{}
         .setColor(0x00ff00_rgbf);
     materialData[1*data.uniformIncrement] = DistanceFieldVectorMaterialUniform{}
@@ -1692,7 +1692,7 @@ void DistanceFieldVectorGLTest::renderMulti2D() {
         .setOutlineRange(0.6f, 0.4f);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{ValueInit, 2*data.uniformIncrement + 1};
     transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform2D{}
         .setTransformationProjectionMatrix(
             Matrix3::projection({2.1f, 2.1f})*
@@ -1713,7 +1713,7 @@ void DistanceFieldVectorGLTest::renderMulti2D() {
         );
     GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
 
-    Containers::Array<TextureTransformationUniform> textureTransformationData{2*data.uniformIncrement + 1};
+    Containers::Array<TextureTransformationUniform> textureTransformationData{ValueInit, 2*data.uniformIncrement + 1};
     textureTransformationData[0*data.uniformIncrement] = TextureTransformationUniform{}
         .setTextureMatrix(
             /* Additional Y shift + scale in the array slice */
@@ -1742,7 +1742,7 @@ void DistanceFieldVectorGLTest::renderMulti2D() {
         .setLayer(1); /* ignored if not array */
     GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, textureTransformationData};
 
-    Containers::Array<DistanceFieldVectorDrawUniform> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<DistanceFieldVectorDrawUniform> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material offsets are zero if we have single draw, as those are done with
        UBO offset bindings instead. */
     drawData[0*data.uniformIncrement] = DistanceFieldVectorDrawUniform{}
@@ -1983,7 +1983,7 @@ void DistanceFieldVectorGLTest::renderMulti3D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<DistanceFieldVectorMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<DistanceFieldVectorMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = DistanceFieldVectorMaterialUniform{}
         .setColor(0x00ff00_rgbf);
     materialData[1*data.uniformIncrement] = DistanceFieldVectorMaterialUniform{}
@@ -1992,7 +1992,7 @@ void DistanceFieldVectorGLTest::renderMulti3D() {
         .setOutlineRange(0.6f, 0.4f);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationProjectionUniform3D> transformationProjectionData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationProjectionUniform3D> transformationProjectionData{ValueInit, 2*data.uniformIncrement + 1};
     transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform3D{}
         .setTransformationProjectionMatrix(
             Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
@@ -2018,7 +2018,7 @@ void DistanceFieldVectorGLTest::renderMulti3D() {
         );
     GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
 
-    Containers::Array<TextureTransformationUniform> textureTransformationData{2*data.uniformIncrement + 1};
+    Containers::Array<TextureTransformationUniform> textureTransformationData{ValueInit, 2*data.uniformIncrement + 1};
     textureTransformationData[0*data.uniformIncrement] = TextureTransformationUniform{}
         .setTextureMatrix(
             /* Additional Y shift + scale in the array slice */
@@ -2047,7 +2047,7 @@ void DistanceFieldVectorGLTest::renderMulti3D() {
         .setLayer(1); /* ignored if not array */
     GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, textureTransformationData};
 
-    Containers::Array<DistanceFieldVectorDrawUniform> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<DistanceFieldVectorDrawUniform> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material offsets are zero if we have single draw, as those are done with
        UBO offset bindings instead. */
     drawData[0*data.uniformIncrement] = DistanceFieldVectorDrawUniform{}

src/Magnum/Shaders/Test/FlatGLTest.cpp

@@ -5076,7 +5076,7 @@ void FlatGLTest::renderMulti2D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<FlatMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<FlatMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = FlatMaterialUniform{}
         .setColor(data.flags & FlatGL2D::Flag::Textured ?
             0xffffff_rgbf : 0x0000ff_rgbf);
@@ -5085,7 +5085,7 @@ void FlatGLTest::renderMulti2D() {
             0xffffff_rgbf : 0xff0000_rgbf);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{ValueInit, 2*data.uniformIncrement + 1};
     transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform2D{}
         .setTransformationProjectionMatrix(
             Matrix3::projection({2.1f, 2.1f})*
@@ -5106,7 +5106,7 @@ void FlatGLTest::renderMulti2D() {
         );
     GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
 
-    Containers::Array<TextureTransformationUniform> textureTransformationData{2*data.uniformIncrement + 1};
+    Containers::Array<TextureTransformationUniform> textureTransformationData{ValueInit, 2*data.uniformIncrement + 1};
     textureTransformationData[0*data.uniformIncrement] = TextureTransformationUniform{}
         .setTextureMatrix(
             data.flags & FlatGL2D::Flag::TextureArrays ?
@@ -5133,7 +5133,7 @@ void FlatGLTest::renderMulti2D() {
         .setLayer(2); /* ignored if not array */
     GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, textureTransformationData};
 
-    Containers::Array<FlatDrawUniform> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<FlatDrawUniform> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material offsets are zero if we have single draw, as those are
        done with UBO offset bindings instead. */
     drawData[0*data.uniformIncrement] = FlatDrawUniform{}
@@ -5441,7 +5441,7 @@ void FlatGLTest::renderMulti3D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<FlatMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<FlatMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = FlatMaterialUniform{}
         .setColor(data.flags & FlatGL2D::Flag::Textured ?
             0xffffff_rgbf : 0x0000ff_rgbf);
@@ -5450,7 +5450,7 @@ void FlatGLTest::renderMulti3D() {
             0xffffff_rgbf : 0xff0000_rgbf);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationProjectionUniform3D> transformationProjectionData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationProjectionUniform3D> transformationProjectionData{ValueInit, 2*data.uniformIncrement + 1};
     transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform3D{}
         .setTransformationProjectionMatrix(
             Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
@@ -5477,7 +5477,7 @@ void FlatGLTest::renderMulti3D() {
         );
     GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
 
-    Containers::Array<TextureTransformationUniform> textureTransformationData{2*data.uniformIncrement + 1};
+    Containers::Array<TextureTransformationUniform> textureTransformationData{ValueInit, 2*data.uniformIncrement + 1};
     textureTransformationData[0*data.uniformIncrement] = TextureTransformationUniform{}
         .setTextureMatrix(
             data.flags & FlatGL2D::Flag::TextureArrays ?
@@ -5504,7 +5504,7 @@ void FlatGLTest::renderMulti3D() {
         .setLayer(2); /* ignored if not array */
     GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, textureTransformationData};
 
-    Containers::Array<FlatDrawUniform> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<FlatDrawUniform> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material offsets are zero if we have single draw, as those are done with
        UBO offset bindings instead. */
     drawData[0*data.uniformIncrement] = FlatDrawUniform{}
@@ -5749,14 +5749,14 @@ void FlatGLTest::renderMultiSkinning2D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<FlatMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<FlatMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = FlatMaterialUniform{}
         .setColor(0x33ffff_rgbf);
     materialData[1*data.uniformIncrement] = FlatMaterialUniform{}
         .setColor(0xffff33_rgbf);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{ValueInit, 2*data.uniformIncrement + 1};
     transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform2D{}
         .setTransformationProjectionMatrix(
             Matrix3::scaling(Vector2{0.3f})*
@@ -5771,7 +5771,7 @@ void FlatGLTest::renderMultiSkinning2D() {
             Matrix3::translation({-1.5f,  1.5f}));
     GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
 
-    Containers::Array<TransformationUniform2D> jointData{Math::max(2*data.uniformIncrement + 4, 10u)};
+    Containers::Array<TransformationUniform2D> jointData{ValueInit, Math::max(2*data.uniformIncrement + 4, 10u)};
     /* First draw moves both bottom corners */
     jointData[Math::max(0*data.uniformIncrement, 0u) + 0] = TransformationUniform2D{}
         .setTransformationMatrix(Matrix3::translation({ 0.5f, -0.5f}));
@@ -5797,7 +5797,7 @@ void FlatGLTest::renderMultiSkinning2D() {
     GL::Buffer jointUniform{GL::Buffer::TargetHint::Uniform,
         jointData};
 
-    Containers::Array<FlatDrawUniform> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<FlatDrawUniform> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material / joint offsets are zero if we have single draw, as those are
        done with UBO offset bindings instead */
     drawData[0*data.uniformIncrement] = FlatDrawUniform{}
@@ -6001,14 +6001,14 @@ void FlatGLTest::renderMultiSkinning3D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<FlatMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<FlatMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = FlatMaterialUniform{}
         .setColor(0x33ffff_rgbf);
     materialData[1*data.uniformIncrement] = FlatMaterialUniform{}
         .setColor(0xffff33_rgbf);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationProjectionUniform3D> transformationProjectionData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationProjectionUniform3D> transformationProjectionData{ValueInit, 2*data.uniformIncrement + 1};
     transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform3D{}
         .setTransformationProjectionMatrix(
             Matrix4::scaling(Vector3{0.3f})*
@@ -6023,7 +6023,7 @@ void FlatGLTest::renderMultiSkinning3D() {
             Matrix4::translation({-1.5f,  1.5f, 0.0f}));
     GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
 
-    Containers::Array<TransformationUniform3D> jointData{Math::max(2*data.uniformIncrement + 4, 10u)};
+    Containers::Array<TransformationUniform3D> jointData{ValueInit, Math::max(2*data.uniformIncrement + 4, 10u)};
     /* First draw moves both bottom corners */
     jointData[Math::max(0*data.uniformIncrement, 0u) + 0] = TransformationUniform3D{}
         .setTransformationMatrix(Matrix4::translation({ 0.5f, -0.5f, 0.0f}));
@@ -6049,7 +6049,7 @@ void FlatGLTest::renderMultiSkinning3D() {
     GL::Buffer jointUniform{GL::Buffer::TargetHint::Uniform,
         jointData};
 
-    Containers::Array<FlatDrawUniform> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<FlatDrawUniform> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material / joint offsets are zero if we have single draw, as those are
        done with UBO offset bindings instead */
     drawData[0*data.uniformIncrement] = FlatDrawUniform{}

src/Magnum/Shaders/Test/LineGLTest.cpp

@@ -2751,7 +2751,7 @@ void LineGLTest::renderMulti2D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<LineMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<LineMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = LineMaterialUniform{}
         .setColor(0x0000ff_rgbf)
         .setWidth(3.0f)
@@ -2762,7 +2762,7 @@ void LineGLTest::renderMulti2D() {
         .setSmoothness(1.0f);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{ValueInit, 2*data.uniformIncrement + 1};
     transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform2D{}
         .setTransformationProjectionMatrix(
             Matrix3::projection({2.1f, 2.1f})*
@@ -2783,7 +2783,7 @@ void LineGLTest::renderMulti2D() {
         );
     GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
 
-    Containers::Array<LineDrawUniform> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<LineDrawUniform> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material offsets are zero if we have single draw, as those are
        done with UBO offset bindings instead. */
     drawData[0*data.uniformIncrement] = LineDrawUniform{}
@@ -2982,7 +2982,7 @@ void LineGLTest::renderMulti3D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<LineMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<LineMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = LineMaterialUniform{}
         .setColor(0x0000ff_rgbf)
         .setWidth(3.0f)
@@ -2993,7 +2993,7 @@ void LineGLTest::renderMulti3D() {
         .setSmoothness(1.0f);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationProjectionUniform3D> transformationProjectionData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationProjectionUniform3D> transformationProjectionData{ValueInit, 2*data.uniformIncrement + 1};
     transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform3D{}
         .setTransformationProjectionMatrix(
             Matrix4::orthographicProjection({2.1f, 2.1f}, -1.0f, 1.0f)*
@@ -3014,7 +3014,7 @@ void LineGLTest::renderMulti3D() {
         );
     GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
 
-    Containers::Array<LineDrawUniform> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<LineDrawUniform> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material offsets are zero if we have single draw, as those are
        done with UBO offset bindings instead. */
     drawData[0*data.uniformIncrement] = LineDrawUniform{}

src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp

@@ -3657,7 +3657,7 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderDefault
         .setSubImage(0, {}, ImageView2D{PixelFormat::RGB8Srgb, size, map});
 
     /* Generate per-face IDs going from 0 to 240 to cover the whole range */
-    Containers::Array<UnsignedInt> ids{16};
+    Containers::Array<UnsignedInt> ids{NoInit, 16};
     for(std::size_t i = 0; i != ids.size(); ++i) ids[i] = i*16;
     GL::Mesh circle = MeshTools::compile(MeshTools::combineFaceAttributes(
         MeshTools::generateIndices(Primitives::circle2DSolid(16)), {
@@ -3756,7 +3756,7 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderDefault
         .setSubImage(0, {}, ImageView2D{PixelFormat::RGB8Srgb, size, map});
 
     /* Generate per-face IDs going from 0 to 228 to cover the whole range */
-    Containers::Array<UnsignedInt> ids{20};
+    Containers::Array<UnsignedInt> ids{NoInit, 20};
     for(std::size_t i = 0; i != ids.size(); ++i) ids[i] = i*12;
     GL::Mesh icosphere = MeshTools::compile(MeshTools::combineFaceAttributes(
         Primitives::icosphereSolid(0), {
@@ -4321,7 +4321,7 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderWirefra
         if(!GL::Context::current().isExtensionSupported<GL::Extensions::MAGNUM::shader_vertex_id>())
         #endif
         {
-            Containers::Array<Float> vertexIndex{circleDataIndexed.indexCount()};
+            Containers::Array<Float> vertexIndex{NoInit, circleDataIndexed.indexCount()};
             std::iota(vertexIndex.begin(), vertexIndex.end(), 0.0f);
 
             GL::Buffer vertexId;
@@ -4473,7 +4473,7 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderWirefra
         if(!GL::Context::current().isExtensionSupported<GL::Extensions::MAGNUM::shader_vertex_id>())
         #endif
         {
-            Containers::Array<Float> vertexIndex{sphereData.indexCount()};
+            Containers::Array<Float> vertexIndex{NoInit, sphereData.indexCount()};
             std::iota(vertexIndex.begin(), vertexIndex.end(), 0.0f);
 
             GL::Buffer vertexId;
@@ -4658,7 +4658,7 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderObjectV
     /* Add the instanced Object ID data even if visualizing just uniform object
        ID, to test the attribute isn't accidentally accessed always */
     if(data.flags2D & MeshVisualizerGL2D::Flag::ObjectId) {
-        Containers::Array<UnsignedInt> ids{16};
+        Containers::Array<UnsignedInt> ids{NoInit, 16};
         /* Each two faces share the same ID */
         for(std::size_t i = 0; i != ids.size(); ++i) ids[i] = i/2;
         circleData = MeshTools::combineFaceAttributes(
@@ -4874,7 +4874,7 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderObjectV
     /* Add the instanced Object ID data even if visualizing just uniform object
        ID, to test the attribute isn't accidentally accessed always */
     if(data.flags3D & MeshVisualizerGL3D::Flag::ObjectId) {
-        Containers::Array<UnsignedInt> ids{sphereData.indexCount()/3};
+        Containers::Array<UnsignedInt> ids{NoInit, sphereData.indexCount()/3};
         /* Each two faces share the same ID */
         for(std::size_t i = 0; i != ids.size(); ++i) ids[i] = i/2;
         sphereData = MeshTools::combineFaceAttributes(
@@ -5713,7 +5713,7 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderInstanc
         if(!GL::Context::current().isExtensionSupported<GL::Extensions::MAGNUM::shader_vertex_id>())
         #endif
         {
-            Containers::Array<Float> vertexIndex{circleDataIndexed.indexCount()};
+            Containers::Array<Float> vertexIndex{NoInit, circleDataIndexed.indexCount()};
             std::iota(vertexIndex.begin(), vertexIndex.end(), 0.0f);
 
             GL::Buffer vertexId;
@@ -6007,7 +6007,7 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderInstanc
         if(!GL::Context::current().isExtensionSupported<GL::Extensions::MAGNUM::shader_vertex_id>())
         #endif
         {
-            Containers::Array<Float> vertexIndex{sphereData.indexCount()};
+            Containers::Array<Float> vertexIndex{NoInit, sphereData.indexCount()};
             std::iota(vertexIndex.begin(), vertexIndex.end(), 0.0f);
 
             GL::Buffer vertexId;
@@ -6691,7 +6691,7 @@ void MeshVisualizerGLTest::renderMulti2D() {
        attribute. Use the same numbers for all meshes, it'll get differentiated
        by the per-draw object ID. */
     if(data.flags & MeshVisualizerGL2D::Flag::ObjectId) {
-        Containers::Array<UnsignedInt> ids{8};
+        Containers::Array<UnsignedInt> ids{NoInit, 8};
         /* Each two faces share the same ID */
         for(std::size_t i = 0; i != ids.size(); ++i) ids[i] = i/2;
         for(Trade::MeshData* i: {&circleData, &squareData, &triangleData}) {
@@ -6729,7 +6729,7 @@ void MeshVisualizerGLTest::renderMulti2D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<MeshVisualizerMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<MeshVisualizerMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = MeshVisualizerMaterialUniform{}
         .setColor(0xffffcc_rgbf)
         .setWireframeColor(0xcc0000_rgbf);
@@ -6755,7 +6755,7 @@ void MeshVisualizerGLTest::renderMulti2D() {
         materialData[1*data.uniformIncrement].setColorMapTransformation(0.5f/12, 1.0f/12);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{ValueInit, 2*data.uniformIncrement + 1};
     transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform2D{}
         .setTransformationProjectionMatrix(
             Matrix3::projection({2.1f, 2.1f})*
@@ -6776,7 +6776,7 @@ void MeshVisualizerGLTest::renderMulti2D() {
         );
     GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
 
-    Containers::Array<TextureTransformationUniform> textureTransformationData{2*data.uniformIncrement + 1};
+    Containers::Array<TextureTransformationUniform> textureTransformationData{ValueInit, 2*data.uniformIncrement + 1};
     textureTransformationData[0*data.uniformIncrement] = TextureTransformationUniform{}
         .setTextureMatrix(
             data.flags & MeshVisualizerGL2D::Flag::TextureArrays ?
@@ -6803,7 +6803,7 @@ void MeshVisualizerGLTest::renderMulti2D() {
         .setLayer(2); /* ignored if not array */
     GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, textureTransformationData};
 
-    Containers::Array<MeshVisualizerDrawUniform2D> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<MeshVisualizerDrawUniform2D> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material offsets are zero if we have single draw, as those are done with
        UBO offset bindings instead. */
     drawData[0*data.uniformIncrement] = MeshVisualizerDrawUniform2D{}
@@ -7033,7 +7033,7 @@ void MeshVisualizerGLTest::renderMulti3D() {
        attribute. Use the same numbers for all meshes, it'll get differentiated
        by the per-draw object ID. */
     if(data.flags & MeshVisualizerGL3D::Flag::ObjectId) {
-        Containers::Array<UnsignedInt> ids{20};
+        Containers::Array<UnsignedInt> ids{NoInit, 20};
         /* Each two faces share the same ID */
         for(std::size_t i = 0; i != ids.size(); ++i) ids[i] = i/2;
         for(Trade::MeshData* i: {&sphereData, &planeData, &coneData}) {
@@ -7078,7 +7078,7 @@ void MeshVisualizerGLTest::renderMulti3D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<MeshVisualizerMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<MeshVisualizerMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = MeshVisualizerMaterialUniform{}
         .setColor(0xffffcc_rgbf)
         .setWireframeColor(0xcc0000_rgbf)
@@ -7106,7 +7106,7 @@ void MeshVisualizerGLTest::renderMulti3D() {
         materialData[1*data.uniformIncrement].setColorMapTransformation(0.5f/30, 1.0f/30);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationUniform3D> transformationData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationUniform3D> transformationData{ValueInit, 2*data.uniformIncrement + 1};
     transformationData[0*data.uniformIncrement] = TransformationUniform3D{}
         .setTransformationMatrix(
             Matrix4::translation(Vector3::zAxis(-2.15f))*
@@ -7127,7 +7127,7 @@ void MeshVisualizerGLTest::renderMulti3D() {
         );
     GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, transformationData};
 
-    Containers::Array<TextureTransformationUniform> textureTransformationData{2*data.uniformIncrement + 1};
+    Containers::Array<TextureTransformationUniform> textureTransformationData{ValueInit, 2*data.uniformIncrement + 1};
     textureTransformationData[0*data.uniformIncrement] = TextureTransformationUniform{}
         .setTextureMatrix(
             data.flags & MeshVisualizerGL3D::Flag::TextureArrays ?
@@ -7154,7 +7154,7 @@ void MeshVisualizerGLTest::renderMulti3D() {
         .setLayer(2); /* ignored if not array */
     GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, textureTransformationData};
 
-    Containers::Array<MeshVisualizerDrawUniform3D> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<MeshVisualizerDrawUniform3D> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material offsets are zero if we have single draw, as those are done with
        UBO offset bindings instead. Also no need to supply a normal matrix. */
     drawData[0*data.uniformIncrement] = MeshVisualizerDrawUniform3D{}
@@ -7370,7 +7370,7 @@ void MeshVisualizerGLTest::renderMultiSkinningWireframe2D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<MeshVisualizerMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<MeshVisualizerMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = MeshVisualizerMaterialUniform{}
         .setColor(0xffffcc_rgbf)
         .setWireframeColor(0xcc0000_rgbf);
@@ -7379,7 +7379,7 @@ void MeshVisualizerGLTest::renderMultiSkinningWireframe2D() {
         .setWireframeColor(0x0000cc_rgbf);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{ValueInit, 2*data.uniformIncrement + 1};
     transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform2D{}
         .setTransformationProjectionMatrix(
             Matrix3::scaling(Vector2{0.3f})*
@@ -7394,7 +7394,7 @@ void MeshVisualizerGLTest::renderMultiSkinningWireframe2D() {
             Matrix3::translation({-1.5f,  1.5f}));
     GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
 
-    Containers::Array<TransformationUniform2D> jointData{Math::max(2*data.uniformIncrement + 4, 10u)};
+    Containers::Array<TransformationUniform2D> jointData{ValueInit, Math::max(2*data.uniformIncrement + 4, 10u)};
     /* First draw moves both bottom corners */
     jointData[Math::max(0*data.uniformIncrement, 0u) + 0] = TransformationUniform2D{}
         .setTransformationMatrix(Matrix3::translation({ 0.5f, -0.5f}));
@@ -7420,7 +7420,7 @@ void MeshVisualizerGLTest::renderMultiSkinningWireframe2D() {
     GL::Buffer jointUniform{GL::Buffer::TargetHint::Uniform,
         jointData};
 
-    Containers::Array<MeshVisualizerDrawUniform2D> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<MeshVisualizerDrawUniform2D> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material / joint offsets are zero if we have single draw, as those are
        done with UBO offset bindings instead */
     drawData[0*data.uniformIncrement] = MeshVisualizerDrawUniform2D{}
@@ -7621,7 +7621,7 @@ void MeshVisualizerGLTest::renderMultiSkinningWireframe3D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<MeshVisualizerMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<MeshVisualizerMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = MeshVisualizerMaterialUniform{}
         .setColor(0xffffcc_rgbf)
         .setWireframeColor(0xcc0000_rgbf);
@@ -7630,7 +7630,7 @@ void MeshVisualizerGLTest::renderMultiSkinningWireframe3D() {
         .setWireframeColor(0x0000cc_rgbf);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationUniform3D> transformationData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationUniform3D> transformationData{ValueInit, 2*data.uniformIncrement + 1};
     transformationData[0*data.uniformIncrement] = TransformationUniform3D{}
         .setTransformationMatrix(
             Matrix4::scaling(Vector3{0.3f})*
@@ -7645,7 +7645,7 @@ void MeshVisualizerGLTest::renderMultiSkinningWireframe3D() {
             Matrix4::translation({-1.5f,  1.5f, 0.0f}));
     GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, transformationData};
 
-    Containers::Array<TransformationUniform3D> jointData{Math::max(2*data.uniformIncrement + 4, 10u)};
+    Containers::Array<TransformationUniform3D> jointData{ValueInit, Math::max(2*data.uniformIncrement + 4, 10u)};
     /* First draw moves both bottom corners */
     jointData[Math::max(0*data.uniformIncrement, 0u) + 0] = TransformationUniform3D{}
         .setTransformationMatrix(Matrix4::translation({ 0.5f, -0.5f, 0.0f}));
@@ -7671,7 +7671,7 @@ void MeshVisualizerGLTest::renderMultiSkinningWireframe3D() {
     GL::Buffer jointUniform{GL::Buffer::TargetHint::Uniform,
         jointData};
 
-    Containers::Array<MeshVisualizerDrawUniform3D> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<MeshVisualizerDrawUniform3D> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material / joint offsets are zero if we have single draw, as those are
        done with UBO offset bindings instead */
     drawData[0*data.uniformIncrement] = MeshVisualizerDrawUniform3D{}

src/Magnum/Shaders/Test/PhongGLTest.cpp

@@ -5518,7 +5518,7 @@ void PhongGLTest::renderMulti() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<PhongMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<PhongMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = PhongMaterialUniform{}
         .setDiffuseColor(data.flags & PhongGL::Flag::DiffuseTexture ?
             0xffffff_rgbf : 0x00ffff_rgbf);
@@ -5530,7 +5530,7 @@ void PhongGLTest::renderMulti() {
     /* The shader has two lights hardcoded, so make sure the buffer can fit
        2 items enough even though the last draw needs just one light. Not a
        problem on desktop, but WebGL complains. */
-    Containers::Array<PhongLightUniform> lightData{2*data.uniformIncrement + 2};
+    Containers::Array<PhongLightUniform> lightData{ValueInit, 2*data.uniformIncrement + 2};
     lightData[0*data.uniformIncrement] = PhongLightUniform{}
         .setPosition(Vector4{0.0f, 0.0f, 1.0f, 0.0f})
         .setColor(data.flags & PhongGL::Flag::DiffuseTexture ?
@@ -5551,7 +5551,7 @@ void PhongGLTest::renderMulti() {
             0xffffff_rgbf : 0xff00ff_rgbf);
     GL::Buffer lightUniform{GL::Buffer::TargetHint::Uniform, lightData};
 
-    Containers::Array<TransformationUniform3D> transformationData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationUniform3D> transformationData{ValueInit, 2*data.uniformIncrement + 1};
     transformationData[0*data.uniformIncrement] = TransformationUniform3D{}
         .setTransformationMatrix(
             Matrix4::translation(Vector3::zAxis(-2.15f))*
@@ -5574,7 +5574,7 @@ void PhongGLTest::renderMulti() {
         );
     GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, transformationData};
 
-    Containers::Array<TextureTransformationUniform> textureTransformationData{2*data.uniformIncrement + 1};
+    Containers::Array<TextureTransformationUniform> textureTransformationData{ValueInit, 2*data.uniformIncrement + 1};
     textureTransformationData[0*data.uniformIncrement] = TextureTransformationUniform{}
         .setTextureMatrix(
             data.flags & PhongGL::Flag::TextureArrays ?
@@ -5601,7 +5601,7 @@ void PhongGLTest::renderMulti() {
         .setLayer(2); /* ignored if not array */
     GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, textureTransformationData};
 
-    Containers::Array<PhongDrawUniform> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<PhongDrawUniform> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material / light offsets are zero if we have single draw, as those are
        done with UBO offset bindings instead. */
     drawData[0*data.uniformIncrement] = PhongDrawUniform{}
@@ -5865,14 +5865,14 @@ void PhongGLTest::renderMultiSkinning() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<PhongMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<PhongMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = PhongMaterialUniform{}
         .setAmbientColor(0x33ffff_rgbf);
     materialData[1*data.uniformIncrement] = PhongMaterialUniform{}
         .setAmbientColor(0xffff33_rgbf);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationUniform3D> transformationData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationUniform3D> transformationData{ValueInit, 2*data.uniformIncrement + 1};
     transformationData[0*data.uniformIncrement] = TransformationUniform3D{}
         .setTransformationMatrix(Matrix4::scaling(Vector3{0.3f})*
                                  Matrix4::translation({ 0.0f, -1.5f, 0.0f}));
@@ -5884,7 +5884,7 @@ void PhongGLTest::renderMultiSkinning() {
                                  Matrix4::translation({-1.5f,  1.5f, 0.0f}));
     GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, transformationData};
 
-    Containers::Array<TransformationUniform3D> jointData{Math::max(2*data.uniformIncrement + 4, 10u)};
+    Containers::Array<TransformationUniform3D> jointData{ValueInit, Math::max(2*data.uniformIncrement + 4, 10u)};
     /* First draw moves both bottom corners */
     jointData[Math::max(0*data.uniformIncrement, 0u) + 0] = TransformationUniform3D{}
         .setTransformationMatrix(Matrix4::translation({ 0.5f, -0.5f, 0.0f}));
@@ -5910,7 +5910,7 @@ void PhongGLTest::renderMultiSkinning() {
     GL::Buffer jointUniform{GL::Buffer::TargetHint::Uniform,
         jointData};
 
-    Containers::Array<PhongDrawUniform> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<PhongDrawUniform> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material / joint offsets are zero if we have single draw, as those are
        done with UBO offset bindings instead */
     drawData[0*data.uniformIncrement] = PhongDrawUniform{}

src/Magnum/Shaders/Test/ShadersGLBenchmark.cpp

@@ -609,16 +609,16 @@ template<UnsignedInt dimensions> void ShadersGLBenchmark::flat() {
     GL::Buffer textureTransformationUniform{NoCreate};
     GL::Buffer materialUniform{NoCreate};
     if(data.flags & FlatGL2D::Flag::UniformBuffers) {
-        transformationProjectionUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<typename UniformTraits<dimensions>::TransformationProjection>{data.drawCount}};
-        drawUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<FlatDrawUniform>{data.drawCount}};
-        Containers::Array<FlatMaterialUniform> materialData{data.materialCount};
+        transformationProjectionUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<typename UniformTraits<dimensions>::TransformationProjection>{ValueInit, data.drawCount}};
+        drawUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<FlatDrawUniform>{ValueInit, data.drawCount}};
+        Containers::Array<FlatMaterialUniform> materialData{ValueInit, data.materialCount};
         materialData[0].setAlphaMask(0.0f);
         materialUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, materialData};
         shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
             .bindDrawBuffer(drawUniform)
             .bindMaterialBuffer(materialUniform);
         if(data.flags & FlatGL2D::Flag::TextureTransformation) {
-            textureTransformationUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<TextureTransformationUniform>{data.drawCount}};
+            textureTransformationUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<TextureTransformationUniform>{ValueInit, data.drawCount}};
             shader.bindTextureTransformationBuffer(textureTransformationUniform);
         }
     } else
@@ -732,16 +732,16 @@ void ShadersGLBenchmark::phong() {
         lightUniform = GL::Buffer{};
         textureTransformationUniform = GL::Buffer{};
 
-        Containers::Array<TransformationUniform3D> transformationData{data.drawCount};
-        Containers::Array<PhongDrawUniform> drawData{data.drawCount};
+        Containers::Array<TransformationUniform3D> transformationData{ValueInit, data.drawCount};
+        Containers::Array<PhongDrawUniform> drawData{ValueInit, data.drawCount};
         drawData[0].lightCount = 5; /* Cap at 5 lights, even if more is set */
-        Containers::Array<PhongMaterialUniform> materialData{data.materialCount};
+        Containers::Array<PhongMaterialUniform> materialData{ValueInit, data.materialCount};
         materialData[0]
             /* White ambient so we always have a white output */
             .setAmbientColor(0xffffffff_rgbaf)
             .setAlphaMask(0.0f);
-        Containers::Array<PhongLightUniform> lightData{data.lightCount};
-        Containers::Array<TextureTransformationUniform> textureTransformationData{data.drawCount};
+        Containers::Array<PhongLightUniform> lightData{ValueInit, data.lightCount};
+        Containers::Array<TextureTransformationUniform> textureTransformationData{ValueInit, data.drawCount};
 
         #ifndef MAGNUM_TARGET_GLES
         if(data.bufferStorage) {
@@ -890,7 +890,7 @@ template<UnsignedInt dimensions> void ShadersGLBenchmark::vertexColor() {
     GL::Buffer transformationProjectionUniform{NoCreate};
     GL::Buffer textureTransformationUniform{NoCreate};
     if(data.flags & VertexColorGL<dimensions>::Flag::UniformBuffers) {
-        transformationProjectionUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<typename UniformTraits<dimensions>::TransformationProjection>{data.drawCount}};
+        transformationProjectionUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<typename UniformTraits<dimensions>::TransformationProjection>{ValueInit, data.drawCount}};
         shader.bindTransformationProjectionBuffer(transformationProjectionUniform);
     }
     #endif
@@ -954,9 +954,9 @@ template<UnsignedInt dimensions> void ShadersGLBenchmark::vector() {
     GL::Buffer textureTransformationUniform{NoCreate};
     GL::Buffer materialUniform{NoCreate};
     if(data.flags & VectorGL2D::Flag::UniformBuffers) {
-        transformationProjectionUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<typename UniformTraits<dimensions>::TransformationProjection>{data.drawCount}};
-        drawUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<VectorDrawUniform>{data.drawCount}};
-        materialUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<VectorMaterialUniform>{data.materialCount}};
+        transformationProjectionUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<typename UniformTraits<dimensions>::TransformationProjection>{ValueInit, data.drawCount}};
+        drawUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<VectorDrawUniform>{ValueInit, data.drawCount}};
+        materialUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<VectorMaterialUniform>{ValueInit, data.materialCount}};
         shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
             .bindDrawBuffer(drawUniform)
             .bindMaterialBuffer(materialUniform);
@@ -1028,14 +1028,14 @@ template<UnsignedInt dimensions> void ShadersGLBenchmark::distanceFieldVector()
     GL::Buffer materialUniform{NoCreate};
     GL::Buffer textureTransformationUniform{NoCreate};
     if(data.flags & DistanceFieldVectorGL2D::Flag::UniformBuffers) {
-        transformationProjectionUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<typename UniformTraits<dimensions>::TransformationProjection>{data.drawCount}};
-        drawUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<DistanceFieldVectorDrawUniform>{data.drawCount}};
-        materialUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<DistanceFieldVectorMaterialUniform>{data.materialCount}};
+        transformationProjectionUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<typename UniformTraits<dimensions>::TransformationProjection>{ValueInit, data.drawCount}};
+        drawUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<DistanceFieldVectorDrawUniform>{ValueInit, data.drawCount}};
+        materialUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<DistanceFieldVectorMaterialUniform>{ValueInit, data.materialCount}};
         shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
             .bindDrawBuffer(drawUniform)
             .bindMaterialBuffer(materialUniform);
         if(data.flags & DistanceFieldVectorGL2D::Flag::TextureTransformation) {
-            textureTransformationUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<TextureTransformationUniform>{data.drawCount}};
+            textureTransformationUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<TextureTransformationUniform>{ValueInit, data.drawCount}};
             shader.bindTextureTransformationBuffer(textureTransformationUniform);
         }
     }
@@ -1144,9 +1144,9 @@ void ShadersGLBenchmark::meshVisualizer2D() {
     GL::Buffer drawUniform{NoCreate};
     GL::Buffer materialUniform{NoCreate};
     if(data.flags & MeshVisualizerGL2D::Flag::UniformBuffers) {
-        transformationProjectionUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<TransformationProjectionUniform2D>{data.drawCount}};
-        drawUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<MeshVisualizerDrawUniform2D>{data.drawCount}};
-        Containers::Array<MeshVisualizerMaterialUniform> materialData{data.materialCount};
+        transformationProjectionUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<TransformationProjectionUniform2D>{ValueInit, data.drawCount}};
+        drawUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<MeshVisualizerDrawUniform2D>{ValueInit, data.drawCount}};
+        Containers::Array<MeshVisualizerMaterialUniform> materialData{ValueInit, data.materialCount};
         materialData[0].setWireframeColor(0xffffffff_rgbaf);
         materialUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, materialData};
         shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
@@ -1284,9 +1284,9 @@ void ShadersGLBenchmark::meshVisualizer3D() {
         projectionUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, {
             ProjectionUniform3D{}
         }};
-        transformationUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<TransformationUniform3D>{data.drawCount}};
-        drawUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<MeshVisualizerDrawUniform3D>{data.drawCount}};
-        Containers::Array<MeshVisualizerMaterialUniform> materialData{data.materialCount};
+        transformationUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<TransformationUniform3D>{ValueInit, data.drawCount}};
+        drawUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, Containers::Array<MeshVisualizerDrawUniform3D>{ValueInit, data.drawCount}};
+        Containers::Array<MeshVisualizerMaterialUniform> materialData{ValueInit, data.materialCount};
         materialData[0].setWireframeColor(0xffffffff_rgbaf);
         materialData[0].setLineLength(0.0f);
         materialUniform = GL::Buffer{GL::Buffer::TargetHint::Uniform, materialData};

src/Magnum/Shaders/Test/VectorGLTest.cpp

@@ -1645,7 +1645,7 @@ void VectorGLTest::renderMulti2D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<VectorMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<VectorMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = VectorMaterialUniform{}
         .setColor(0xff0000_rgbf)
         .setBackgroundColor(0xffcccc_rgbf);
@@ -1654,7 +1654,7 @@ void VectorGLTest::renderMulti2D() {
         .setBackgroundColor(0xccffcc_rgbf);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{ValueInit, 2*data.uniformIncrement + 1};
     transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform2D{}
         .setTransformationProjectionMatrix(
             Matrix3::projection({2.1f, 2.1f})*
@@ -1675,7 +1675,7 @@ void VectorGLTest::renderMulti2D() {
         );
     GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
 
-    Containers::Array<TextureTransformationUniform> textureTransformationData{2*data.uniformIncrement + 1};
+    Containers::Array<TextureTransformationUniform> textureTransformationData{ValueInit, 2*data.uniformIncrement + 1};
     textureTransformationData[0*data.uniformIncrement] = TextureTransformationUniform{}
         .setTextureMatrix(
             /* Additional Y shift + scale in the array slice */
@@ -1704,7 +1704,7 @@ void VectorGLTest::renderMulti2D() {
         .setLayer(1); /* ignored if not array */
     GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, textureTransformationData};
 
-    Containers::Array<VectorDrawUniform> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<VectorDrawUniform> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material offsets are zero if we have single draw, as those are done with
        UBO offset bindings instead. */
     drawData[0*data.uniformIncrement] = VectorDrawUniform{}
@@ -1945,7 +1945,7 @@ void VectorGLTest::renderMulti3D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<VectorMaterialUniform> materialData{data.uniformIncrement + 1};
+    Containers::Array<VectorMaterialUniform> materialData{ValueInit, data.uniformIncrement + 1};
     materialData[0*data.uniformIncrement] = VectorMaterialUniform{}
         .setColor(0xff0000_rgbf)
         .setBackgroundColor(0xffcccc_rgbf);
@@ -1954,7 +1954,7 @@ void VectorGLTest::renderMulti3D() {
         .setBackgroundColor(0xccffcc_rgbf);
     GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
 
-    Containers::Array<TransformationProjectionUniform3D> transformationProjectionData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationProjectionUniform3D> transformationProjectionData{ValueInit, 2*data.uniformIncrement + 1};
     transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform3D{}
         .setTransformationProjectionMatrix(
             Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
@@ -1980,7 +1980,7 @@ void VectorGLTest::renderMulti3D() {
         );
     GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
 
-    Containers::Array<TextureTransformationUniform> textureTransformationData{2*data.uniformIncrement + 1};
+    Containers::Array<TextureTransformationUniform> textureTransformationData{ValueInit, 2*data.uniformIncrement + 1};
     textureTransformationData[0*data.uniformIncrement] = TextureTransformationUniform{}
         .setTextureMatrix(
             /* Additional Y shift + scale in the array slice */
@@ -2009,7 +2009,7 @@ void VectorGLTest::renderMulti3D() {
         .setLayer(1); /* ignored if not array */
     GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, textureTransformationData};
 
-    Containers::Array<VectorDrawUniform> drawData{2*data.uniformIncrement + 1};
+    Containers::Array<VectorDrawUniform> drawData{ValueInit, 2*data.uniformIncrement + 1};
     /* Material offsets are zero if we have single draw, as those are done with
        UBO offset bindings instead. */
     drawData[0*data.uniformIncrement] = VectorDrawUniform{}

src/Magnum/Shaders/Test/VertexColorGLTest.cpp

@@ -1063,7 +1063,7 @@ void VertexColorGLTest::renderMulti2D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{ValueInit, 2*data.uniformIncrement + 1};
     transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform2D{}
         .setTransformationProjectionMatrix(
             Matrix3::projection({2.1f, 2.1f})*
@@ -1209,7 +1209,7 @@ void VertexColorGLTest::renderMulti3D() {
        The data.uniformIncrement is set high enough to ensure that, in the
        non-offset-bind case this value is 1. */
 
-    Containers::Array<TransformationProjectionUniform3D> transformationProjectionData{2*data.uniformIncrement + 1};
+    Containers::Array<TransformationProjectionUniform3D> transformationProjectionData{ValueInit, 2*data.uniformIncrement + 1};
     transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform3D{}
         .setTransformationProjectionMatrix(
             Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*

src/Magnum/Test/ImageTest.cpp

@@ -237,7 +237,7 @@ void ImageTest::constructGeneric() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 4);
         CORRADE_COMPARE(a.size(), (Vector2i{1, 3}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 4*4);
     } {
         auto data = new char[3*2];
@@ -250,7 +250,7 @@ void ImageTest::constructGeneric() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 2);
         CORRADE_COMPARE(a.size(), (Vector2i{1, 3}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 3*2);
     }
 }
@@ -265,7 +265,7 @@ void ImageTest::constructGenericPlaceholder() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 8);
         CORRADE_COMPARE(a.size(), Vector2i{});
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     } {
         Image2D a{
             PixelStorage{}
@@ -281,7 +281,7 @@ void ImageTest::constructGenericPlaceholder() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 6);
         CORRADE_COMPARE(a.size(), Vector2i{});
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     }
 }
 
@@ -297,7 +297,7 @@ void ImageTest::constructImplementationSpecific() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 12);
         CORRADE_COMPARE(a.size(), (Vector2i{1, 3}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 3*12);
     } {
         auto data = new char[3*12];
@@ -310,7 +310,7 @@ void ImageTest::constructImplementationSpecific() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 12);
         CORRADE_COMPARE(a.size(), (Vector2i{1, 3}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 3*12);
     }
 
@@ -325,7 +325,7 @@ void ImageTest::constructImplementationSpecific() {
         CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
         CORRADE_COMPARE(a.pixelSize(), 6);
         CORRADE_COMPARE(a.size(), (Vector2i{1, 3}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 3*8);
     } {
         auto data = new char[3*6];
@@ -337,7 +337,7 @@ void ImageTest::constructImplementationSpecific() {
         CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
         CORRADE_COMPARE(a.pixelSize(), 6);
         CORRADE_COMPARE(a.size(), (Vector2i{1, 3}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 3*6);
     }
 
@@ -352,7 +352,7 @@ void ImageTest::constructImplementationSpecific() {
         CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
         CORRADE_COMPARE(a.pixelSize(), 6);
         CORRADE_COMPARE(a.size(), (Vector2i{1, 3}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 3*6);
     }
 }
@@ -368,7 +368,7 @@ void ImageTest::constructImplementationSpecificPlaceholder() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 12);
         CORRADE_COMPARE(a.size(), Vector2i{});
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     } {
         Image2D a{
             PixelStorage{}
@@ -384,7 +384,7 @@ void ImageTest::constructImplementationSpecificPlaceholder() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 12);
         CORRADE_COMPARE(a.size(), Vector2i{});
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     }
 
     /* Format + extra */
@@ -397,7 +397,7 @@ void ImageTest::constructImplementationSpecificPlaceholder() {
         CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
         CORRADE_COMPARE(a.pixelSize(), 6);
         CORRADE_COMPARE(a.size(), Vector2i{});
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     } {
         Image2D a{
             PixelStorage{}
@@ -413,7 +413,7 @@ void ImageTest::constructImplementationSpecificPlaceholder() {
         CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
         CORRADE_COMPARE(a.pixelSize(), 6);
         CORRADE_COMPARE(a.size(), Vector2i{});
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     }
 
     /* Manual pixel size */
@@ -430,7 +430,7 @@ void ImageTest::constructImplementationSpecificPlaceholder() {
         CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
         CORRADE_COMPARE(a.pixelSize(), 6);
         CORRADE_COMPARE(a.size(), Vector2i{});
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     }
 }
 
@@ -447,7 +447,7 @@ void ImageTest::constructCompressedGeneric() {
         CORRADE_COMPARE(a.blockSize(), (Vector3i{4, 4, 1}));
         CORRADE_COMPARE(a.blockDataSize(), 8);
         CORRADE_COMPARE(a.size(), (Vector2i{12, 8}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 6*8);
     } {
         auto data = new char[8*16];
@@ -462,7 +462,7 @@ void ImageTest::constructCompressedGeneric() {
         CORRADE_COMPARE(a.blockSize(), (Vector3i{5, 5, 4}));
         CORRADE_COMPARE(a.blockDataSize(), 16);
         CORRADE_COMPARE(a.size(), (Vector2i{15, 10}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 8*16);
     }
 }
@@ -477,7 +477,7 @@ void ImageTest::constructCompressedGenericPlaceholder() {
         CORRADE_COMPARE(a.blockSize(), (Vector3i{}));
         CORRADE_COMPARE(a.blockDataSize(), 0);
         CORRADE_COMPARE(a.size(), Vector2i{});
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     } {
         CompressedImage2D a{
             CompressedPixelStorage{}
@@ -492,7 +492,7 @@ void ImageTest::constructCompressedGenericPlaceholder() {
         CORRADE_COMPARE(a.blockSize(), (Vector3i{}));
         CORRADE_COMPARE(a.blockDataSize(), 0);
         CORRADE_COMPARE(a.size(), Vector2i{});
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     }
 }
 
@@ -510,7 +510,7 @@ void ImageTest::constructCompressedImplementationSpecific() {
         CORRADE_COMPARE(a.blockSize(), (Vector3i{4, 4, 1}));
         CORRADE_COMPARE(a.blockDataSize(), 8);
         CORRADE_COMPARE(a.size(), (Vector2i{12, 8}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 6*8);
     } {
         auto data = new char[8*16];
@@ -525,7 +525,7 @@ void ImageTest::constructCompressedImplementationSpecific() {
         CORRADE_COMPARE(a.blockSize(), (Vector3i{5, 5, 4}));
         CORRADE_COMPARE(a.blockDataSize(), 16);
         CORRADE_COMPARE(a.size(), (Vector2i{15, 10}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 8*16);
     }
 
@@ -544,7 +544,7 @@ void ImageTest::constructCompressedImplementationSpecific() {
         CORRADE_COMPARE(a.blockSize(), (Vector3i{3, 4, 5}));
         CORRADE_COMPARE(a.blockDataSize(), 12);
         CORRADE_COMPARE(a.size(), (Vector2i{3, 8}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 6*12);
     }
 }
@@ -594,7 +594,7 @@ void ImageTest::constructInvalidSize() {
     Error redirectError{&out};
 
     /* Doesn't consider alignment */
-    Image2D{PixelFormat::RGB8Unorm, {1, 3}, Containers::Array<char>{3*3}};
+    Image2D{PixelFormat::RGB8Unorm, {1, 3}, Containers::Array<char>{NoInit, 3*3}};
     CORRADE_COMPARE(out, "Image: data too small, got 9 but expected at least 12 bytes\n");
 }
 
@@ -603,10 +603,10 @@ void ImageTest::constructInvalidCubeMap() {
 
     Containers::String out;
     Error redirectError{&out};
-    Image3D{PixelFormat::RGBA8Unorm, {3, 3, 5}, Containers::Array<char>{3*3*5*4}, ImageFlag3D::CubeMap};
-    Image3D{PixelFormat::RGBA8Unorm, {3, 4, 6}, Containers::Array<char>{3*4*6*4}, ImageFlag3D::CubeMap};
-    Image3D{PixelFormat::RGBA8Unorm, {3, 3, 17}, Containers::Array<char>{3*3*17*4}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
-    Image3D{PixelFormat::RGBA8Unorm, {4, 3, 18}, Containers::Array<char>{4*3*18*4}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
+    Image3D{PixelFormat::RGBA8Unorm, {3, 3, 5}, Containers::Array<char>{NoInit, 3*3*5*4}, ImageFlag3D::CubeMap};
+    Image3D{PixelFormat::RGBA8Unorm, {3, 4, 6}, Containers::Array<char>{NoInit, 3*4*6*4}, ImageFlag3D::CubeMap};
+    Image3D{PixelFormat::RGBA8Unorm, {3, 3, 17}, Containers::Array<char>{NoInit, 3*3*17*4}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
+    Image3D{PixelFormat::RGBA8Unorm, {4, 3, 18}, Containers::Array<char>{NoInit, 4*3*18*4}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
     CORRADE_COMPARE(out,
         "Image: expected exactly 6 faces for a cube map, got 5\n"
         "Image: expected square faces for a cube map, got {3, 4}\n"
@@ -677,14 +677,14 @@ void ImageTest::constructCompressedInvalidSize() {
     {
         Containers::String out;
         Error redirectError{&out};
-        CompressedImage2D{CompressedPixelFormat::Bc2RGBAUnorm, {4, 4}, Containers::Array<char>{15}};
+        CompressedImage2D{CompressedPixelFormat::Bc2RGBAUnorm, {4, 4}, Containers::Array<char>{NoInit, 15}};
         CORRADE_COMPARE(out, "CompressedImage: data too small, got 15 but expected at least 16 bytes\n");
 
     /* Size should be rounded up even if the image size is not full block */
     } {
         Containers::String out;
         Error redirectError{&out};
-        CompressedImage2D{CompressedPixelFormat::Bc2RGBAUnorm, {2, 2}, Containers::Array<char>{15}};
+        CompressedImage2D{CompressedPixelFormat::Bc2RGBAUnorm, {2, 2}, Containers::Array<char>{NoInit, 15}};
         CORRADE_COMPARE(out, "CompressedImage: data too small, got 15 but expected at least 16 bytes\n");
     }
 }
@@ -694,10 +694,10 @@ void ImageTest::constructCompressedInvalidCubeMap() {
 
     Containers::String out;
     Error redirectError{&out};
-    CompressedImage3D{CompressedPixelFormat::Bc1RGBAUnorm, {3, 3, 5}, Containers::Array<char>{8*5}, ImageFlag3D::CubeMap};
-    CompressedImage3D{CompressedPixelFormat::Bc1RGBAUnorm, {3, 4, 6}, Containers::Array<char>{8*6}, ImageFlag3D::CubeMap};
-    CompressedImage3D{CompressedPixelFormat::Bc1RGBAUnorm, {3, 3, 17}, Containers::Array<char>{8*17}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
-    CompressedImage3D{CompressedPixelFormat::Bc1RGBAUnorm, {4, 3, 18}, Containers::Array<char>{8*18}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
+    CompressedImage3D{CompressedPixelFormat::Bc1RGBAUnorm, {3, 3, 5}, Containers::Array<char>{NoInit, 8*5}, ImageFlag3D::CubeMap};
+    CompressedImage3D{CompressedPixelFormat::Bc1RGBAUnorm, {3, 4, 6}, Containers::Array<char>{NoInit, 8*6}, ImageFlag3D::CubeMap};
+    CompressedImage3D{CompressedPixelFormat::Bc1RGBAUnorm, {3, 3, 17}, Containers::Array<char>{NoInit, 8*17}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
+    CompressedImage3D{CompressedPixelFormat::Bc1RGBAUnorm, {4, 3, 18}, Containers::Array<char>{NoInit, 8*18}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
     CORRADE_COMPARE(out,
         "CompressedImage: expected exactly 6 faces for a cube map, got 5\n"
         "CompressedImage: expected square faces for a cube map, got {3, 4}\n"
@@ -721,7 +721,7 @@ void ImageTest::constructMoveGeneric() {
         PixelFormat::RGBA32F, {1, 3}, Containers::Array<char>{data, 3*16}, ImageFlag2D::Array};
     Image2D b(Utility::move(a));
 
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(a.size(), Vector2i{});
 
     CORRADE_COMPARE(b.flags(), ImageFlag2D::Array);
@@ -730,14 +730,14 @@ void ImageTest::constructMoveGeneric() {
     CORRADE_COMPARE(b.formatExtra(), 0);
     CORRADE_COMPARE(b.pixelSize(), 16);
     CORRADE_COMPARE(b.size(), (Vector2i{1, 3}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 3*16);
 
     auto data2 = new char[24];
     Image2D c{PixelFormat::R8I, {2, 6}, Containers::Array<char>{data2, 24}};
     c = Utility::move(b);
 
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data2));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data2));
     CORRADE_COMPARE(b.size(), (Vector2i{2, 6}));
 
     CORRADE_COMPARE(c.flags(), ImageFlag2D::Array);
@@ -746,7 +746,7 @@ void ImageTest::constructMoveGeneric() {
     CORRADE_COMPARE(c.formatExtra(), 0);
     CORRADE_COMPARE(c.pixelSize(), 16);
     CORRADE_COMPARE(c.size(), (Vector2i{1, 3}));
-    CORRADE_COMPARE(c.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(c.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(c.data().size(), 3*16);
 
     CORRADE_VERIFY(std::is_nothrow_move_constructible<Image2D>::value);
@@ -759,7 +759,7 @@ void ImageTest::constructMoveImplementationSpecific() {
         GL::PixelFormat::RGB, GL::PixelType::UnsignedShort, {1, 3}, Containers::Array<char>{data, 3*6}, ImageFlag2D::Array};
     Image2D b(Utility::move(a));
 
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(a.size(), Vector2i{});
 
     CORRADE_COMPARE(b.flags(), ImageFlag2D::Array);
@@ -768,7 +768,7 @@ void ImageTest::constructMoveImplementationSpecific() {
     CORRADE_COMPARE(b.formatExtra(), 1337);
     CORRADE_COMPARE(b.pixelSize(), 6);
     CORRADE_COMPARE(b.size(), (Vector2i{1, 3}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 3*6);
 
     auto data2 = new char[12*4*2];
@@ -776,7 +776,7 @@ void ImageTest::constructMoveImplementationSpecific() {
         1, 2, 8, {2, 6}, Containers::Array<char>{data2, 12*4*2}};
     c = Utility::move(b);
 
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data2));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data2));
     CORRADE_COMPARE(b.size(), Vector2i(2, 6));
 
     CORRADE_COMPARE(c.flags(), ImageFlag2D::Array);
@@ -785,7 +785,7 @@ void ImageTest::constructMoveImplementationSpecific() {
     CORRADE_COMPARE(c.formatExtra(), 1337);
     CORRADE_COMPARE(c.pixelSize(), 6);
     CORRADE_COMPARE(c.size(), (Vector2i{1, 3}));
-    CORRADE_COMPARE(c.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(c.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(c.data().size(), 3*6);
 }
 
@@ -797,7 +797,7 @@ void ImageTest::constructMoveCompressedGeneric() {
         Containers::Array<char>{data, 8*16}, ImageFlag2D::Array};
     CompressedImage2D b{Utility::move(a)};
 
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(a.size(), Vector2i{});
 
     CORRADE_COMPARE(b.flags(), ImageFlag2D::Array);
@@ -806,14 +806,14 @@ void ImageTest::constructMoveCompressedGeneric() {
     CORRADE_COMPARE(b.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(b.blockDataSize(), 16);
     CORRADE_COMPARE(b.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 8*16);
 
     auto data2 = new char[2*8];
     CompressedImage2D c{CompressedPixelFormat::Bc1RGBAUnorm, {8, 4}, Containers::Array<char>{data2, 2*8}};
     c = Utility::move(b);
 
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data2));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data2));
     CORRADE_COMPARE(b.size(), (Vector2i{8, 4}));
 
     CORRADE_COMPARE(c.flags(), ImageFlag2D::Array);
@@ -822,7 +822,7 @@ void ImageTest::constructMoveCompressedGeneric() {
     CORRADE_COMPARE(c.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(c.blockDataSize(), 16);
     CORRADE_COMPARE(c.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(c.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(c.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(c.data().size(), 8*16);
 
     CORRADE_VERIFY(std::is_nothrow_move_constructible<CompressedImage2D>::value);
@@ -837,7 +837,7 @@ void ImageTest::constructMoveCompressedImplementationSpecific() {
         Containers::Array<char>{data, 8*16}, ImageFlag2D::Array};
     CompressedImage2D b{Utility::move(a)};
 
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(a.size(), Vector2i{});
 
     CORRADE_COMPARE(b.flags(), ImageFlag2D::Array);
@@ -846,14 +846,14 @@ void ImageTest::constructMoveCompressedImplementationSpecific() {
     CORRADE_COMPARE(b.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(b.blockDataSize(), 16);
     CORRADE_COMPARE(b.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 8*16);
 
     auto data2 = new char[2*8];
     CompressedImage2D c{CompressedPixelFormat::Bc1RGBAUnorm, {8, 4}, Containers::Array<char>{data2, 2*8}};
     c = Utility::move(b);
 
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data2));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data2));
     CORRADE_COMPARE(b.size(), (Vector2i{8, 4}));
 
     CORRADE_COMPARE(c.flags(), ImageFlag2D::Array);
@@ -862,7 +862,7 @@ void ImageTest::constructMoveCompressedImplementationSpecific() {
     CORRADE_COMPARE(c.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(c.blockDataSize(), 16);
     CORRADE_COMPARE(c.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(c.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(c.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(c.data().size(), 8*16);
 }
 
@@ -880,7 +880,7 @@ template<class T> void ImageTest::toViewGeneric() {
     CORRADE_COMPARE(b.formatExtra(), 0);
     CORRADE_COMPARE(b.pixelSize(), 4);
     CORRADE_COMPARE(b.size(), (Vector2i{1, 3}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
 }
 
 template<class T> void ImageTest::toViewImplementationSpecific() {
@@ -897,7 +897,7 @@ template<class T> void ImageTest::toViewImplementationSpecific() {
     CORRADE_COMPARE(b.formatExtra(), 1337);
     CORRADE_COMPARE(b.pixelSize(), 6);
     CORRADE_COMPARE(b.size(), (Vector2i{1, 3}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
 }
 
 template<class T> void ImageTest::toViewCompressedGeneric() {
@@ -916,7 +916,7 @@ template<class T> void ImageTest::toViewCompressedGeneric() {
     CORRADE_COMPARE(b.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(b.blockDataSize(), 16);
     CORRADE_COMPARE(b.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 8*16);
 }
 
@@ -936,7 +936,7 @@ template<class T> void ImageTest::toViewCompressedImplementationSpecific() {
     CORRADE_COMPARE(b.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(b.blockDataSize(), 16);
     CORRADE_COMPARE(b.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 8*16);
 }
 
@@ -944,8 +944,8 @@ void ImageTest::data() {
     auto data = new char[4*4];
     Image2D a{PixelFormat::RGBA8Unorm, {1, 3}, Containers::Array<char>{data, 4*4}};
     const Image2D& ca = a;
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
-    CORRADE_COMPARE(ca.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(ca.data().data(), static_cast<const void*>(data));
 }
 
 void ImageTest::dataCompressed() {
@@ -954,8 +954,8 @@ void ImageTest::dataCompressed() {
         CompressedPixelFormat::Bc1RGBAUnorm, {12, 8},
         Containers::Array<char>{data, 6*8}, ImageFlag2D::Array};
     const CompressedImage2D& ca = a;
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
-    CORRADE_COMPARE(ca.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(ca.data().data(), static_cast<const void*>(data));
 }
 
 void ImageTest::dataRvalue() {
@@ -979,7 +979,7 @@ void ImageTest::dataProperties() {
             .setAlignment(8)
             .setSkip({3, 2, 1}),
         PixelFormat::R8Unorm, {2, 4, 6},
-        Containers::Array<char>{224}};
+        Containers::Array<char>{NoInit, 224}};
     CORRADE_COMPARE(image.dataProperties(),
         (std::pair<Math::Vector3<std::size_t>, Math::Vector3<std::size_t>>{{3, 16, 32}, {8, 4, 6}}));
 }
@@ -1002,7 +1002,7 @@ void ImageTest::release() {
     const char* const pointer = a.release().release();
 
     CORRADE_COMPARE(pointer, data);
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(a.size(), Vector2i());
 }
 
@@ -1014,7 +1014,7 @@ void ImageTest::releaseCompressed() {
     const char* const pointer = a.release().release();
 
     CORRADE_COMPARE(pointer, data);
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(a.size(), Vector2i());
 }
 
@@ -1033,14 +1033,14 @@ void ImageTest::pixels1D() {
         Containers::StridedArrayView1D<Color3ub> pixels = image.pixels<Color3ub>();
         CORRADE_COMPARE(pixels.size(), 2);
         CORRADE_COMPARE(pixels.stride(), 3);
-        CORRADE_COMPARE(pixels.data(), image.data() + 3*3);
+        CORRADE_COMPARE(pixels.data(), image.data().data() + 3*3);
         CORRADE_COMPARE(pixels[0], (Color3ub{3, 4, 5}));
         CORRADE_COMPARE(pixels[1], (Color3ub{6, 7, 8}));
     } {
         Containers::StridedArrayView1D<const Color3ub> pixels = cimage.pixels<Color3ub>();
         CORRADE_COMPARE(pixels.size(), 2);
         CORRADE_COMPARE(pixels.stride(), 3);
-        CORRADE_COMPARE(pixels.data(), cimage.data() + 3*3);
+        CORRADE_COMPARE(pixels.data(), cimage.data().data() + 3*3);
         CORRADE_COMPARE(pixels[0], (Color3ub{3, 4, 5}));
         CORRADE_COMPARE(pixels[1], (Color3ub{6, 7, 8}));
     }
@@ -1067,14 +1067,14 @@ void ImageTest::pixels2D() {
         Containers::StridedArrayView2D<Color3ub> pixels = image.pixels<Color3ub>();
         CORRADE_COMPARE(pixels.size(), (Containers::Size2D{4, 2}));
         CORRADE_COMPARE(pixels.stride(), (Containers::Stride2D{20, 3}));
-        CORRADE_COMPARE(pixels.data(), image.data() + 2*20 + 3*3);
+        CORRADE_COMPARE(pixels.data(), image.data().data() + 2*20 + 3*3);
         CORRADE_COMPARE(pixels[3][0], (Color3ub{4, 5, 6}));
         CORRADE_COMPARE(pixels[3][1], (Color3ub{7, 8, 9}));
     } {
         Containers::StridedArrayView2D<const Color3ub> pixels = cimage.pixels<Color3ub>();
         CORRADE_COMPARE(pixels.size(), (Containers::Size2D{4, 2}));
         CORRADE_COMPARE(pixels.stride(), (Containers::Stride2D{20, 3}));
-        CORRADE_COMPARE(pixels.data(), cimage.data() + 2*20 + 3*3);
+        CORRADE_COMPARE(pixels.data(), cimage.data().data() + 2*20 + 3*3);
         CORRADE_COMPARE(pixels[3][0], (Color3ub{4, 5, 6}));
         CORRADE_COMPARE(pixels[3][1], (Color3ub{7, 8, 9}));
     }
@@ -1127,14 +1127,14 @@ void ImageTest::pixels3D() {
         Containers::StridedArrayView3D<Color3ub> pixels = image.pixels<Color3ub>();
         CORRADE_COMPARE(pixels.size(), (Containers::Size3D{3, 4, 2}));
         CORRADE_COMPARE(pixels.stride(), (Containers::Stride3D{140, 20, 3}));
-        CORRADE_COMPARE(pixels.data(), image.data() + 140 + 2*20 + 3*3);
+        CORRADE_COMPARE(pixels.data(), image.data().data() + 140 + 2*20 + 3*3);
         CORRADE_COMPARE(pixels[1][3][0], (Color3ub{9, 8, 7}));
         CORRADE_COMPARE(pixels[1][3][1], (Color3ub{6, 5, 4}));
     } {
         Containers::StridedArrayView3D<const Color3ub> pixels = cimage.pixels<Color3ub>();
         CORRADE_COMPARE(pixels.size(), (Containers::Size3D{3, 4, 2}));
         CORRADE_COMPARE(pixels.stride(), (Containers::Stride3D{140, 20, 3}));
-        CORRADE_COMPARE(pixels.data(), cimage.data() + 140 + 2*20 + 3*3);
+        CORRADE_COMPARE(pixels.data(), cimage.data().data() + 140 + 2*20 + 3*3);
         CORRADE_COMPARE(pixels[1][3][0], (Color3ub{9, 8, 7}));
         CORRADE_COMPARE(pixels[1][3][1], (Color3ub{6, 5, 4}));
     }

src/Magnum/Test/ImageViewTest.cpp

@@ -231,7 +231,7 @@ template<class T> void ImageViewTest::constructGeneric() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 4);
         CORRADE_COMPARE(a.size(), (Vector2i{1, 3}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 4*4);
     } {
         T data[3*2]{};
@@ -244,7 +244,7 @@ template<class T> void ImageViewTest::constructGeneric() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 2);
         CORRADE_COMPARE(a.size(), (Vector2i{1, 3}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 3*2);
     }
 }
@@ -261,7 +261,7 @@ template<class T> void ImageViewTest::constructGenericEmpty() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 8);
         CORRADE_COMPARE(a.size(), (Vector2i{2, 6}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     } {
         ImageView<2, T> a{PixelStorage{}.setAlignment(1),
             PixelFormat::RGB16F, {8, 3}, ImageFlag2D::Array};
@@ -272,7 +272,7 @@ template<class T> void ImageViewTest::constructGenericEmpty() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 6);
         CORRADE_COMPARE(a.size(), (Vector2i{8, 3}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     }
 }
 
@@ -290,7 +290,7 @@ template<class T> void ImageViewTest::constructImplementationSpecific() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 12);
         CORRADE_COMPARE(a.size(), (Vector2i{1, 3}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 3*12);
     } {
         T data[3*12]{};
@@ -303,7 +303,7 @@ template<class T> void ImageViewTest::constructImplementationSpecific() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 12);
         CORRADE_COMPARE(a.size(), (Vector2i{1, 3}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 3*12);
     }
 
@@ -318,7 +318,7 @@ template<class T> void ImageViewTest::constructImplementationSpecific() {
         CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
         CORRADE_COMPARE(a.pixelSize(), 6);
         CORRADE_COMPARE(a.size(), Vector2i(1, 3));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 3*8);
     } {
         T data[3*6]{};
@@ -330,7 +330,7 @@ template<class T> void ImageViewTest::constructImplementationSpecific() {
         CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
         CORRADE_COMPARE(a.pixelSize(), 6);
         CORRADE_COMPARE(a.size(), Vector2i(1, 3));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 3*6);
     }
 
@@ -345,7 +345,7 @@ template<class T> void ImageViewTest::constructImplementationSpecific() {
         CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
         CORRADE_COMPARE(a.pixelSize(), 6);
         CORRADE_COMPARE(a.size(), Vector2i(1, 3));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 3*6);
     }
 }
@@ -363,7 +363,7 @@ template<class T> void ImageViewTest::constructImplementationSpecificEmpty() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 12);
         CORRADE_COMPARE(a.size(), (Vector2i{2, 16}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     } {
         ImageView<2, T> a{PixelStorage{}.setAlignment(1),
             Vk::PixelFormat::R32G32B32F, {1, 2}, ImageFlag2D::Array};
@@ -374,7 +374,7 @@ template<class T> void ImageViewTest::constructImplementationSpecificEmpty() {
         CORRADE_COMPARE(a.formatExtra(), 0);
         CORRADE_COMPARE(a.pixelSize(), 12);
         CORRADE_COMPARE(a.size(), (Vector2i{1, 2}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     }
 
     /* Format + extra */
@@ -387,7 +387,7 @@ template<class T> void ImageViewTest::constructImplementationSpecificEmpty() {
         CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
         CORRADE_COMPARE(a.pixelSize(), 6);
         CORRADE_COMPARE(a.size(), (Vector2i{1, 3}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     } {
         ImageView<2, T> a{PixelStorage{}.setAlignment(1),
             GL::PixelFormat::RGB, GL::PixelType::UnsignedShort, {8, 2}, ImageFlag2D::Array};
@@ -397,7 +397,7 @@ template<class T> void ImageViewTest::constructImplementationSpecificEmpty() {
         CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
         CORRADE_COMPARE(a.pixelSize(), 6);
         CORRADE_COMPARE(a.size(), (Vector2i{8, 2}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     }
 
     /* Manual pixel size */
@@ -410,7 +410,7 @@ template<class T> void ImageViewTest::constructImplementationSpecificEmpty() {
         CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
         CORRADE_COMPARE(a.pixelSize(), 6);
         CORRADE_COMPARE(a.size(), (Vector2i{3, 3}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     }
 }
 
@@ -429,7 +429,7 @@ template<class T> void ImageViewTest::constructCompressedGeneric() {
         CORRADE_COMPARE(a.blockSize(), (Vector3i{4, 4, 1}));
         CORRADE_COMPARE(a.blockDataSize(), 8);
         CORRADE_COMPARE(a.size(), (Vector2i{12, 8}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 6*8);
     } {
         T data[8*16]{};
@@ -444,7 +444,7 @@ template<class T> void ImageViewTest::constructCompressedGeneric() {
         CORRADE_COMPARE(a.blockSize(), (Vector3i{5, 5, 4}));
         CORRADE_COMPARE(a.blockDataSize(), 16);
         CORRADE_COMPARE(a.size(), (Vector2i{15, 10}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 8*16);
     }
 }
@@ -461,7 +461,7 @@ template<class T> void ImageViewTest::constructCompressedGenericEmpty() {
         CORRADE_COMPARE(a.blockSize(), (Vector3i{4, 4, 1}));
         CORRADE_COMPARE(a.blockDataSize(), 8);
         CORRADE_COMPARE(a.size(), (Vector2i{12, 8}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     } {
         CompressedImageView<2, T> a{
             CompressedPixelStorage{}.setRowLength(20),
@@ -474,7 +474,7 @@ template<class T> void ImageViewTest::constructCompressedGenericEmpty() {
         CORRADE_COMPARE(a.blockSize(), (Vector3i{5, 5, 4}));
         CORRADE_COMPARE(a.blockDataSize(), 16);
         CORRADE_COMPARE(a.size(), (Vector2i{15, 10}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     }
 }
 
@@ -494,7 +494,7 @@ template<class T> void ImageViewTest::constructCompressedImplementationSpecific(
         CORRADE_COMPARE(a.blockSize(), (Vector3i{4, 4, 1}));
         CORRADE_COMPARE(a.blockDataSize(), 8);
         CORRADE_COMPARE(a.size(), (Vector2i{12, 8}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 6*8);
     } {
         T data[8*16]{};
@@ -509,7 +509,7 @@ template<class T> void ImageViewTest::constructCompressedImplementationSpecific(
         CORRADE_COMPARE(a.blockSize(), (Vector3i{5, 5, 4}));
         CORRADE_COMPARE(a.blockDataSize(), 16);
         CORRADE_COMPARE(a.size(), (Vector2i{15, 10}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 8*16);
     }
 
@@ -528,7 +528,7 @@ template<class T> void ImageViewTest::constructCompressedImplementationSpecific(
         CORRADE_COMPARE(a.blockSize(), (Vector3i{3, 4, 5}));
         CORRADE_COMPARE(a.blockDataSize(), 12);
         CORRADE_COMPARE(a.size(), (Vector2i{3, 8}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
         CORRADE_COMPARE(a.data().size(), 6*12);
     }
 }
@@ -548,7 +548,7 @@ template<class T> void ImageViewTest::constructCompressedImplementationSpecificE
         CORRADE_COMPARE(a.blockSize(), (Vector3i{4, 4, 1}));
         CORRADE_COMPARE(a.blockDataSize(), 8);
         CORRADE_COMPARE(a.size(), (Vector2i{12, 8}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     } {
         CompressedImageView<2, T> a{
             CompressedPixelStorage{}.setRowLength(20),
@@ -560,7 +560,7 @@ template<class T> void ImageViewTest::constructCompressedImplementationSpecificE
         CORRADE_COMPARE(a.blockSize(), (Vector3i{5, 5, 4}));
         CORRADE_COMPARE(a.blockDataSize(), 16);
         CORRADE_COMPARE(a.size(), (Vector2i{15, 10}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     }
 
     /* Manual block properties */
@@ -577,7 +577,7 @@ template<class T> void ImageViewTest::constructCompressedImplementationSpecificE
         CORRADE_COMPARE(a.blockSize(), (Vector3i{3, 4, 5}));
         CORRADE_COMPARE(a.blockDataSize(), 12);
         CORRADE_COMPARE(a.size(), (Vector2i{3, 8}));
-        CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     }
 }
 
@@ -593,7 +593,7 @@ void ImageViewTest::construct3DFrom1D() {
     CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
     CORRADE_COMPARE(a.pixelSize(), 6);
     CORRADE_COMPARE(a.size(), 3);
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(a.data().size(), 3*6);
 
     /* Not testing the flags parameter here to be sure implicit conversion
@@ -605,7 +605,7 @@ void ImageViewTest::construct3DFrom1D() {
     CORRADE_COMPARE(b.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
     CORRADE_COMPARE(b.pixelSize(), 6);
     CORRADE_COMPARE(b.size(), (Vector3i{3, 1, 1}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 3*6);
 
     /* Conversion the other way is not allowed (will be later, but explicitly
@@ -627,7 +627,7 @@ void ImageViewTest::construct3DFrom2D() {
     CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
     CORRADE_COMPARE(a.pixelSize(), 6);
     CORRADE_COMPARE(a.size(), (Vector2i{1, 3}));
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(a.data().size(), 3*6);
 
     MutableImageView3D b = {a, ImageFlag3D(0x00a0)};
@@ -639,7 +639,7 @@ void ImageViewTest::construct3DFrom2D() {
     CORRADE_COMPARE(b.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
     CORRADE_COMPARE(b.pixelSize(), 6);
     CORRADE_COMPARE(b.size(), (Vector3i{1, 3, 1}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 3*6);
 
     /* Conversion the other way is not allowed (will be later, but explicitly
@@ -664,7 +664,7 @@ void ImageViewTest::constructCompressed3DFrom1D() {
     CORRADE_COMPARE(a.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(a.blockDataSize(), 16);
     CORRADE_COMPARE(a.size(), 15);
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(a.data().size(), 4*16);
 
     /* Not testing the flags parameter here to be sure implicit conversion
@@ -677,7 +677,7 @@ void ImageViewTest::constructCompressed3DFrom1D() {
     CORRADE_COMPARE(b.blockDataSize(), 16);
     /* The size doesn't get expanded */
     CORRADE_COMPARE(b.size(), (Vector3i{15, 1, 1}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 4*16);
 
     /* Conversion the other way is not allowed (will be later, but explicitly
@@ -703,7 +703,7 @@ void ImageViewTest::constructCompressed3DFrom2D() {
     CORRADE_COMPARE(a.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(a.blockDataSize(), 16);
     CORRADE_COMPARE(a.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(a.data().size(), 8*16);
 
     MutableCompressedImageView3D b = {a, ImageFlag3D(0x00a0)};
@@ -715,7 +715,7 @@ void ImageViewTest::constructCompressed3DFrom2D() {
     CORRADE_COMPARE(b.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(b.blockDataSize(), 16);
     CORRADE_COMPARE(b.size(), (Vector3i{15, 10, 1}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 8*16);
 
     /* Conversion the other way is not allowed (will be later, but explicitly
@@ -735,7 +735,7 @@ void ImageViewTest::constructFromMutable() {
     CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
     CORRADE_COMPARE(a.pixelSize(), 6);
     CORRADE_COMPARE(a.size(), Vector2i(1, 3));
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(a.data().size(), 3*6);
 
     ImageView2D b = a;
@@ -745,7 +745,7 @@ void ImageViewTest::constructFromMutable() {
     CORRADE_COMPARE(b.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort));
     CORRADE_COMPARE(b.pixelSize(), 6);
     CORRADE_COMPARE(b.size(), Vector2i(1, 3));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 3*6);
 }
 
@@ -764,7 +764,7 @@ void ImageViewTest::constructCompressedFromMutable() {
     CORRADE_COMPARE(a.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(a.blockDataSize(), 16);
     CORRADE_COMPARE(a.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(a.data().size(), 8*16);
 
     CompressedImageView2D b = a;
@@ -774,7 +774,7 @@ void ImageViewTest::constructCompressedFromMutable() {
     CORRADE_COMPARE(b.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(b.blockDataSize(), 16);
     CORRADE_COMPARE(b.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 8*16);
 }
 
@@ -1048,7 +1048,7 @@ template<class T> void ImageViewTest::setData() {
     CORRADE_COMPARE(a.storage().alignment(), 1);
     CORRADE_COMPARE(a.format(), PixelFormat::RGB8Snorm);
     CORRADE_COMPARE(a.size(), Vector2i(1, 3));
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(data2));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data2));
 }
 
 template<class T> void ImageViewTest::setDataCompressed() {
@@ -1064,7 +1064,7 @@ template<class T> void ImageViewTest::setDataCompressed() {
     CORRADE_COMPARE(a.storage().rowLength(), 8);
     CORRADE_COMPARE(a.format(), CompressedPixelFormat::Bc1RGBAUnorm);
     CORRADE_COMPARE(a.size(), Vector2i(4, 4));
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(data2));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data2));
 }
 
 void ImageViewTest::setDataInvalidSize() {
@@ -1121,7 +1121,7 @@ template<class T> void ImageViewTest::pixels1D() {
     CORRADE_COMPARE(std::is_const<typename decltype(pixels)::Type>::value, std::is_const<T>::value);
     CORRADE_COMPARE(pixels.size(), 2);
     CORRADE_COMPARE(pixels.stride(), 3);
-    CORRADE_COMPARE(pixels.data(), image.data() + 3*3);
+    CORRADE_COMPARE(pixels.data(), image.data().data() + 3*3);
 }
 
 template<class T> void ImageViewTest::pixels2D() {
@@ -1142,7 +1142,7 @@ template<class T> void ImageViewTest::pixels2D() {
     CORRADE_COMPARE(std::is_const<typename decltype(pixels)::Type>::value, std::is_const<T>::value);
     CORRADE_COMPARE(pixels.size(), (Containers::Size2D{4, 2}));
     CORRADE_COMPARE(pixels.stride(), (Containers::Stride2D{20, 3}));
-    CORRADE_COMPARE(pixels.data(), image.data() + 2*20 + 3*3);
+    CORRADE_COMPARE(pixels.data(), image.data().data() + 2*20 + 3*3);
 }
 
 template<class T> void ImageViewTest::pixels3D() {
@@ -1164,13 +1164,13 @@ template<class T> void ImageViewTest::pixels3D() {
     CORRADE_COMPARE(std::is_const<typename decltype(pixels)::Type>::value, std::is_const<T>::value);
     CORRADE_COMPARE(pixels.size(), (Containers::Size3D{3, 4, 2}));
     CORRADE_COMPARE(pixels.stride(), (Containers::Stride3D{140, 20, 3}));
-    CORRADE_COMPARE(pixels.data(), image.data() + 140 + 2*20 + 3*3);
+    CORRADE_COMPARE(pixels.data(), image.data().data() + 140 + 2*20 + 3*3);
 }
 
 void ImageViewTest::pixelsNullptr() {
     ImageView3D image{PixelFormat::RGB8Unorm, {2, 4, 3}};
 
-    CORRADE_COMPARE(image.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(image.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(image.data().size(), 0);
 
     CORRADE_COMPARE(image.pixels().data(), nullptr);

src/Magnum/Text/Test/RendererTest.cpp

@@ -4960,12 +4960,12 @@ void RendererTest::allocateIndexAllocator() {
         CORRADE_COMPARE(renderer.renderingRunCount(), 1);
         /* No need to verify the actual contents, just that the view didn't
            change since last time */
-        CORRADE_COMPARE(renderer.indices().data(), indices);
+        CORRADE_COMPARE(renderer.indices().data(), indices.data());
     }
 
     /* Reserve / render / set index type second time. Pass with a size that's
        not a multiple of 6 times type size, it should round that down. */
-    allocation.expectedData = indices;
+    allocation.expectedData = indices.data();
     /* Using a heap allocation to not go over limited stack sizes on
        Emscripten etc */
     Containers::Array<char> indices2{NoInit, 20000*6*4};
@@ -5016,10 +5016,10 @@ void RendererTest::allocateIndexAllocator() {
        to perform the data copy, the one in this test deliberately doesn't. */
     if(data.expectNoReallocation) {
         CORRADE_COMPARE(allocation.called, 1);
-        CORRADE_COMPARE(renderer.indices().data(), indices);
+        CORRADE_COMPARE(renderer.indices().data(), indices.data());
     } else {
         CORRADE_COMPARE(allocation.called, 2);
-        CORRADE_COMPARE(renderer.indices().data(), indices2);
+        CORRADE_COMPARE(renderer.indices().data(), indices2.data());
     }
 }
 

src/Magnum/Trade/AbstractImporter.cpp

@@ -628,7 +628,7 @@ void AbstractImporter::populateCachedScenes() {
         return;
 
     _cachedScenes.emplace();
-    _cachedScenes->scenes = Containers::Array<Containers::Optional<SceneData>>{sceneCount()};
+    _cachedScenes->scenes = Containers::Array<Containers::Optional<SceneData>>{ValueInit, sceneCount()};
 
     UnsignedLong newObjectOffset = objectCount();
     for(UnsignedInt i = 0; i != _cachedScenes->scenes.size(); ++i) {
@@ -813,7 +813,7 @@ Containers::Pointer<ObjectData2D> AbstractImporter::doObject2D(const UnsignedInt
             new MeshObjectData2D{Utility::move(children),
                 *transformation,
                 mesh.front().first(), mesh.front().second(),
-                skin ? Int(*skin) : -1,
+                skin.isEmpty() ? -1  : Int(skin.front()),
                 importerState ? *importerState : nullptr});
     }
 
@@ -821,7 +821,7 @@ Containers::Pointer<ObjectData2D> AbstractImporter::doObject2D(const UnsignedInt
     UnsignedInt instance;
     if(camera) {
         instanceType = ObjectInstanceType2D::Camera;
-        instance = *camera;
+        instance = camera.front();
     } else {
         instanceType = ObjectInstanceType2D::Empty;
         instance = UnsignedInt(-1); /* Old APIs, you suck! */
@@ -993,7 +993,7 @@ Containers::Pointer<ObjectData3D> AbstractImporter::doObject3D(const UnsignedInt
             new MeshObjectData3D{Utility::move(children),
                 *transformation,
                 mesh.front().first(), mesh.front().second(),
-                skin ? Int(*skin) : -1,
+                skin.isEmpty() ? -1  : Int(skin.front()),
                 importerState ? *importerState : nullptr});
     }
 
@@ -1001,10 +1001,10 @@ Containers::Pointer<ObjectData3D> AbstractImporter::doObject3D(const UnsignedInt
     UnsignedInt instance;
     if(camera) {
         instanceType = ObjectInstanceType3D::Camera;
-        instance = *camera;
+        instance = camera.front();
     } else if(light) {
         instanceType = ObjectInstanceType3D::Light;
-        instance = *light;
+        instance = light.front();
     } else {
         instanceType = ObjectInstanceType3D::Empty;
         instance = UnsignedInt(-1); /* Old APIs, you suck! */

src/Magnum/Trade/Implementation/arrayUtilities.h

@@ -38,7 +38,7 @@ namespace Magnum { namespace Trade { namespace Implementation {
 /** @todo isn't there some C++56 feature that would allow me to allocate
     without calling constructors? */
 template<class T> Containers::Array<T> initializerListToArrayWithDefaultDeleter(const std::initializer_list<T> list) {
-    Containers::Array<T> out{list.size()};
+    Containers::Array<T> out{ValueInit, list.size()};
     /* FFS why initializer list doesn't have an operator[] */
     std::size_t i = 0;
     for(auto&& item: list)

src/Magnum/Trade/MaterialData.cpp

@@ -300,7 +300,7 @@ MaterialData::MaterialData(const MaterialTypes types, Containers::Array<Material
             if(_data[j - 1].name() < _data[j].name())
                 continue;
 
-            std::sort(_data + begin, _data + end, [
+            std::sort(_data.data() + begin, _data.data() + end, [
                 #ifndef CORRADE_NO_ASSERT
                 i
                 #endif

src/Magnum/Trade/MeshData.cpp

@@ -1014,7 +1014,7 @@ Containers::Array<UnsignedInt> MeshData::jointIdsAsArray(const UnsignedInt id) c
     CORRADE_ASSERT(attributeId != ~UnsignedInt{},
         "Trade::MeshData::jointIdsAsArray(): index" << id << "out of range for" << attributeCount(MeshAttribute::JointIds) << "joint ID attributes", {});
     const MeshAttributeData& attribute = _attributes[attributeId];
-    Containers::Array<UnsignedInt> out{_vertexCount*attribute._arraySize};
+    Containers::Array<UnsignedInt> out{NoInit, _vertexCount*attribute._arraySize};
     jointIdsInto(Containers::StridedArrayView2D<UnsignedInt>{out, {_vertexCount, attribute._arraySize}}, id);
     return out;
 }
@@ -1052,7 +1052,7 @@ Containers::Array<Float> MeshData::weightsAsArray(const UnsignedInt id) const {
     const UnsignedInt attributeId = findAttributeIdInternal(MeshAttribute::Weights, id, -1);
     CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::weightsAsArray(): index" << id << "out of range for" << attributeCount(MeshAttribute::JointIds) << "weight attributes", {});
     const MeshAttributeData& attribute = _attributes[attributeId];
-    Containers::Array<Float> out{_vertexCount*attribute._arraySize};
+    Containers::Array<Float> out{NoInit, _vertexCount*attribute._arraySize};
     weightsInto(Containers::StridedArrayView2D<Float>{out, {_vertexCount, attribute._arraySize}}, id);
     return out;
 }

src/Magnum/Trade/SceneData.cpp

@@ -736,7 +736,7 @@ Containers::StridedBitArrayView2D SceneFieldData::fieldBitData(const Containers:
     CORRADE_ASSERT(fieldType() == SceneFieldType::Bit,
         "Trade::SceneFieldData::fieldBitData(): the field is" << fieldType() << Debug::nospace << ", not a bit", {});
     return Containers::StridedBitArrayView2D{
-        {data, 0, data.size()*8},
+        {data.data(), 0, data.size()*8},
         _flags & SceneFieldFlag::OffsetOnly ? static_cast<const char*>(data.data()) + _fieldData.offset : _fieldData.pointer, _field.data.bitOffset,
         {std::size_t(_size), _field.data.arraySize ? _field.data.arraySize : 1},
         {_field.data.stride, 1}};
@@ -1060,7 +1060,7 @@ SceneData::SceneData(std::vector<UnsignedInt> children2D, std::vector<UnsignedIn
     /* Can't use InPlaceInit as that creates an Array with a non-default
        deleter, which then trips up on an assertion when such an instance gets
        returned from AbstractImporter */
-    _fields = Containers::Array<SceneFieldData>{1};
+    _fields = Containers::Array<SceneFieldData>{ValueInit, 1};
     _fields[0] = SceneFieldData{SceneField::Parent, mapping, parents};
     Utility::copy(children, mapping);
     constexpr Int parent[]{-1};

src/Magnum/Trade/Test/AbstractImageConverterTest.cpp

@@ -967,7 +967,7 @@ void AbstractImageConverterTest::convert1D() {
     struct: AbstractImageConverter {
         ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert1D; }
         Containers::Optional<ImageData1D> doConvert(const ImageView1D& image) override {
-            return ImageData1D{PixelFormat::RGBA8Unorm, image.size(), Containers::Array<char>{16}};
+            return ImageData1D{PixelFormat::RGBA8Unorm, image.size(), Containers::Array<char>{NoInit, 16}};
         }
     } converter;
 
@@ -982,7 +982,7 @@ void AbstractImageConverterTest::convert2D() {
     struct: AbstractImageConverter {
         ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert2D; }
         Containers::Optional<ImageData2D> doConvert(const ImageView2D& image) override {
-            return ImageData2D{PixelFormat::RGBA8Unorm, image.size(), Containers::Array<char>{96}};
+            return ImageData2D{PixelFormat::RGBA8Unorm, image.size(), Containers::Array<char>{NoInit, 96}};
         }
     } converter;
 
@@ -1000,7 +1000,7 @@ void AbstractImageConverterTest::convert2DDeprecated() {
     struct: AbstractImageConverter {
         ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert2D; }
         Containers::Optional<ImageData2D> doConvert(const ImageView2D& image) override {
-            return ImageData2D{PixelFormat::RGBA8Unorm, image.size(), Containers::Array<char>{96}};
+            return ImageData2D{PixelFormat::RGBA8Unorm, image.size(), Containers::Array<char>{NoInit, 96}};
         }
     } converter;
 
@@ -1016,7 +1016,7 @@ void AbstractImageConverterTest::convert2DDeprecatedInvalid() {
     struct: AbstractImageConverter {
         ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert2D; }
         Containers::Optional<ImageData2D> doConvert(const ImageView2D& image) override {
-            return ImageData2D{CompressedPixelFormat::Bc1RGBAUnorm, image.size(), Containers::Array<char>{96}};
+            return ImageData2D{CompressedPixelFormat::Bc1RGBAUnorm, image.size(), Containers::Array<char>{NoInit, 96}};
         }
     } converter;
 
@@ -1034,7 +1034,7 @@ void AbstractImageConverterTest::convert2DDeprecatedCompressed() {
     struct: AbstractImageConverter {
         ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert2D; }
         Containers::Optional<ImageData2D> doConvert(const ImageView2D& image) override {
-            return ImageData2D{CompressedPixelFormat::Bc1RGBAUnorm, image.size(), Containers::Array<char>{96}};
+            return ImageData2D{CompressedPixelFormat::Bc1RGBAUnorm, image.size(), Containers::Array<char>{NoInit, 96}};
         }
     } converter;
 
@@ -1050,7 +1050,7 @@ void AbstractImageConverterTest::convert2DDeprecatedCompressedInvalid() {
     struct: AbstractImageConverter {
         ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert2D; }
         Containers::Optional<ImageData2D> doConvert(const ImageView2D& image) override {
-            return ImageData2D{PixelFormat::RGBA8Unorm, image.size(), Containers::Array<char>{96}};
+            return ImageData2D{PixelFormat::RGBA8Unorm, image.size(), Containers::Array<char>{NoInit, 96}};
         }
     } converter;
 
@@ -1067,7 +1067,7 @@ void AbstractImageConverterTest::convert3D() {
     struct: AbstractImageConverter {
         ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert3D; }
         Containers::Optional<ImageData3D> doConvert(const ImageView3D& image) override {
-            return ImageData3D{PixelFormat::RGBA8Unorm, image.size(), Containers::Array<char>{96}};
+            return ImageData3D{PixelFormat::RGBA8Unorm, image.size(), Containers::Array<char>{NoInit, 96}};
         }
     } converter;
 
@@ -1260,7 +1260,7 @@ void AbstractImageConverterTest::convertCompressed1D() {
     struct: AbstractImageConverter {
         ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::ConvertCompressed1D; }
         Containers::Optional<ImageData1D> doConvert(const CompressedImageView1D& image) override {
-            return ImageData1D{image.format(), image.size(), Containers::Array<char>{64}};
+            return ImageData1D{image.format(), image.size(), Containers::Array<char>{NoInit, 64}};
         }
     } converter;
 
@@ -1275,7 +1275,7 @@ void AbstractImageConverterTest::convertCompressed2D() {
     struct: AbstractImageConverter {
         ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::ConvertCompressed2D; }
         Containers::Optional<ImageData2D> doConvert(const CompressedImageView2D& image) override {
-            return ImageData2D{image.format(), image.size(), Containers::Array<char>{64}};
+            return ImageData2D{image.format(), image.size(), Containers::Array<char>{NoInit, 64}};
         }
     } converter;
 
@@ -1290,7 +1290,7 @@ void AbstractImageConverterTest::convertCompressed3D() {
     struct: AbstractImageConverter {
         ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::ConvertCompressed3D; }
         Containers::Optional<ImageData3D> doConvert(const CompressedImageView3D& image) override {
-            return ImageData3D{image.format(), image.size(), Containers::Array<char>{64}};
+            return ImageData3D{image.format(), image.size(), Containers::Array<char>{NoInit, 64}};
         }
     } converter;
 
@@ -2273,7 +2273,7 @@ void AbstractImageConverterTest::convertImageData1DToData() {
 
     /* Should get "B" when converting uncompressed */
     {
-        Containers::Optional<Containers::Array<char>> out = converter.convertToData(ImageData1D{PixelFormat::RGBA8Unorm, 1, Containers::Array<char>{4}});
+        Containers::Optional<Containers::Array<char>> out = converter.convertToData(ImageData1D{PixelFormat::RGBA8Unorm, 1, Containers::Array<char>{NoInit, 4}});
         CORRADE_VERIFY(out);
         CORRADE_COMPARE_AS(*out,
             Containers::arrayView({'B'}),
@@ -2282,7 +2282,7 @@ void AbstractImageConverterTest::convertImageData1DToData() {
 
     /* Should get "C" when converting compressed */
     {
-        Containers::Optional<Containers::Array<char>> out = converter.convertToData(ImageData1D{CompressedPixelFormat::Bc1RGBUnorm, 4, Containers::Array<char>{8}});
+        Containers::Optional<Containers::Array<char>> out = converter.convertToData(ImageData1D{CompressedPixelFormat::Bc1RGBUnorm, 4, Containers::Array<char>{NoInit, 8}});
         CORRADE_VERIFY(out);
         CORRADE_COMPARE_AS(*out,
             Containers::arrayView({'C'}),
@@ -2295,7 +2295,7 @@ void AbstractImageConverterTest::convertImageData2DToData() {
 
     /* Should get "B" when converting uncompressed */
     {
-        Containers::Optional<Containers::Array<char>> out = converter.convertToData(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, Containers::Array<char>{4}});
+        Containers::Optional<Containers::Array<char>> out = converter.convertToData(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, Containers::Array<char>{NoInit, 4}});
         CORRADE_VERIFY(out);
         CORRADE_COMPARE_AS(*out,
             Containers::arrayView({'B'}),
@@ -2321,7 +2321,7 @@ void AbstractImageConverterTest::convertImageData2DToDataDeprecated() {
     /* Should get "B" when converting uncompressed */
     {
         CORRADE_IGNORE_DEPRECATED_PUSH
-        Containers::Array<char> out = converter.exportToData(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, Containers::Array<char>{4}});
+        Containers::Array<char> out = converter.exportToData(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, Containers::Array<char>{NoInit, 4}});
         CORRADE_IGNORE_DEPRECATED_POP
         CORRADE_VERIFY(out);
         CORRADE_COMPARE_AS(out,
@@ -2347,7 +2347,7 @@ void AbstractImageConverterTest::convertImageData3DToData() {
 
     /* Should get "B" when converting uncompressed */
     {
-        Containers::Optional<Containers::Array<char>> out = converter.convertToData(ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, Containers::Array<char>{4}});
+        Containers::Optional<Containers::Array<char>> out = converter.convertToData(ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, Containers::Array<char>{NoInit, 4}});
         CORRADE_VERIFY(out);
         CORRADE_COMPARE_AS(*out,
             Containers::arrayView({'B'}),
@@ -3530,7 +3530,7 @@ void AbstractImageConverterTest::convert1DToFile() {
     if(Utility::Path::exists(filename))
         CORRADE_VERIFY(Utility::Path::remove(filename));
 
-    CORRADE_VERIFY(converter.convertToFile(ImageView1D{PixelFormat::RGBA8Unorm, 0x0f, Containers::Array<char>{0x0f*4}}, filename));
+    CORRADE_VERIFY(converter.convertToFile(ImageView1D{PixelFormat::RGBA8Unorm, 0x0f, Containers::Array<char>{NoInit, 0x0f*4}}, filename));
     CORRADE_COMPARE_AS(filename,
         "\x0f", TestSuite::Compare::FileToString);
 }
@@ -3549,7 +3549,7 @@ void AbstractImageConverterTest::convert2DToFile() {
     if(Utility::Path::exists(filename))
         CORRADE_VERIFY(Utility::Path::remove(filename));
 
-    CORRADE_VERIFY(converter.convertToFile(ImageView2D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d}, Containers::Array<char>{0x0f*0x0d*4}}, filename));
+    CORRADE_VERIFY(converter.convertToFile(ImageView2D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d}, Containers::Array<char>{NoInit, 0x0f*0x0d*4}}, filename));
     CORRADE_COMPARE_AS(filename,
         "\x0f\x0d", TestSuite::Compare::FileToString);
 }
@@ -3572,7 +3572,7 @@ void AbstractImageConverterTest::convert2DToFileDeprecated() {
         CORRADE_VERIFY(Utility::Path::remove(filename));
 
     CORRADE_IGNORE_DEPRECATED_PUSH
-    CORRADE_VERIFY(converter.exportToFile(ImageView2D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d}, Containers::Array<char>{0x0f*0x0d*4}}, filename));
+    CORRADE_VERIFY(converter.exportToFile(ImageView2D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d}, Containers::Array<char>{NoInit, 0x0f*0x0d*4}}, filename));
     CORRADE_IGNORE_DEPRECATED_POP
     CORRADE_COMPARE_AS(filename,
         "\x0f\x0d", TestSuite::Compare::FileToString);
@@ -3593,7 +3593,7 @@ void AbstractImageConverterTest::convert3DToFile() {
     if(Utility::Path::exists(filename))
         CORRADE_VERIFY(Utility::Path::remove(filename));
 
-    CORRADE_VERIFY(converter.convertToFile(ImageView3D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d, 0x02}, Containers::Array<char>{0x0f*0x0d*0x02*4}}, filename));
+    CORRADE_VERIFY(converter.convertToFile(ImageView3D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d, 0x02}, Containers::Array<char>{NoInit, 0x0f*0x0d*0x02*4}}, filename));
     CORRADE_COMPARE_AS(filename,
         "\x0f\x0d\x02", TestSuite::Compare::FileToString);
 }
@@ -3711,7 +3711,7 @@ void AbstractImageConverterTest::convert1DToFileThroughData() {
         CORRADE_VERIFY(Utility::Path::remove(filename));
 
     /* doConvertToFile() should call doConvertToData() */
-    CORRADE_VERIFY(converter.convertToFile(ImageView1D(PixelFormat::RGBA8Unorm, 0x0f, Containers::Array<char>{0x0f*4}), filename));
+    CORRADE_VERIFY(converter.convertToFile(ImageView1D(PixelFormat::RGBA8Unorm, 0x0f, Containers::Array<char>{NoInit, 0x0f*4}), filename));
     CORRADE_COMPARE_AS(filename,
         "\x0f", TestSuite::Compare::FileToString);
 }
@@ -3731,7 +3731,7 @@ void AbstractImageConverterTest::convert2DToFileThroughData() {
         CORRADE_VERIFY(Utility::Path::remove(filename));
 
     /* doConvertToFile() should call doConvertToData() */
-    CORRADE_VERIFY(converter.convertToFile(ImageView2D(PixelFormat::RGBA8Unorm, {0x0f, 0x0d}, Containers::Array<char>{0x0f*0x0d*4}), filename));
+    CORRADE_VERIFY(converter.convertToFile(ImageView2D(PixelFormat::RGBA8Unorm, {0x0f, 0x0d}, Containers::Array<char>{NoInit, 0x0f*0x0d*4}), filename));
     CORRADE_COMPARE_AS(filename,
         "\x0f\x0d", TestSuite::Compare::FileToString);
 }
@@ -3751,7 +3751,7 @@ void AbstractImageConverterTest::convert3DToFileThroughData() {
         CORRADE_VERIFY(Utility::Path::remove(filename));
 
     /* doConvertToFile() should call doConvertToData() */
-    CORRADE_VERIFY(converter.convertToFile(ImageView3D(PixelFormat::RGBA8Unorm, {0x0f, 0x0d, 0x02}, Containers::Array<char>{0x0f*0x0d*0x02*4}), filename));
+    CORRADE_VERIFY(converter.convertToFile(ImageView3D(PixelFormat::RGBA8Unorm, {0x0f, 0x0d, 0x02}, Containers::Array<char>{NoInit, 0x0f*0x0d*0x02*4}), filename));
     CORRADE_COMPARE_AS(filename,
         "\x0f\x0d\x02", TestSuite::Compare::FileToString);
 }
@@ -3992,7 +3992,7 @@ void AbstractImageConverterTest::convertCompressed1DToFile() {
     if(Utility::Path::exists(filename))
         CORRADE_VERIFY(Utility::Path::remove(filename));
 
-    CORRADE_VERIFY(converter.convertToFile(CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 0x0f, Containers::Array<char>{64}}, filename));
+    CORRADE_VERIFY(converter.convertToFile(CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 0x0f, Containers::Array<char>{NoInit, 64}}, filename));
     CORRADE_COMPARE_AS(filename,
         "\x0f", TestSuite::Compare::FileToString);
 }
@@ -4174,7 +4174,7 @@ void AbstractImageConverterTest::convertCompressed1DToFileThroughData() {
         CORRADE_VERIFY(Utility::Path::remove(filename));
 
     /* doConvertToFile() should call doConvertToData() */
-    CORRADE_VERIFY(converter.convertToFile(CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 0x0f, Containers::Array<char>{64}}, filename));
+    CORRADE_VERIFY(converter.convertToFile(CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 0x0f, Containers::Array<char>{NoInit, 64}}, filename));
     CORRADE_COMPARE_AS(filename,
         "\x0f", TestSuite::Compare::FileToString);
 }
@@ -4445,7 +4445,7 @@ void AbstractImageConverterTest::convertImageData1DToFile() {
     ImageData1DConverter converter;
 
     /* Should get "B" when converting uncompressed */
-    CORRADE_VERIFY(converter.convertToFile(ImageData1D{PixelFormat::RGBA16F, 1, Containers::Array<char>{8}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
+    CORRADE_VERIFY(converter.convertToFile(ImageData1D{PixelFormat::RGBA16F, 1, Containers::Array<char>{NoInit, 8}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
     CORRADE_COMPARE_AS(Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out"),
         "B", TestSuite::Compare::FileToString);
 
@@ -4459,7 +4459,7 @@ void AbstractImageConverterTest::convertImageData2DToFile() {
     ImageData2DConverter converter;
 
     /* Should get "B" when converting uncompressed */
-    CORRADE_VERIFY(converter.convertToFile(ImageData2D{PixelFormat::RGBA16F, {1, 1}, Containers::Array<char>{8}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
+    CORRADE_VERIFY(converter.convertToFile(ImageData2D{PixelFormat::RGBA16F, {1, 1}, Containers::Array<char>{NoInit, 8}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
     CORRADE_COMPARE_AS(Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out"),
         "B", TestSuite::Compare::FileToString);
 
@@ -4477,7 +4477,7 @@ void AbstractImageConverterTest::convertImageData2DToFileDeprecated() {
 
     /* Should get "B" when converting uncompressed */
     CORRADE_IGNORE_DEPRECATED_PUSH
-    CORRADE_VERIFY(converter.exportToFile(ImageData2D{PixelFormat::RGBA16F, {1, 1}, Containers::Array<char>{8}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
+    CORRADE_VERIFY(converter.exportToFile(ImageData2D{PixelFormat::RGBA16F, {1, 1}, Containers::Array<char>{NoInit, 8}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
     CORRADE_IGNORE_DEPRECATED_POP
     CORRADE_COMPARE_AS(Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out"),
         "B", TestSuite::Compare::FileToString);
@@ -4495,7 +4495,7 @@ void AbstractImageConverterTest::convertImageData3DToFile() {
     ImageData3DConverter converter;
 
     /* Should get "B" when converting uncompressed */
-    CORRADE_VERIFY(converter.convertToFile(ImageData3D{PixelFormat::RGBA16F, {1, 1, 1}, Containers::Array<char>{8}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
+    CORRADE_VERIFY(converter.convertToFile(ImageData3D{PixelFormat::RGBA16F, {1, 1, 1}, Containers::Array<char>{NoInit, 8}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
     CORRADE_COMPARE_AS(Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out"),
         "B", TestSuite::Compare::FileToString);
 
@@ -4652,7 +4652,7 @@ void AbstractImageConverterTest::convertLevels1DToFile() {
     const char data[4]{};
     CORRADE_VERIFY(converter.convertToFile({
         /* Arbitrary dimensions should be fine */
-        ImageView1D{PixelFormat::RGBA8Unorm, 0x0f, Containers::Array<char>{0x0f*4}},
+        ImageView1D{PixelFormat::RGBA8Unorm, 0x0f, Containers::Array<char>{NoInit, 0x0f*4}},
         ImageView1D{PixelFormat::RGBA8Unorm, 1, data}
     }, filename));
     CORRADE_COMPARE_AS(filename,
@@ -4679,7 +4679,7 @@ void AbstractImageConverterTest::convertLevels2DToFile() {
     const char data[4]{};
     CORRADE_VERIFY(converter.convertToFile({
         /* Arbitrary dimensions should be fine */
-        ImageView2D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d}, Containers::Array<char>{0x0f*0x0d*4}},
+        ImageView2D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d}, Containers::Array<char>{NoInit, 0x0f*0x0d*4}},
         ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, data}
     }, filename));
     CORRADE_COMPARE_AS(filename,
@@ -4706,7 +4706,7 @@ void AbstractImageConverterTest::convertLevels3DToFile() {
     const char data[4]{};
     CORRADE_VERIFY(converter.convertToFile({
         /* Arbitrary dimensions should be fine */
-        ImageView3D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d, 0x0e}, Containers::Array<char>{0x0f*0x0d*0x0e*4}},
+        ImageView3D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d, 0x0e}, Containers::Array<char>{NoInit, 0x0f*0x0d*0x0e*4}},
         ImageView3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, data}
     }, filename));
     CORRADE_COMPARE_AS(filename,
@@ -4807,7 +4807,7 @@ void AbstractImageConverterTest::convertLevels1DToFileThroughData() {
     /* doConvertToFile() should call doConvertToData() */
     CORRADE_VERIFY(converter.convertToFile({
         /* Arbitrary dimensions should be fine */
-        ImageView1D{PixelFormat::RGBA8Unorm, 0x0f, Containers::Array<char>{0x0f*4}},
+        ImageView1D{PixelFormat::RGBA8Unorm, 0x0f, Containers::Array<char>{NoInit, 0x0f*4}},
         ImageView1D{PixelFormat::RGBA8Unorm, 1, data}
     }, filename));
     CORRADE_COMPARE_AS(filename,
@@ -4835,7 +4835,7 @@ void AbstractImageConverterTest::convertLevels2DToFileThroughData() {
 
     /* doConvertToFile() should call doConvertToData() */
     CORRADE_VERIFY(converter.convertToFile({
-        ImageView2D(PixelFormat::RGBA8Unorm, {0x0f, 0x0d}, Containers::Array<char>{0x0f*0x0d*4}),
+        ImageView2D(PixelFormat::RGBA8Unorm, {0x0f, 0x0d}, Containers::Array<char>{NoInit, 0x0f*0x0d*4}),
         ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, data}
     }, filename));
     CORRADE_COMPARE_AS(filename,
@@ -4863,7 +4863,7 @@ void AbstractImageConverterTest::convertLevels3DToFileThroughData() {
 
     /* doConvertToFile() should call doConvertToData() */
     CORRADE_VERIFY(converter.convertToFile({
-        ImageView3D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d, 0x0e}, Containers::Array<char>{0x0f*0x0d*0x0e*4}},
+        ImageView3D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d, 0x0e}, Containers::Array<char>{NoInit, 0x0f*0x0d*0x0e*4}},
         ImageView3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, data}
     }, filename));
     CORRADE_COMPARE_AS(filename,
@@ -5146,7 +5146,7 @@ void AbstractImageConverterTest::convertCompressedLevels1DToFile() {
 
     const char data[8]{};
     CORRADE_VERIFY(converter.convertToFile({
-        CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 0x0f, Containers::Array<char>{64}},
+        CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 0x0f, Containers::Array<char>{NoInit, 64}},
         CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 4, data}
     }, filename));
     CORRADE_COMPARE_AS(filename,
@@ -5298,7 +5298,7 @@ void AbstractImageConverterTest::convertCompressedLevels1DToFileThroughData() {
 
     /* doConvertToFile() should call doConvertToData() */
     CORRADE_VERIFY(converter.convertToFile({
-        CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 0x0f, Containers::Array<char>{64}},
+        CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 0x0f, Containers::Array<char>{NoInit, 64}},
         CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 4, data}
     }, filename));
     CORRADE_COMPARE_AS(filename,
@@ -5636,7 +5636,7 @@ void AbstractImageConverterTest::convert1DToFileThroughLevels() {
     if(Utility::Path::exists(filename))
         CORRADE_VERIFY(Utility::Path::remove(filename));
 
-    CORRADE_VERIFY(converter.convertToFile(ImageView1D{PixelFormat::RGBA8Unorm, 0x0f, Containers::Array<char>{0x0f*4}}, filename));
+    CORRADE_VERIFY(converter.convertToFile(ImageView1D{PixelFormat::RGBA8Unorm, 0x0f, Containers::Array<char>{NoInit, 0x0f*4}}, filename));
     CORRADE_COMPARE_AS(filename,
         "\x0f\x01", TestSuite::Compare::FileToString);
 }
@@ -5658,7 +5658,7 @@ void AbstractImageConverterTest::convert2DToFileThroughLevels() {
     if(Utility::Path::exists(filename))
         CORRADE_VERIFY(Utility::Path::remove(filename));
 
-    CORRADE_VERIFY(converter.convertToFile(ImageView2D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d}, Containers::Array<char>{0x0f*0x0d*4}}, filename));
+    CORRADE_VERIFY(converter.convertToFile(ImageView2D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d}, Containers::Array<char>{NoInit, 0x0f*0x0d*4}}, filename));
     CORRADE_COMPARE_AS(filename,
         "\x0f\x0d\x01", TestSuite::Compare::FileToString);
 }
@@ -5680,7 +5680,7 @@ void AbstractImageConverterTest::convert3DToFileThroughLevels() {
     if(Utility::Path::exists(filename))
         CORRADE_VERIFY(Utility::Path::remove(filename));
 
-    CORRADE_VERIFY(converter.convertToFile(ImageView3D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d, 0x0e}, Containers::Array<char>{0x0f*0x0d*0x0e*4}}, filename));
+    CORRADE_VERIFY(converter.convertToFile(ImageView3D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d, 0x0e}, Containers::Array<char>{NoInit, 0x0f*0x0d*0x0e*4}}, filename));
     CORRADE_COMPARE_AS(filename,
         "\x0f\x0d\x0e\x01", TestSuite::Compare::FileToString);
 }
@@ -5774,7 +5774,7 @@ void AbstractImageConverterTest::convertCompressed1DToFileThroughLevels() {
     if(Utility::Path::exists(filename))
         CORRADE_VERIFY(Utility::Path::remove(filename));
 
-    CORRADE_VERIFY(converter.convertToFile(CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 0x0f, Containers::Array<char>{64}}, filename));
+    CORRADE_VERIFY(converter.convertToFile(CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 0x0f, Containers::Array<char>{NoInit, 64}}, filename));
     CORRADE_COMPARE_AS(filename,
         "\x0f\x01", TestSuite::Compare::FileToString);
 }

src/Magnum/Trade/Test/AbstractImporterTest.cpp

@@ -4049,8 +4049,8 @@ void AbstractImporterTest::sceneNonOwningDeleters() {
 
     auto data = importer.scene(0);
     CORRADE_VERIFY(data);
-    CORRADE_COMPARE(static_cast<const void*>(data->data()), importer.data);
-    CORRADE_COMPARE(static_cast<const void*>(data->fieldData()), importer.fields);
+    CORRADE_COMPARE(static_cast<const void*>(data->data().data()), importer.data);
+    CORRADE_COMPARE(static_cast<const void*>(data->fieldData().data()), importer.fields);
 }
 
 void AbstractImporterTest::sceneCustomDataDeleter() {
@@ -4373,7 +4373,7 @@ void AbstractImporterTest::animationNonOwningDeleters() {
 
     auto data = importer.animation(0);
     CORRADE_VERIFY(data);
-    CORRADE_COMPARE(static_cast<const void*>(data->data()), importer.data);
+    CORRADE_COMPARE(static_cast<const void*>(data->data().data()), importer.data);
 }
 
 void AbstractImporterTest::animationGrowableDeleters() {
@@ -5578,8 +5578,8 @@ void AbstractImporterTest::skin2DNonOwningDeleters() {
     Error redirectError{&out};
 
     auto data = importer.skin2D(0);
-    CORRADE_COMPARE(data->joints(), importer.jointData);
-    CORRADE_COMPARE(data->inverseBindMatrices(), importer.inverseBindMatrixData);
+    CORRADE_COMPARE(data->joints().data(), importer.jointData);
+    CORRADE_COMPARE(data->inverseBindMatrices().data(), importer.inverseBindMatrixData);
 }
 
 void AbstractImporterTest::skin2DCustomJointDataDeleter() {
@@ -5593,7 +5593,7 @@ void AbstractImporterTest::skin2DCustomJointDataDeleter() {
         UnsignedInt doSkin2DCount() const override { return 1; }
         Int doSkin2DForName(Containers::StringView) override { return 0; }
         Containers::Optional<SkinData2D> doSkin2D(UnsignedInt) override {
-            return SkinData2D{Containers::Array<UnsignedInt>{jointData, 1, [](UnsignedInt*, std::size_t){}}, Containers::Array<Matrix3>{1}};
+            return SkinData2D{Containers::Array<UnsignedInt>{jointData, 1, [](UnsignedInt*, std::size_t){}}, Containers::Array<Matrix3>{NoInit, 1}};
         }
 
         UnsignedInt jointData[1]{};
@@ -5620,7 +5620,7 @@ void AbstractImporterTest::skin2DCustomInverseBindMatrixDataDeleter() {
         UnsignedInt doSkin2DCount() const override { return 1; }
         Int doSkin2DForName(Containers::StringView) override { return 0; }
         Containers::Optional<SkinData2D> doSkin2D(UnsignedInt) override {
-            return SkinData2D{Containers::Array<UnsignedInt>{1}, Containers::Array<Matrix3>{inverseBindMatrixData, 1, [](Matrix3*, std::size_t){}}};
+            return SkinData2D{Containers::Array<UnsignedInt>{NoInit, 1}, Containers::Array<Matrix3>{inverseBindMatrixData, 1, [](Matrix3*, std::size_t){}}};
         }
 
         Matrix3 inverseBindMatrixData[1]{};
@@ -5825,8 +5825,8 @@ void AbstractImporterTest::skin3DNonOwningDeleters() {
     Error redirectError{&out};
 
     auto data = importer.skin3D(0);
-    CORRADE_COMPARE(data->joints(), importer.jointData);
-    CORRADE_COMPARE(data->inverseBindMatrices(), importer.inverseBindMatrixData);
+    CORRADE_COMPARE(data->joints().data(), importer.jointData);
+    CORRADE_COMPARE(data->inverseBindMatrices().data(), importer.inverseBindMatrixData);
 }
 
 void AbstractImporterTest::skin3DCustomJointDataDeleter() {
@@ -5840,7 +5840,7 @@ void AbstractImporterTest::skin3DCustomJointDataDeleter() {
         UnsignedInt doSkin3DCount() const override { return 1; }
         Int doSkin3DForName(Containers::StringView) override { return 0; }
         Containers::Optional<SkinData3D> doSkin3D(UnsignedInt) override {
-            return SkinData3D{Containers::Array<UnsignedInt>{jointData, 1, [](UnsignedInt*, std::size_t){}}, Containers::Array<Matrix4>{1}};
+            return SkinData3D{Containers::Array<UnsignedInt>{jointData, 1, [](UnsignedInt*, std::size_t){}}, Containers::Array<Matrix4>{NoInit, 1}};
         }
 
         UnsignedInt jointData[1]{};
@@ -5867,7 +5867,7 @@ void AbstractImporterTest::skin3DCustomInverseBindMatrixDataDeleter() {
         UnsignedInt doSkin3DCount() const override { return 1; }
         Int doSkin3DForName(Containers::StringView) override { return 0; }
         Containers::Optional<SkinData3D> doSkin3D(UnsignedInt) override {
-            return SkinData3D{Containers::Array<UnsignedInt>{1}, Containers::Array<Matrix4>{inverseBindMatrixData, 1, [](Matrix4*, std::size_t){}}};
+            return SkinData3D{Containers::Array<UnsignedInt>{NoInit, 1}, Containers::Array<Matrix4>{inverseBindMatrixData, 1, [](Matrix4*, std::size_t){}}};
         }
 
         Matrix4 inverseBindMatrixData[1]{};
@@ -6197,7 +6197,7 @@ void AbstractImporterTest::meshNonOwningDeleters() {
 
     auto data = importer.mesh(0);
     CORRADE_VERIFY(data);
-    CORRADE_COMPARE(static_cast<const void*>(data->indexData()), importer.indexData);
+    CORRADE_COMPARE(static_cast<const void*>(data->indexData().data()), importer.indexData);
 }
 
 void AbstractImporterTest::meshGrowableDeleters() {
@@ -7027,8 +7027,8 @@ void AbstractImporterTest::materialNonOwningDeleters() {
 
     auto data = importer.material(0);
     CORRADE_VERIFY(data);
-    CORRADE_COMPARE(static_cast<const void*>(data->attributeData()), importer.attributeData);
-    CORRADE_COMPARE(static_cast<const void*>(data->layerData()), importer.layerData);
+    CORRADE_COMPARE(static_cast<const void*>(data->attributeData().data()), importer.attributeData);
+    CORRADE_COMPARE(static_cast<const void*>(data->layerData().data()), importer.layerData);
 }
 
 void AbstractImporterTest::materialCustomAttributeDataDeleter() {
@@ -7518,7 +7518,7 @@ void AbstractImporterTest::image1DNonOwningDeleter() {
 
     auto data = importer.image1D(0);
     CORRADE_VERIFY(data);
-    CORRADE_COMPARE(static_cast<const void*>(data->data()), importer.data);
+    CORRADE_COMPARE(static_cast<const void*>(data->data().data()), importer.data);
 }
 
 void AbstractImporterTest::image1DGrowableDeleter() {
@@ -7830,7 +7830,7 @@ void AbstractImporterTest::image2DNonOwningDeleter() {
 
     auto data = importer.image2D(0);
     CORRADE_VERIFY(data);
-    CORRADE_COMPARE(static_cast<const void*>(data->data()), importer.data);
+    CORRADE_COMPARE(static_cast<const void*>(data->data().data()), importer.data);
 }
 
 void AbstractImporterTest::image2DGrowableDeleter() {
@@ -8142,7 +8142,7 @@ void AbstractImporterTest::image3DNonOwningDeleter() {
 
     auto data = importer.image3D(0);
     CORRADE_VERIFY(data);
-    CORRADE_COMPARE(static_cast<const void*>(data->data()), importer.data);
+    CORRADE_COMPARE(static_cast<const void*>(data->data().data()), importer.data);
 }
 
 void AbstractImporterTest::image3DGrowableDeleter() {

src/Magnum/Trade/Test/AbstractSceneConverterTest.cpp

@@ -1437,7 +1437,7 @@ void AbstractSceneConverterTest::convertMeshNonOwningDeleters() {
 
     Containers::Optional<MeshData> out = converter.convert(MeshData{MeshPrimitive::Triangles, 6});
     CORRADE_VERIFY(out);
-    CORRADE_COMPARE(static_cast<const void*>(out->indexData()), converter.indexData);
+    CORRADE_COMPARE(static_cast<const void*>(out->indexData().data()), converter.indexData);
 }
 
 void AbstractSceneConverterTest::convertMeshGrowableDeleters() {

src/Magnum/Trade/Test/AnimationDataTest.cpp

@@ -679,7 +679,7 @@ void AnimationDataTest::construct() {
         Vector3 position;
         Quaternion rotation;
     };
-    Containers::Array<char> buffer{sizeof(Data)*3};
+    Containers::Array<char> buffer{NoInit, sizeof(Data)*3};
     auto view = Containers::arrayCast<Data>(buffer);
     view[0] = {0.0f, {3.0f, 1.0f, 0.1f}, Quaternion::rotation(45.0_degf, Vector3::yAxis())};
     view[1] = {5.0f, {0.3f, 0.6f, 1.0f}, Quaternion::rotation(20.0_degf, Vector3::yAxis())};
@@ -758,7 +758,7 @@ void AnimationDataTest::constructImplicitDuration() {
         Float time;
         bool value;
     };
-    Containers::Array<char> buffer{sizeof(Data)*4};
+    Containers::Array<char> buffer{NoInit, sizeof(Data)*4};
     auto view = Containers::arrayCast<Data>(buffer);
     view[0] = {1.0f, true};
     view[1] = {5.0f, false};
@@ -951,7 +951,7 @@ void AnimationDataTest::constructMove() {
         Vector3 position;
         Quaternion rotation;
     };
-    Containers::Array<char> buffer{sizeof(Data)*3};
+    Containers::Array<char> buffer{NoInit, sizeof(Data)*3};
     auto view = Containers::arrayCast<Data>(buffer);
     view[0] = {0.0f, {3.0f, 1.0f, 0.1f}, Quaternion::rotation(45.0_degf, Vector3::yAxis())};
     view[1] = {5.0f, {0.3f, 0.6f, 1.0f}, Quaternion::rotation(20.0_degf, Vector3::yAxis())};
@@ -1073,7 +1073,7 @@ void AnimationDataTest::trackCustomResultType() {
         Float time;
         Vector3i position;
     };
-    Containers::Array<char> buffer{sizeof(Data)*3};
+    Containers::Array<char> buffer{NoInit, sizeof(Data)*3};
     auto view = Containers::arrayCast<Data>(buffer);
     view[0] = {0.0f, {300, 100, 10}};
     view[1] = {5.0f, {30, 60, 100}};
@@ -1159,7 +1159,7 @@ void AnimationDataTest::release() {
     CORRADE_COMPARE(data.trackCount(), 1);
 
     Containers::Array<char> released = data.release();
-    CORRADE_COMPARE(data.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(data.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(data.trackCount(), 0);
     CORRADE_COMPARE(static_cast<const void*>(released.data()), keyframes);
 }

src/Magnum/Trade/Test/ImageDataTest.cpp

@@ -1318,7 +1318,7 @@ void ImageDataTest::constructInvalidSize() {
     Error redirectError{&out};
 
     /* Doesn't consider alignment */
-    ImageData2D{PixelFormat::RGB8Unorm, {1, 3}, Containers::Array<char>{3*3}};
+    ImageData2D{PixelFormat::RGB8Unorm, {1, 3}, Containers::Array<char>{NoInit, 3*3}};
     CORRADE_COMPARE(out, "Trade::ImageData: data too small, got 9 but expected at least 12 bytes\n");
 }
 
@@ -1327,10 +1327,10 @@ void ImageDataTest::constructInvalidCubeMap() {
 
     Containers::String out;
     Error redirectError{&out};
-    ImageData3D{PixelFormat::RGBA8Unorm, {3, 3, 5}, Containers::Array<char>{3*3*5*4}, ImageFlag3D::CubeMap};
-    ImageData3D{PixelFormat::RGBA8Unorm, {3, 4, 6}, Containers::Array<char>{3*4*6*4}, ImageFlag3D::CubeMap};
-    ImageData3D{PixelFormat::RGBA8Unorm, {3, 3, 17}, Containers::Array<char>{3*3*17*4}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
-    ImageData3D{PixelFormat::RGBA8Unorm, {4, 3, 18}, Containers::Array<char>{4*3*18*4}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
+    ImageData3D{PixelFormat::RGBA8Unorm, {3, 3, 5}, Containers::Array<char>{NoInit, 3*3*5*4}, ImageFlag3D::CubeMap};
+    ImageData3D{PixelFormat::RGBA8Unorm, {3, 4, 6}, Containers::Array<char>{NoInit, 3*4*6*4}, ImageFlag3D::CubeMap};
+    ImageData3D{PixelFormat::RGBA8Unorm, {3, 3, 17}, Containers::Array<char>{NoInit, 3*3*17*4}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
+    ImageData3D{PixelFormat::RGBA8Unorm, {4, 3, 18}, Containers::Array<char>{NoInit, 4*3*18*4}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
     CORRADE_COMPARE(out,
         "Trade::ImageData: expected exactly 6 faces for a cube map, got 5\n"
         "Trade::ImageData: expected square faces for a cube map, got {3, 4}\n"
@@ -1416,14 +1416,14 @@ void ImageDataTest::constructCompressedInvalidSize() {
     {
         Containers::String out;
         Error redirectError{&out};
-        ImageData2D{CompressedPixelFormat::Bc2RGBAUnorm, {4, 4}, Containers::Array<char>{15}};
+        ImageData2D{CompressedPixelFormat::Bc2RGBAUnorm, {4, 4}, Containers::Array<char>{NoInit, 15}};
         CORRADE_COMPARE(out, "Trade::ImageData: data too small, got 15 but expected at least 16 bytes\n");
 
     /* Size should be rounded up even if the image size is not full block */
     } {
         Containers::String out;
         Error redirectError{&out};
-        ImageData2D{CompressedPixelFormat::Bc2RGBAUnorm, {2, 2}, Containers::Array<char>{15}};
+        ImageData2D{CompressedPixelFormat::Bc2RGBAUnorm, {2, 2}, Containers::Array<char>{NoInit, 15}};
         CORRADE_COMPARE(out, "Trade::ImageData: data too small, got 15 but expected at least 16 bytes\n");
     }
 }
@@ -1433,10 +1433,10 @@ void ImageDataTest::constructCompressedInvalidCubeMap() {
 
     Containers::String out;
     Error redirectError{&out};
-    ImageData3D{CompressedPixelFormat::Bc1RGBAUnorm, {3, 3, 5}, Containers::Array<char>{8*5}, ImageFlag3D::CubeMap};
-    ImageData3D{CompressedPixelFormat::Bc1RGBAUnorm, {3, 4, 6}, Containers::Array<char>{8*6}, ImageFlag3D::CubeMap};
-    ImageData3D{CompressedPixelFormat::Bc1RGBAUnorm, {3, 3, 17}, Containers::Array<char>{8*17}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
-    ImageData3D{CompressedPixelFormat::Bc1RGBAUnorm, {4, 3, 18}, Containers::Array<char>{8*18}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
+    ImageData3D{CompressedPixelFormat::Bc1RGBAUnorm, {3, 3, 5}, Containers::Array<char>{NoInit, 8*5}, ImageFlag3D::CubeMap};
+    ImageData3D{CompressedPixelFormat::Bc1RGBAUnorm, {3, 4, 6}, Containers::Array<char>{NoInit, 8*6}, ImageFlag3D::CubeMap};
+    ImageData3D{CompressedPixelFormat::Bc1RGBAUnorm, {3, 3, 17}, Containers::Array<char>{NoInit, 8*17}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
+    ImageData3D{CompressedPixelFormat::Bc1RGBAUnorm, {4, 3, 18}, Containers::Array<char>{NoInit, 8*18}, ImageFlag3D::CubeMap |ImageFlag3D::Array};
     CORRADE_COMPARE(out,
         "Trade::ImageData: expected exactly 6 faces for a cube map, got 5\n"
         "Trade::ImageData: expected square faces for a cube map, got {3, 4}\n"
@@ -1456,7 +1456,7 @@ void ImageDataTest::constructMoveGeneric() {
         PixelFormat::RGBA32F, {1, 3}, Containers::Array<char>{data, 3*16}, ImageFlag2D::Array, &state};
     ImageData2D b(Utility::move(a));
 
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(a.size(), Vector2i{});
 
     CORRADE_COMPARE(b.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
@@ -1467,7 +1467,7 @@ void ImageDataTest::constructMoveGeneric() {
     CORRADE_COMPARE(b.formatExtra(), 0);
     CORRADE_COMPARE(b.pixelSize(), 16);
     CORRADE_COMPARE(b.size(), (Vector2i{1, 3}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 3*16);
     CORRADE_COMPARE(b.importerState(), &state);
 
@@ -1475,7 +1475,7 @@ void ImageDataTest::constructMoveGeneric() {
     ImageData2D c{PixelFormat::R8I, {2, 6}, Containers::Array<char>{data2, 24}};
     c = Utility::move(b);
 
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data2));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data2));
     CORRADE_COMPARE(b.size(), (Vector2i{2, 6}));
 
     CORRADE_COMPARE(c.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
@@ -1486,7 +1486,7 @@ void ImageDataTest::constructMoveGeneric() {
     CORRADE_COMPARE(c.formatExtra(), 0);
     CORRADE_COMPARE(c.pixelSize(), 16);
     CORRADE_COMPARE(c.size(), (Vector2i{1, 3}));
-    CORRADE_COMPARE(c.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(c.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(c.data().size(), 3*16);
     CORRADE_COMPARE(c.importerState(), &state);
 
@@ -1501,7 +1501,7 @@ void ImageDataTest::constructMoveImplementationSpecific() {
         GL::PixelFormat::RGB, GL::PixelType::UnsignedShort, {1, 3}, Containers::Array<char>{data, 3*6}, ImageFlag2D::Array, &state};
     ImageData2D b(Utility::move(a));
 
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(a.size(), Vector2i{});
 
     CORRADE_COMPARE(b.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
@@ -1512,7 +1512,7 @@ void ImageDataTest::constructMoveImplementationSpecific() {
     CORRADE_COMPARE(b.formatExtra(), 1337);
     CORRADE_COMPARE(b.pixelSize(), 6);
     CORRADE_COMPARE(b.size(), (Vector2i{1, 3}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 3*6);
     CORRADE_COMPARE(b.importerState(), &state);
 
@@ -1521,7 +1521,7 @@ void ImageDataTest::constructMoveImplementationSpecific() {
         1, 2, 8, {2, 6}, Containers::Array<char>{data2, 12*4*2}};
     c = Utility::move(b);
 
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data2));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data2));
     CORRADE_COMPARE(b.size(), Vector2i(2, 6));
 
     CORRADE_COMPARE(c.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
@@ -1532,7 +1532,7 @@ void ImageDataTest::constructMoveImplementationSpecific() {
     CORRADE_COMPARE(c.formatExtra(), 1337);
     CORRADE_COMPARE(c.pixelSize(), 6);
     CORRADE_COMPARE(c.size(), (Vector2i{1, 3}));
-    CORRADE_COMPARE(c.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(c.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(c.data().size(), 3*6);
     CORRADE_COMPARE(c.importerState(), &state);
 }
@@ -1546,7 +1546,7 @@ void ImageDataTest::constructMoveCompressedGeneric() {
         Containers::Array<char>{data, 8*16}, ImageFlag2D::Array, &state};
     ImageData2D b{Utility::move(a)};
 
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(a.size(), Vector2i{});
 
     CORRADE_COMPARE(b.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
@@ -1557,7 +1557,7 @@ void ImageDataTest::constructMoveCompressedGeneric() {
     CORRADE_COMPARE(b.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(b.blockDataSize(), 16);
     CORRADE_COMPARE(b.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 8*16);
     CORRADE_COMPARE(b.importerState(), &state);
 
@@ -1565,7 +1565,7 @@ void ImageDataTest::constructMoveCompressedGeneric() {
     ImageData2D c{CompressedPixelFormat::Bc1RGBAUnorm, {8, 4}, Containers::Array<char>{data2, 16}};
     c = Utility::move(b);
 
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data2));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data2));
     CORRADE_COMPARE(b.size(), (Vector2i{8, 4}));
 
     CORRADE_COMPARE(c.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
@@ -1576,7 +1576,7 @@ void ImageDataTest::constructMoveCompressedGeneric() {
     CORRADE_COMPARE(c.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(c.blockDataSize(), 16);
     CORRADE_COMPARE(c.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(c.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(c.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(c.data().size(), 8*16);
     CORRADE_COMPARE(c.importerState(), &state);
 }
@@ -1590,7 +1590,7 @@ void ImageDataTest::constructMoveCompressedImplementationSpecific() {
         Containers::Array<char>{data, 8*16}, ImageFlag2D::Array, &state};
     ImageData2D b{Utility::move(a)};
 
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(a.size(), Vector2i{});
 
     CORRADE_COMPARE(b.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
@@ -1601,7 +1601,7 @@ void ImageDataTest::constructMoveCompressedImplementationSpecific() {
     CORRADE_COMPARE(b.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(b.blockDataSize(), 16);
     CORRADE_COMPARE(b.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 8*16);
     CORRADE_COMPARE(b.importerState(), &state);
 
@@ -1609,7 +1609,7 @@ void ImageDataTest::constructMoveCompressedImplementationSpecific() {
     ImageData2D c{CompressedPixelFormat::Bc1RGBAUnorm, {8, 4}, Containers::Array<char>{data2, 16}};
     c = Utility::move(b);
 
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data2));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data2));
     CORRADE_COMPARE(b.size(), (Vector2i{8, 4}));
 
     CORRADE_COMPARE(c.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
@@ -1620,7 +1620,7 @@ void ImageDataTest::constructMoveCompressedImplementationSpecific() {
     CORRADE_COMPARE(c.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(c.blockDataSize(), 16);
     CORRADE_COMPARE(c.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(c.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(c.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(c.data().size(), 8*16);
     CORRADE_COMPARE(c.importerState(), &state);
 }
@@ -1633,7 +1633,7 @@ void ImageDataTest::constructMoveAttachState() {
         GL::PixelFormat::RGB, GL::PixelType::UnsignedShort, {1, 3}, Containers::Array<char>{data, 3*6}, ImageFlag2D::Array, &stateOld};
     ImageData2D b{Utility::move(a), &stateNew};
 
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(a.size(), Vector2i{});
 
     CORRADE_COMPARE(b.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
@@ -1644,7 +1644,7 @@ void ImageDataTest::constructMoveAttachState() {
     CORRADE_COMPARE(b.formatExtra(), 1337);
     CORRADE_COMPARE(b.pixelSize(), 6);
     CORRADE_COMPARE(b.size(), (Vector2i{1, 3}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 3*6);
     CORRADE_COMPARE(b.importerState(), &stateNew);
 }
@@ -1659,7 +1659,7 @@ void ImageDataTest::constructMoveCompressedAttachState() {
         Containers::Array<char>{data, 8*8}, ImageFlag2D::Array, &stateOld};
     ImageData2D b{Utility::move(a), &stateNew};
 
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(a.size(), Vector2i{});
 
     CORRADE_COMPARE(b.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
@@ -1670,7 +1670,7 @@ void ImageDataTest::constructMoveCompressedAttachState() {
     CORRADE_COMPARE(b.blockSize(), (Vector3i{4, 4, 1}));
     CORRADE_COMPARE(b.blockDataSize(), 8);
     CORRADE_COMPARE(b.size(), (Vector2i{12, 8}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 8*8);
     CORRADE_COMPARE(b.importerState(), &stateNew);
 }
@@ -1712,7 +1712,7 @@ void ImageDataTest::moveCompressedToUncompressed() {
     CORRADE_COMPARE(a.formatExtra(), 0x12345678);
     CORRADE_COMPARE(a.pixelSize(), 1);
     CORRADE_COMPARE(a.size(), (Vector2i{2, 5}));
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(data2));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data2));
     CORRADE_COMPARE(a.data().size(), 24);
     CORRADE_COMPARE(a.importerState(), &state2);
 
@@ -1726,7 +1726,7 @@ void ImageDataTest::moveCompressedToUncompressed() {
     CORRADE_COMPARE(b.compressedStorage().compressedBlockDataSize(), 16);
     CORRADE_COMPARE(b.compressedFormat(), CompressedPixelFormat::Bc3RGBAUnorm);
     CORRADE_COMPARE(b.size(), (Vector2i{4, 4}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 8*16);
     CORRADE_COMPARE(b.importerState(), &state);
 }
@@ -1767,7 +1767,7 @@ void ImageDataTest::moveUncompressedToCompressed() {
     CORRADE_COMPARE(a.compressedStorage().compressedBlockDataSize(), 16);
     CORRADE_COMPARE(a.compressedFormat(), CompressedPixelFormat::Bc3RGBAUnorm);
     CORRADE_COMPARE(a.size(), (Vector2i{4, 4}));
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(data2));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data2));
     CORRADE_COMPARE(a.data().size(), 8*16);
     CORRADE_COMPARE(a.importerState(), &state2);
 
@@ -1782,7 +1782,7 @@ void ImageDataTest::moveUncompressedToCompressed() {
     CORRADE_COMPARE(b.formatExtra(), 0x12345678);
     CORRADE_COMPARE(b.pixelSize(), 1);
     CORRADE_COMPARE(b.size(), (Vector2i{2, 5}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 24);
     CORRADE_COMPARE(b.importerState(), &state);
 }
@@ -1842,7 +1842,7 @@ template<class T> void ImageDataTest::toViewGeneric() {
     CORRADE_COMPARE(b.formatExtra(), 0);
     CORRADE_COMPARE(b.pixelSize(), 4);
     CORRADE_COMPARE(b.size(), (Vector2i{1, 3}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
 }
 
 template<class T> void ImageDataTest::toViewImplementationSpecific() {
@@ -1859,7 +1859,7 @@ template<class T> void ImageDataTest::toViewImplementationSpecific() {
     CORRADE_COMPARE(b.formatExtra(), 1337);
     CORRADE_COMPARE(b.pixelSize(), 6);
     CORRADE_COMPARE(b.size(), (Vector2i{1, 3}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
 }
 
 template<class T> void ImageDataTest::toViewCompressedGeneric() {
@@ -1878,7 +1878,7 @@ template<class T> void ImageDataTest::toViewCompressedGeneric() {
     CORRADE_COMPARE(b.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(b.blockDataSize(), 16);
     CORRADE_COMPARE(b.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 8*16);
 }
 
@@ -1898,7 +1898,7 @@ template<class T> void ImageDataTest::toViewCompressedImplementationSpecific() {
     CORRADE_COMPARE(b.blockSize(), (Vector3i{5, 5, 4}));
     CORRADE_COMPARE(b.blockDataSize(), 16);
     CORRADE_COMPARE(b.size(), (Vector2i{15, 10}));
-    CORRADE_COMPARE(b.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(b.data().data(), static_cast<const void*>(data));
     CORRADE_COMPARE(b.data().size(), 8*16);
 }
 
@@ -1906,8 +1906,8 @@ void ImageDataTest::data() {
     auto data = new char[4*4];
     ImageData2D a{PixelFormat::RGBA8Unorm, {1, 3}, Containers::Array<char>{data, 4*4}};
     const ImageData2D& ca = a;
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(data));
-    CORRADE_COMPARE(ca.data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(data));
+    CORRADE_COMPARE(ca.data().data(), static_cast<const void*>(data));
 }
 
 void ImageDataTest::dataRvalue() {
@@ -1951,7 +1951,7 @@ void ImageDataTest::dataProperties() {
             .setAlignment(8)
             .setSkip({3, 2, 1}),
         PixelFormat::R8Unorm, {2, 4, 6},
-        Containers::Array<char>{224}};
+        Containers::Array<char>{NoInit, 224}};
     CORRADE_COMPARE(image.dataProperties(),
         (std::pair<Math::Vector3<std::size_t>, Math::Vector3<std::size_t>>{{3, 16, 32}, {8, 4, 6}}));
 }
@@ -1974,7 +1974,7 @@ void ImageDataTest::release() {
     const char* const pointer = a.release().release();
 
     CORRADE_COMPARE(pointer, data);
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(a.size(), Vector2i());
 }
 
@@ -1984,7 +1984,7 @@ void ImageDataTest::releaseCompressed() {
     const char* const pointer = a.release().release();
 
     CORRADE_COMPARE(pointer, data);
-    CORRADE_COMPARE(a.data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(a.data().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(a.size(), Vector2i());
 }
 
@@ -1994,7 +1994,7 @@ void ImageDataTest::pixels1D() {
             .setAlignment(1) /** @todo alignment 4 expects 17 bytes. what */
             .setSkip({3, 0, 0}),
         PixelFormat::RGB8Unorm, 2,
-        Containers::Array<char>{15}};
+        Containers::Array<char>{NoInit, 15}};
     const ImageData1D& cimage = image;
 
     /* Full test is in ImageTest, this is just a sanity check */
@@ -2003,12 +2003,12 @@ void ImageDataTest::pixels1D() {
         Containers::StridedArrayView1D<Color3ub> pixels = image.mutablePixels<Color3ub>();
         CORRADE_COMPARE(pixels.size(), 2);
         CORRADE_COMPARE(pixels.stride(), 3);
-        CORRADE_COMPARE(pixels.data(), image.data() + 3*3);
+        CORRADE_COMPARE(pixels.data(), image.data().data() + 3*3);
     } {
         Containers::StridedArrayView1D<const Color3ub> pixels = cimage.pixels<Color3ub>();
         CORRADE_COMPARE(pixels.size(), 2);
         CORRADE_COMPARE(pixels.stride(), 3);
-        CORRADE_COMPARE(pixels.data(), cimage.data() + 3*3);
+        CORRADE_COMPARE(pixels.data(), cimage.data().data() + 3*3);
     }
 }
 
@@ -2019,7 +2019,7 @@ void ImageDataTest::pixels2D() {
             .setSkip({3, 2, 0})
             .setRowLength(6),
         PixelFormat::RGB8Unorm, {2, 4},
-        Containers::Array<char>{120}};
+        Containers::Array<char>{NoInit, 120}};
     const ImageData2D& cimage = image;
 
     /* Full test is in ImageTest, this is just a sanity check */
@@ -2028,12 +2028,12 @@ void ImageDataTest::pixels2D() {
         Containers::StridedArrayView2D<Color3ub> pixels = image.mutablePixels<Color3ub>();
         CORRADE_COMPARE(pixels.size(), (Containers::Size2D{4, 2}));
         CORRADE_COMPARE(pixels.stride(), (Containers::Stride2D{20, 3}));
-        CORRADE_COMPARE(pixels.data(), image.data() + 2*20 + 3*3);
+        CORRADE_COMPARE(pixels.data(), image.data().data() + 2*20 + 3*3);
     } {
         Containers::StridedArrayView2D<const Color3ub> pixels = cimage.pixels<Color3ub>();
         CORRADE_COMPARE(pixels.size(), (Containers::Size2D{4, 2}));
         CORRADE_COMPARE(pixels.stride(), (Containers::Stride2D{20, 3}));
-        CORRADE_COMPARE(pixels.data(), cimage.data() + 2*20 + 3*3);
+        CORRADE_COMPARE(pixels.data(), cimage.data().data() + 2*20 + 3*3);
     }
 }
 
@@ -2045,7 +2045,7 @@ void ImageDataTest::pixels3D() {
             .setRowLength(6)
             .setImageHeight(7),
         PixelFormat::RGB8Unorm, {2, 4, 3},
-        Containers::Array<char>{560}};
+        Containers::Array<char>{NoInit, 560}};
     const ImageData3D& cimage = image;
 
     /* Full test is in ImageTest, this is just a sanity check */
@@ -2054,12 +2054,12 @@ void ImageDataTest::pixels3D() {
         Containers::StridedArrayView3D<Color3ub> pixels = image.mutablePixels<Color3ub>();
         CORRADE_COMPARE(pixels.size(), (Containers::Size3D{3, 4, 2}));
         CORRADE_COMPARE(pixels.stride(), (Containers::Stride3D{140, 20, 3}));
-        CORRADE_COMPARE(pixels.data(), image.data() + 140 + 2*20 + 3*3);
+        CORRADE_COMPARE(pixels.data(), image.data().data() + 140 + 2*20 + 3*3);
     } {
         Containers::StridedArrayView3D<const Color3ub> pixels = cimage.pixels<Color3ub>();
         CORRADE_COMPARE(pixels.size(), (Containers::Size3D{3, 4, 2}));
         CORRADE_COMPARE(pixels.stride(), (Containers::Stride3D{140, 20, 3}));
-        CORRADE_COMPARE(pixels.data(), cimage.data() + 140 + 2*20 + 3*3);
+        CORRADE_COMPARE(pixels.data(), cimage.data().data() + 140 + 2*20 + 3*3);
     }
 }
 

src/Magnum/Trade/Test/MeshDataTest.cpp

@@ -1607,13 +1607,13 @@ void MeshDataTest::construct() {
         Byte idMorphTarget[3];
     };
 
-    Containers::Array<char> indexData{8*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{NoInit, 8*sizeof(UnsignedShort)};
     auto indices = Containers::arrayCast<UnsignedShort>(indexData).slice(1, 7);
     Utility::copy({0, 1, 2, 0, 2, 1}, indices);
 
     /* Enough vertex data to fit also the case with large explicit vertex count
        (but fill just the first 3, as those are only tested) */
-    Containers::Array<char> vertexData{17*sizeof(Vertex)};
+    Containers::Array<char> vertexData{NoInit, 17*sizeof(Vertex)};
     auto vertices = stridedArrayView(Containers::arrayCast<Vertex>(vertexData)).prefix(3);
     Utility::copy({
         {{0.1f, 0.2f, 0.3f},
@@ -1675,10 +1675,10 @@ void MeshDataTest::construct() {
     CORRADE_COMPARE(data.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_COMPARE(data.primitive(), MeshPrimitive::Triangles);
     CORRADE_VERIFY(!data.attributeData().isEmpty());
-    CORRADE_COMPARE(static_cast<const void*>(data.indexData() + 2), indices.data());
-    CORRADE_COMPARE(static_cast<const void*>(data.vertexData()), vertices.data());
-    CORRADE_COMPARE(static_cast<void*>(data.mutableIndexData() + 2), indices.data());
-    CORRADE_COMPARE(static_cast<void*>(data.mutableVertexData()), vertices.data());
+    CORRADE_COMPARE(static_cast<const void*>(data.indexData().data() + 2), indices.data());
+    CORRADE_COMPARE(static_cast<const void*>(data.vertexData().data()), vertices.data());
+    CORRADE_COMPARE(static_cast<void*>(data.mutableIndexData().data() + 2), indices.data());
+    CORRADE_COMPARE(static_cast<void*>(data.mutableVertexData().data()), vertices.data());
     CORRADE_COMPARE(data.importerState(), &importerState);
 
     /* Index access */
@@ -2072,7 +2072,7 @@ void MeshDataTest::constructZeroIndices() {
     /* This is a valid use case because this could be an empty slice of a
        well-defined indexed mesh. Explicitly use a non-null zero-sized array
        to check the importer is checking size and not pointer. */
-    Containers::Array<char> vertexData{3*sizeof(Vector3)};
+    Containers::Array<char> vertexData{NoInit, 3*sizeof(Vector3)};
     auto vertices = Containers::arrayCast<Vector3>(vertexData);
     char i;
     Containers::Array<char> indexData{&i, 0, [](char*, std::size_t){}};
@@ -2096,8 +2096,8 @@ void MeshDataTest::constructZeroAttributes() {
     /* This is a valid use case because e.g. the index/vertex data can be
        shared by multiple meshes and this particular one is just a plain
        index array */
-    Containers::Array<char> indexData{3*sizeof(UnsignedInt)};
-    Containers::Array<char> vertexData{3};
+    Containers::Array<char> indexData{ValueInit, 3*sizeof(UnsignedInt)};
+    Containers::Array<char> vertexData{NoInit, 3};
     auto indices = Containers::arrayCast<UnsignedInt>(indexData);
     MeshData data{MeshPrimitive::Triangles,
         Utility::move(indexData), MeshIndexData{indices},
@@ -2114,7 +2114,7 @@ void MeshDataTest::constructZeroAttributes() {
 void MeshDataTest::constructZeroVertices() {
     /* This is a valid use case because this could be an empty slice of a
        well-defined indexed mesh */
-    Containers::Array<char> indexData{3*sizeof(UnsignedInt)};
+    Containers::Array<char> indexData{ValueInit, 3*sizeof(UnsignedInt)};
     auto indices = Containers::arrayCast<UnsignedInt>(indexData);
     MeshData data{MeshPrimitive::Triangles,
         Utility::move(indexData), MeshIndexData{indices},
@@ -2133,7 +2133,7 @@ void MeshDataTest::constructZeroVertices() {
 }
 
 void MeshDataTest::constructIndexless() {
-    Containers::Array<char> vertexData{3*sizeof(Vector2)};
+    Containers::Array<char> vertexData{NoInit, 3*sizeof(Vector2)};
     auto vertices = Containers::arrayCast<Vector2>(vertexData);
     Utility::copy({
         {0.1f, 0.2f},
@@ -2156,7 +2156,7 @@ void MeshDataTest::constructIndexless() {
        allowed, to allow creation of MeshData instances referencing other
        MeshData without having to branch on isIndexed(). */
     CORRADE_VERIFY(!data.isIndexed());
-    CORRADE_COMPARE(data.indexData(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(data.indexData().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(data.indices().data(), nullptr);
     CORRADE_COMPARE(data.indices().size(), (Containers::Size2D{0, 0}));
     CORRADE_COMPARE(data.mutableIndices().data(), nullptr);
@@ -2173,8 +2173,8 @@ void MeshDataTest::constructIndexlessZeroVertices() {
         MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, nullptr}
     }};
     CORRADE_COMPARE(data.primitive(), MeshPrimitive::LineLoop);
-    CORRADE_COMPARE(data.indexData(), static_cast<const void*>(nullptr));
-    CORRADE_COMPARE(data.vertexData(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(data.indexData().data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(data.vertexData().data(), static_cast<const void*>(nullptr));
 
     CORRADE_VERIFY(!data.isIndexed());
     CORRADE_COMPARE(data.vertexCount(), 0);
@@ -2183,7 +2183,7 @@ void MeshDataTest::constructIndexlessZeroVertices() {
 }
 
 void MeshDataTest::constructAttributeless() {
-    Containers::Array<char> indexData{6*sizeof(UnsignedInt)};
+    Containers::Array<char> indexData{ValueInit, 6*sizeof(UnsignedInt)};
     auto indices = Containers::arrayCast<UnsignedInt>(indexData);
     Utility::copy({0, 1, 2, 0, 2, 1}, indices);
 
@@ -2197,7 +2197,7 @@ void MeshDataTest::constructAttributeless() {
     CORRADE_COMPARE(data.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_COMPARE(data.primitive(), MeshPrimitive::TriangleStrip);
     CORRADE_VERIFY(!data.attributeData());
-    CORRADE_COMPARE(data.vertexData(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(data.vertexData().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(data.importerState(), &importerState);
 
     CORRADE_VERIFY(data.isIndexed());
@@ -2220,8 +2220,8 @@ void MeshDataTest::constructIndexlessAttributeless() {
     CORRADE_COMPARE(data.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_COMPARE(data.primitive(), MeshPrimitive::TriangleStrip);
     CORRADE_VERIFY(!data.attributeData());
-    CORRADE_COMPARE(data.indexData(), static_cast<const void*>(nullptr));
-    CORRADE_COMPARE(data.vertexData(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(data.indexData().data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(data.vertexData().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(data.importerState(), &state);
 
     CORRADE_VERIFY(!data.isIndexed());
@@ -2234,8 +2234,8 @@ void MeshDataTest::constructIndexlessAttributelessZeroVertices() {
     MeshData data{MeshPrimitive::TriangleStrip, 0, &state};
     CORRADE_COMPARE(data.primitive(), MeshPrimitive::TriangleStrip);
     CORRADE_VERIFY(!data.attributeData());
-    CORRADE_COMPARE(data.indexData(), static_cast<const void*>(nullptr));
-    CORRADE_COMPARE(data.vertexData(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(data.indexData().data(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(data.vertexData().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(data.importerState(), &state);
 
     CORRADE_VERIFY(!data.isIndexed());
@@ -2329,7 +2329,7 @@ void MeshDataTest::constructImplementationSpecificVertexFormat() {
 void MeshDataTest::constructSpecialIndexStrides() {
     /* Every second index */
     {
-        Containers::Array<char> indexData{sizeof(UnsignedShort)*8};
+        Containers::Array<char> indexData{ValueInit, sizeof(UnsignedShort)*8};
         Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
         Utility::copy({1, 0, 2, 0, 3, 0, 4, 0}, indices);
         MeshData mesh{MeshPrimitive::Points, Utility::move(indexData),
@@ -2361,7 +2361,7 @@ void MeshDataTest::constructSpecialIndexStrides() {
 
     /* Zero stride. Not sure how useful like this. */
     } {
-        Containers::Array<char> indexData{sizeof(UnsignedShort)};
+        Containers::Array<char> indexData{ValueInit, sizeof(UnsignedShort)};
         Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
         indices[0] = 15;
         MeshData mesh{MeshPrimitive::Points, Utility::move(indexData),
@@ -2393,7 +2393,7 @@ void MeshDataTest::constructSpecialIndexStrides() {
 
     /* Negative stride */
     } {
-        Containers::Array<char> indexData{sizeof(UnsignedShort)*4};
+        Containers::Array<char> indexData{ValueInit, sizeof(UnsignedShort)*4};
         Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
         Utility::copy({1, 2, 3, 4}, indices);
         MeshData mesh{MeshPrimitive::Points, Utility::move(indexData),
@@ -2432,7 +2432,7 @@ void MeshDataTest::constructSpecialIndexStridesImplementationSpecificIndexType()
 
     /* Every second index */
     {
-        Containers::Array<char> indexData{sizeof(UnsignedShort)*8};
+        Containers::Array<char> indexData{ValueInit, sizeof(UnsignedShort)*8};
         Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
         Utility::copy({1, 0, 2, 0, 3, 0, 4, 0}, indices);
         MeshData mesh{MeshPrimitive::Points, Utility::move(indexData),
@@ -2456,7 +2456,7 @@ void MeshDataTest::constructSpecialIndexStridesImplementationSpecificIndexType()
        access anything except for directly interpreting the data pointer. Which
        is actually as desired for implementation-specific index types. */
     } {
-        Containers::Array<char> indexData{sizeof(UnsignedShort)};
+        Containers::Array<char> indexData{ValueInit, sizeof(UnsignedShort)};
         Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
         indices[0] = 15;
         MeshData mesh{MeshPrimitive::Points, Utility::move(indexData),
@@ -2476,7 +2476,7 @@ void MeshDataTest::constructSpecialIndexStridesImplementationSpecificIndexType()
 
     /* Negative stride */
     } {
-        Containers::Array<char> indexData{sizeof(UnsignedShort)*4};
+        Containers::Array<char> indexData{ValueInit, sizeof(UnsignedShort)*4};
         Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
         Utility::copy({1, 2, 3, 4}, indices);
         MeshData mesh{MeshPrimitive::Points, Utility::move(indexData),
@@ -2498,7 +2498,7 @@ void MeshDataTest::constructSpecialIndexStridesImplementationSpecificIndexType()
 }
 
 void MeshDataTest::constructSpecialAttributeStrides() {
-    Containers::Array<char> vertexData{sizeof(UnsignedShort)*5};
+    Containers::Array<char> vertexData{NoInit, sizeof(UnsignedShort)*5};
     Containers::StridedArrayView1D<UnsignedShort> vertices = Containers::arrayCast<UnsignedShort>(vertexData);
     Utility::copy({15, 1, 2, 3, 4}, vertices);
 
@@ -2556,7 +2556,7 @@ void MeshDataTest::constructSpecialAttributeStridesImplementationSpecificVertexF
        formats, which causes the attribute() to return the full stride in
        second dimension */
 
-    Containers::Array<char> vertexData{sizeof(UnsignedShort)*5};
+    Containers::Array<char> vertexData{NoInit, sizeof(UnsignedShort)*5};
     Containers::StridedArrayView1D<UnsignedShort> vertices = Containers::arrayCast<UnsignedShort>(vertexData);
     Utility::copy({15, 1, 2, 3, 4}, vertices);
 
@@ -2609,12 +2609,12 @@ void MeshDataTest::constructNotOwned() {
     CORRADE_COMPARE(data.indexDataFlags(), instanceData.indexDataFlags);
     CORRADE_COMPARE(data.vertexDataFlags(), instanceData.vertexDataFlags);
     CORRADE_COMPARE(data.primitive(), MeshPrimitive::Triangles);
-    CORRADE_COMPARE(static_cast<const void*>(data.indexData()), +indices);
-    CORRADE_COMPARE(static_cast<const void*>(data.vertexData()), +vertices);
+    CORRADE_COMPARE(static_cast<const void*>(data.indexData().data()), +indices);
+    CORRADE_COMPARE(static_cast<const void*>(data.vertexData().data()), +vertices);
     if(instanceData.indexDataFlags & DataFlag::Mutable)
-        CORRADE_COMPARE(static_cast<const void*>(data.mutableIndexData()), +indices);
+        CORRADE_COMPARE(static_cast<const void*>(data.mutableIndexData().data()), +indices);
     if(instanceData.vertexDataFlags & DataFlag::Mutable)
-        CORRADE_COMPARE(static_cast<const void*>(data.mutableVertexData()), +vertices);
+        CORRADE_COMPARE(static_cast<const void*>(data.mutableVertexData().data()), +vertices);
     CORRADE_COMPARE(data.importerState(), &importerState);
 
     CORRADE_VERIFY(data.isIndexed());
@@ -2646,7 +2646,7 @@ void MeshDataTest::constructIndicesNotOwned() {
     setTestCaseDescription(instanceData.name);
 
     UnsignedShort indices[]{0, 1, 0};
-    Containers::Array<char> vertexData{2*sizeof(Vector2)};
+    Containers::Array<char> vertexData{NoInit, 2*sizeof(Vector2)};
     auto vertices = Containers::arrayCast<Vector2>(vertexData);
     Utility::copy({
         {0.1f, 0.2f},
@@ -2664,11 +2664,11 @@ void MeshDataTest::constructIndicesNotOwned() {
     CORRADE_COMPARE(data.indexDataFlags(), instanceData.dataFlags);
     CORRADE_COMPARE(data.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_COMPARE(data.primitive(), MeshPrimitive::Triangles);
-    CORRADE_COMPARE(static_cast<const void*>(data.indexData()), +indices);
-    CORRADE_COMPARE(static_cast<const void*>(data.vertexData()), vertices.data());
+    CORRADE_COMPARE(static_cast<const void*>(data.indexData().data()), +indices);
+    CORRADE_COMPARE(static_cast<const void*>(data.vertexData().data()), vertices.data());
     if(instanceData.dataFlags & DataFlag::Mutable)
-        CORRADE_COMPARE(static_cast<const void*>(data.mutableIndexData()), +indices);
-    CORRADE_COMPARE(static_cast<const void*>(data.mutableVertexData()), vertices.data());
+        CORRADE_COMPARE(static_cast<const void*>(data.mutableIndexData().data()), +indices);
+    CORRADE_COMPARE(static_cast<const void*>(data.mutableVertexData().data()), vertices.data());
     CORRADE_COMPARE(data.importerState(), &importerState);
 
     CORRADE_VERIFY(data.isIndexed());
@@ -2697,7 +2697,7 @@ void MeshDataTest::constructVerticesNotOwned() {
     auto&& instanceData = SingleNotOwnedData[testCaseInstanceId()];
     setTestCaseDescription(instanceData.name);
 
-    Containers::Array<char> indexData{3*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, 3*sizeof(UnsignedShort)};
     auto indices = Containers::arrayCast<UnsignedShort>(indexData);
     Utility::copy({0, 1, 0}, indices);
     Vector2 vertices[]{{0.1f, 0.2f}, {0.4f, 0.5f}};
@@ -2714,11 +2714,11 @@ void MeshDataTest::constructVerticesNotOwned() {
     CORRADE_COMPARE(data.indexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_COMPARE(data.vertexDataFlags(), instanceData.dataFlags);
     CORRADE_COMPARE(data.primitive(), MeshPrimitive::Triangles);
-    CORRADE_COMPARE(static_cast<const void*>(data.indexData()), indices.data());
-    CORRADE_COMPARE(static_cast<const void*>(data.vertexData()), +vertices);
-    CORRADE_COMPARE(static_cast<const void*>(data.mutableIndexData()), indices.data());
+    CORRADE_COMPARE(static_cast<const void*>(data.indexData().data()), indices.data());
+    CORRADE_COMPARE(static_cast<const void*>(data.vertexData().data()), +vertices);
+    CORRADE_COMPARE(static_cast<const void*>(data.mutableIndexData().data()), indices.data());
     if(instanceData.dataFlags & DataFlag::Mutable)
-        CORRADE_COMPARE(static_cast<const void*>(data.mutableVertexData()), +vertices);
+        CORRADE_COMPARE(static_cast<const void*>(data.mutableVertexData().data()), +vertices);
     CORRADE_COMPARE(data.importerState(), &importerState);
 
     CORRADE_VERIFY(data.isIndexed());
@@ -2760,9 +2760,9 @@ void MeshDataTest::constructIndexlessNotOwned() {
     CORRADE_COMPARE(data.indexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_COMPARE(data.vertexDataFlags(), instanceData.dataFlags);
     CORRADE_COMPARE(data.primitive(), MeshPrimitive::LineLoop);
-    CORRADE_COMPARE(data.indexData(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(data.indexData().data(), static_cast<const void*>(nullptr));
     if(instanceData.dataFlags & DataFlag::Mutable)
-        CORRADE_COMPARE(data.mutableIndexData(), static_cast<void*>(nullptr));
+        CORRADE_COMPARE(data.mutableIndexData().data(), static_cast<void*>(nullptr));
     CORRADE_COMPARE(data.importerState(), &importerState);
 
     CORRADE_VERIFY(!data.isIndexed());
@@ -2788,9 +2788,9 @@ void MeshDataTest::constructAttributelessNotOwned() {
     CORRADE_COMPARE(data.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_COMPARE(data.primitive(), MeshPrimitive::TriangleStrip);
     CORRADE_VERIFY(!data.attributeData());
-    CORRADE_COMPARE(data.vertexData(), static_cast<const void*>(nullptr));
+    CORRADE_COMPARE(data.vertexData().data(), static_cast<const void*>(nullptr));
     if(instanceData.dataFlags & DataFlag::Mutable)
-        CORRADE_COMPARE(data.mutableVertexData(), static_cast<const void*>(nullptr));
+        CORRADE_COMPARE(data.mutableVertexData().data(), static_cast<const void*>(nullptr));
     CORRADE_COMPARE(data.importerState(), &importerState);
 
     CORRADE_VERIFY(data.isIndexed());
@@ -2835,7 +2835,7 @@ void MeshDataTest::constructAttributeOver4GB() {
 void MeshDataTest::constructIndexDataButNotIndexed() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
-    Containers::Array<char> indexData{6};
+    Containers::Array<char> indexData{ValueInit, 6};
     MeshAttributeData positions{MeshAttribute::Position, VertexFormat::Vector2, nullptr};
 
     Containers::String out;
@@ -2974,12 +2974,12 @@ void MeshDataTest::constructAttributeNotContained() {
         MeshAttributeData{MeshAttribute::Position, vertexDataIn}
     }};
     /* Offset-only attributes with a different message */
-    MeshData{MeshPrimitive::Triangles, Containers::Array<char>{24}, {
+    MeshData{MeshPrimitive::Triangles, Containers::Array<char>{NoInit, 24}, {
         MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, 1, 3, 8}
     }};
     /* This again spans 21 bytes if array size isn't taken into account, and 25
        if it is */
-    MeshData{MeshPrimitive::Triangles, Containers::Array<char>{24}, {
+    MeshData{MeshPrimitive::Triangles, Containers::Array<char>{NoInit, 24}, {
         MeshAttributeData{meshAttributeCustom(37), VertexFormat::UnsignedByte, 0, 5, 5, 5}
     }};
     /* An implementation-specific vertex format has a size assumed to be 0, but
@@ -2992,7 +2992,7 @@ void MeshDataTest::constructAttributeNotContained() {
     MeshData{MeshPrimitive::Triangles, {}, vertexData, {
         MeshAttributeData{MeshAttribute::Position, stridedArrayView(vertexDataSlightlyOut).flipped<0>()}
     }};
-    MeshData{MeshPrimitive::Triangles, Containers::Array<char>{24}, {
+    MeshData{MeshPrimitive::Triangles, Containers::Array<char>{NoInit, 24}, {
         MeshAttributeData{meshAttributeCustom(37), VertexFormat::UnsignedByte, 24, 3, -8}
     }};
     /* In this case the implementation-specific format is treated as having a
@@ -3022,7 +3022,7 @@ void MeshDataTest::constructAttributeNotContained() {
 void MeshDataTest::constructInconsitentVertexCount() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
-    Containers::Array<char> vertexData{136};
+    Containers::Array<char> vertexData{NoInit, 136};
     MeshAttributeData positions{MeshAttribute::Position,
         Containers::arrayCast<Vector2>(vertexData).prefix(3)};
     MeshAttributeData positions2{MeshAttribute::Position,
@@ -3131,7 +3131,7 @@ void MeshDataTest::constructIndicesNotOwnedFlagOwned() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
     UnsignedShort indexData[]{0, 1, 0};
-    Containers::Array<char> vertexData{2*sizeof(Vector2)};
+    Containers::Array<char> vertexData{NoInit, 2*sizeof(Vector2)};
     auto vertexView = Containers::arrayCast<Vector2>(vertexData);
     vertexView[0] = {0.1f, 0.2f};
     vertexView[1] = {0.4f, 0.5f};
@@ -3149,7 +3149,7 @@ void MeshDataTest::constructIndicesNotOwnedFlagOwned() {
 void MeshDataTest::constructVerticesNotOwnedFlagOwned() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
-    Containers::Array<char> indexData{3*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, 3*sizeof(UnsignedShort)};
     auto indexView = Containers::arrayCast<UnsignedShort>(indexData);
     Utility::copy({0, 1, 0}, indexView);
     Vector2 vertexData[]{{0.1f, 0.2f}, {0.4f, 0.5f}};
@@ -3213,11 +3213,11 @@ void MeshDataTest::constructCopy() {
 }
 
 void MeshDataTest::constructMove() {
-    Containers::Array<char> indexData{3*sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, 3*sizeof(UnsignedShort)};
     auto indices = Containers::arrayCast<UnsignedShort>(indexData);
     Utility::copy({0, 1, 0}, indices);
 
-    Containers::Array<char> vertexData{2*sizeof(Vector2)};
+    Containers::Array<char> vertexData{NoInit, 2*sizeof(Vector2)};
     auto vertices = Containers::arrayCast<Vector2>(vertexData);
     Utility::copy({
         {0.1f, 0.2f},
@@ -3237,8 +3237,8 @@ void MeshDataTest::constructMove() {
     CORRADE_COMPARE(b.indexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_COMPARE(b.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_COMPARE(b.primitive(), MeshPrimitive::Triangles);
-    CORRADE_COMPARE(static_cast<const void*>(b.indexData()), indices.data());
-    CORRADE_COMPARE(static_cast<const void*>(b.vertexData()), vertices.data());
+    CORRADE_COMPARE(static_cast<const void*>(b.indexData().data()), indices.data());
+    CORRADE_COMPARE(static_cast<const void*>(b.vertexData().data()), vertices.data());
     CORRADE_COMPARE(b.importerState(), &importerState);
 
     CORRADE_VERIFY(b.isIndexed());
@@ -3262,8 +3262,8 @@ void MeshDataTest::constructMove() {
     CORRADE_COMPARE(c.indexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_COMPARE(c.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_COMPARE(c.primitive(), MeshPrimitive::Triangles);
-    CORRADE_COMPARE(static_cast<const void*>(c.indexData()), indices.data());
-    CORRADE_COMPARE(static_cast<const void*>(c.vertexData()), vertices.data());
+    CORRADE_COMPARE(static_cast<const void*>(c.indexData().data()), indices.data());
+    CORRADE_COMPARE(static_cast<const void*>(c.vertexData().data()), vertices.data());
     CORRADE_COMPARE(c.importerState(), &importerState);
 
     CORRADE_VERIFY(c.isIndexed());
@@ -4470,7 +4470,7 @@ void MeshDataTest::indicesNotIndexed() {
 void MeshDataTest::indicesWrongType() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
-    Containers::Array<char> indexData{sizeof(UnsignedShort)};
+    Containers::Array<char> indexData{ValueInit, sizeof(UnsignedShort)};
     auto indices = Containers::arrayCast<UnsignedShort>(indexData);
     indices[0] = 57616;
     MeshData data{MeshPrimitive::Points, Utility::move(indexData), MeshIndexData{indices}, 57617};
@@ -4708,7 +4708,7 @@ void MeshDataTest::attributeWrongArrayAccess() {
 }
 
 void MeshDataTest::releaseIndexData() {
-    Containers::Array<char> indexData{23};
+    Containers::Array<char> indexData{ValueInit, 23};
     auto indices = Containers::arrayCast<UnsignedShort>(indexData.slice(6, 12));
 
     MeshData data{MeshPrimitive::TriangleStrip, Utility::move(indexData), MeshIndexData{indices}, 10};
@@ -4719,7 +4719,7 @@ void MeshDataTest::releaseIndexData() {
     Containers::Array<char> released = data.releaseIndexData();
     CORRADE_COMPARE(static_cast<void*>(released.data() + 6), indices.data());
     /* This is not null as we still need the value for calculating offsets */
-    CORRADE_COMPARE(static_cast<const void*>(data.indexData()), released.data());
+    CORRADE_COMPARE(static_cast<const void*>(data.indexData().data()), released.data());
     CORRADE_COMPARE(data.indexData().size(), 0);
     CORRADE_VERIFY(data.isIndexed());
     CORRADE_COMPARE(data.indexCount(), 0);
@@ -4728,7 +4728,7 @@ void MeshDataTest::releaseIndexData() {
 }
 
 void MeshDataTest::releaseAttributeData() {
-    Containers::Array<char> vertexData{16};
+    Containers::Array<char> vertexData{NoInit, 16};
     auto vertices = Containers::arrayCast<Vector2>(vertexData);
 
     MeshData data{MeshPrimitive::LineLoop, Utility::move(vertexData), {
@@ -4743,14 +4743,14 @@ void MeshDataTest::releaseAttributeData() {
     CORRADE_COMPARE(released[0].data().size(), 2);
     /* Unlike the other two, this is null as we don't need the value for
        calculating anything */
-    CORRADE_COMPARE(static_cast<const void*>(data.attributeData()), nullptr);
+    CORRADE_COMPARE(static_cast<const void*>(data.attributeData().data()), nullptr);
     CORRADE_COMPARE(data.attributeCount(), 0);
-    CORRADE_COMPARE(static_cast<const void*>(data.vertexData()), vertices);
+    CORRADE_COMPARE(static_cast<const void*>(data.vertexData().data()), vertices.data());
     CORRADE_COMPARE(data.vertexCount(), 2);
 }
 
 void MeshDataTest::releaseVertexData() {
-    Containers::Array<char> vertexData{80};
+    Containers::Array<char> vertexData{NoInit, 80};
     auto vertices = Containers::arrayCast<Vector2>(vertexData.slice(48, 72));
 
     MeshData data{MeshPrimitive::LineLoop, Utility::move(vertexData), {
@@ -4773,7 +4773,7 @@ void MeshDataTest::releaseVertexData() {
     CORRADE_COMPARE(data.attributeData()[0].data().size(), 3);
     CORRADE_COMPARE(static_cast<void*>(released.data() + 48), vertices.data());
     /* This is not null as we still need the value for calculating offsets */
-    CORRADE_COMPARE(static_cast<const void*>(data.vertexData()), released.data());
+    CORRADE_COMPARE(static_cast<const void*>(data.vertexData().data()), released.data());
     CORRADE_COMPARE(data.vertexCount(), 0);
     CORRADE_COMPARE(data.attributeOffset(0), 48);
 }

src/Magnum/Trade/Test/SceneDataTest.cpp

@@ -2523,8 +2523,8 @@ void SceneDataTest::construct() {
     /* Basics */
     CORRADE_COMPARE(scene.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_VERIFY(!scene.fieldData().isEmpty());
-    CORRADE_COMPARE(static_cast<const void*>(scene.data()), transformsParentFieldMappingData.data());
-    CORRADE_COMPARE(static_cast<void*>(scene.mutableData()), transformsParentFieldMappingData.data());
+    CORRADE_COMPARE(static_cast<const void*>(scene.data().data()), transformsParentFieldMappingData.data());
+    CORRADE_COMPARE(static_cast<void*>(scene.mutableData().data()), transformsParentFieldMappingData.data());
     CORRADE_COMPARE(scene.mappingBound(), 8);
     CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedShort);
     CORRADE_COMPARE(scene.fieldCount(), 4);
@@ -2778,8 +2778,8 @@ void SceneDataTest::constructZeroFields() {
     SceneData scene{SceneMappingType::UnsignedShort, 37563, nullptr, {}, &importerState};
     CORRADE_COMPARE(scene.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_VERIFY(scene.fieldData().isEmpty());
-    CORRADE_COMPARE(static_cast<const void*>(scene.data()), nullptr);
-    CORRADE_COMPARE(static_cast<void*>(scene.mutableData()), nullptr);
+    CORRADE_COMPARE(static_cast<const void*>(scene.data().data()), nullptr);
+    CORRADE_COMPARE(static_cast<void*>(scene.mutableData().data()), nullptr);
     CORRADE_COMPARE(scene.importerState(), &importerState);
     CORRADE_COMPARE(scene.mappingBound(), 37563);
     CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedShort);
@@ -2797,8 +2797,8 @@ void SceneDataTest::constructZeroObjects() {
     SceneData scene{SceneMappingType::UnsignedInt, 0, nullptr, {meshes, materials}, &importerState};
     CORRADE_COMPARE(scene.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_VERIFY(!scene.fieldData().isEmpty());
-    CORRADE_COMPARE(static_cast<const void*>(scene.data()), nullptr);
-    CORRADE_COMPARE(static_cast<void*>(scene.mutableData()), nullptr);
+    CORRADE_COMPARE(static_cast<const void*>(scene.data().data()), nullptr);
+    CORRADE_COMPARE(static_cast<void*>(scene.mutableData().data()), nullptr);
     CORRADE_COMPARE(scene.importerState(), &importerState);
     CORRADE_COMPARE(scene.mappingBound(), 0);
     CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedInt);
@@ -2834,9 +2834,9 @@ void SceneDataTest::constructNotOwned() {
     SceneData scene{SceneMappingType::UnsignedShort, 7, instanceData.dataFlags, Containers::arrayView(data), {mesh}, &importerState};
 
     CORRADE_COMPARE(scene.dataFlags(), instanceData.dataFlags);
-    CORRADE_COMPARE(static_cast<const void*>(scene.data()), +data);
+    CORRADE_COMPARE(static_cast<const void*>(scene.data().data()), +data);
     if(instanceData.dataFlags & DataFlag::Mutable)
-        CORRADE_COMPARE(static_cast<void*>(scene.mutableData()), static_cast<void*>(data));
+        CORRADE_COMPARE(static_cast<void*>(scene.mutableData().data()), static_cast<void*>(data));
     CORRADE_COMPARE(scene.mappingBound(), 7);
     CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedShort);
     CORRADE_COMPARE(scene.fieldCount(), 1);
@@ -3677,7 +3677,7 @@ void SceneDataTest::constructMappingDataNotContained() {
         SceneFieldData{SceneField::Mesh, dataOut, dataIn}
     }};
     /* Offset-only fields with a different message */
-    SceneData{SceneMappingType::UnsignedByte, 6, Containers::Array<char>{24}, {
+    SceneData{SceneMappingType::UnsignedByte, 6, Containers::Array<char>{NoInit, 24}, {
         SceneFieldData{SceneField::Mesh, 6, SceneMappingType::UnsignedByte, 4, 4, SceneFieldType::UnsignedByte, 0, 4}
     }};
     /* And the final boss, negative strides. Both only caught if the element
@@ -3685,7 +3685,7 @@ void SceneDataTest::constructMappingDataNotContained() {
     SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
         SceneFieldData{SceneField::Mesh, stridedArrayView(dataSlightlyOut).flipped<0>(), dataIn}
     }};
-    SceneData{SceneMappingType::UnsignedByte, 6, Containers::Array<char>{24}, {
+    SceneData{SceneMappingType::UnsignedByte, 6, Containers::Array<char>{NoInit, 24}, {
         SceneFieldData{SceneField::Mesh, 6, SceneMappingType::UnsignedByte, 24, -4, SceneFieldType::UnsignedByte, 0, 4}
     }};
     CORRADE_COMPARE(out,
@@ -3734,12 +3734,12 @@ void SceneDataTest::constructFieldDataNotContained() {
     /* Not checking for nullptr data, since that got checked for mapping view
        already and there's no way to trigger it for fields */
     /* Offset-only fields with a different message */
-    SceneData{SceneMappingType::UnsignedShort, 6, Containers::Array<char>{24}, {
+    SceneData{SceneMappingType::UnsignedShort, 6, Containers::Array<char>{NoInit, 24}, {
         SceneFieldData{SceneField::Mesh, 6, SceneMappingType::UnsignedShort, 0, 4, SceneFieldType::UnsignedByte, 4, 4}
     }};
     /* This again spans 21 bytes if array size isn't taken into account, and 25
        if it is */
-    SceneData{SceneMappingType::UnsignedShort, 5, Containers::Array<char>{24}, {
+    SceneData{SceneMappingType::UnsignedShort, 5, Containers::Array<char>{NoInit, 24}, {
         SceneFieldData{sceneFieldCustom(37), 5, SceneMappingType::UnsignedShort, 0, 5, SceneFieldType::UnsignedByte, 0, 5, 5}
     }};
     /* And the final boss, negative strides. Both only caught if the element
@@ -3747,7 +3747,7 @@ void SceneDataTest::constructFieldDataNotContained() {
     SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
         SceneFieldData{SceneField::Mesh, dataIn, stridedArrayView(dataSlightlyOut).flipped<0>()}
     }};
-    SceneData{SceneMappingType::UnsignedByte, 6, Containers::Array<char>{24}, {
+    SceneData{SceneMappingType::UnsignedByte, 6, Containers::Array<char>{NoInit, 24}, {
         SceneFieldData{SceneField::Mesh, 6, SceneMappingType::UnsignedByte, 0, 4, SceneFieldType::UnsignedByte, 24, -4}
     }};
     CORRADE_COMPARE(out,
@@ -3812,17 +3812,17 @@ void SceneDataTest::constructBitFieldDataNotContained() {
        already and there's no way to trigger it for fields */
     /* Offset-only fields with a different message, again both one byte and one
        bit off, one bit with offset */
-    SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{10}, {
+    SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{NoInit, 10}, {
         SceneFieldData{sceneFieldCustom(773), 10, SceneMappingType::UnsignedByte, 0, 1, 1, 0, 8}
     }};
-    SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{10}, {
+    SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{NoInit, 10}, {
         SceneFieldData{sceneFieldCustom(773), 10, SceneMappingType::UnsignedByte, 0, 1, 0, 0, 9}
     }};
-    SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{10}, {
+    SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{NoInit, 10}, {
         SceneFieldData{sceneFieldCustom(773), 5, SceneMappingType::UnsignedByte, 0, 1, 0, 4, 19}
     }};
     /* One with array */
-    SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{10}, {
+    SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{NoInit, 10}, {
         SceneFieldData{sceneFieldCustom(773), 9, SceneMappingType::UnsignedByte, 0, 1, 0, 0, 9, 9}
     }};
     /* And the final boss, negative strides -- one byte off and two bits off.
@@ -3834,10 +3834,10 @@ void SceneDataTest::constructBitFieldDataNotContained() {
     SceneData{SceneMappingType::UnsignedByte, 10, {}, data, {
         SceneFieldData{sceneFieldCustom(773), mappingData, dataTwoBitsOut.flipped<0>()}
     }};
-    SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{10}, {
+    SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{NoInit, 10}, {
         SceneFieldData{sceneFieldCustom(773), 10, SceneMappingType::UnsignedByte, 0, 1, 10, 0, -8}
     }};
-    SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{10}, {
+    SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{NoInit, 10}, {
         SceneFieldData{sceneFieldCustom(773), 9, SceneMappingType::UnsignedByte, 0, 1, 10, 0, -9}
     }};
     CORRADE_COMPARE(out,
@@ -4221,7 +4221,7 @@ void SceneDataTest::constructMove() {
     CORRADE_COMPARE(b.mappingType(), SceneMappingType::UnsignedShort);
     CORRADE_COMPARE(b.fieldCount(), 1);
     CORRADE_COMPARE(b.importerState(), &importerState);
-    CORRADE_COMPARE(static_cast<const void*>(b.data()), meshData.data());
+    CORRADE_COMPARE(static_cast<const void*>(b.data().data()), meshData.data());
     CORRADE_COMPARE(b.fieldName(0), SceneField::Mesh);
     CORRADE_COMPARE(b.fieldType(0), SceneFieldType::UnsignedInt);
     CORRADE_COMPARE(b.fieldSize(0), 3);
@@ -4236,7 +4236,7 @@ void SceneDataTest::constructMove() {
     CORRADE_COMPARE(c.mappingType(), SceneMappingType::UnsignedShort);
     CORRADE_COMPARE(c.fieldCount(), 1);
     CORRADE_COMPARE(c.importerState(), &importerState);
-    CORRADE_COMPARE(static_cast<const void*>(c.data()), meshData.data());
+    CORRADE_COMPARE(static_cast<const void*>(c.data().data()), meshData.data());
     CORRADE_COMPARE(c.fieldName(0), SceneField::Mesh);
     CORRADE_COMPARE(c.fieldType(0), SceneFieldType::UnsignedInt);
     CORRADE_COMPARE(c.fieldSize(0), 3);
@@ -4462,7 +4462,7 @@ void SceneDataTest::mappingIntoArrayByIndex() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> out{data.size};
+        Containers::Array<UnsignedInt> out{NoInit, data.size};
         CORRADE_COMPARE(scene.mappingInto(1, data.offset, out), data.expectedSize);
         CORRADE_COMPARE_AS(out.prefix(data.expectedSize),
             view.slice(&Field::object)
@@ -4508,7 +4508,7 @@ void SceneDataTest::mappingIntoArrayByName() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> out{data.size};
+        Containers::Array<UnsignedInt> out{NoInit, data.size};
         CORRADE_COMPARE(scene.mappingInto(SceneField::Mesh, data.offset, out), data.expectedSize);
         CORRADE_COMPARE_AS(out.prefix(data.expectedSize),
             view.slice(&Field::object)
@@ -4616,8 +4616,8 @@ void SceneDataTest::parentsIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> mapping{data.size};
-        Containers::Array<Int> field{data.size};
+        Containers::Array<UnsignedInt> mapping{NoInit, data.size};
+        Containers::Array<Int> field{NoInit, data.size};
         CORRADE_COMPARE(scene.parentsInto(data.offset,
             data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
@@ -5006,8 +5006,8 @@ void SceneDataTest::transformations2DIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> mapping{data.size};
-        Containers::Array<Matrix3> field{data.size};
+        Containers::Array<UnsignedInt> mapping{NoInit, data.size};
+        Containers::Array<Matrix3> field{NoInit, data.size};
         CORRADE_COMPARE(scene.transformations2DInto(data.offset,
             data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
@@ -5080,8 +5080,8 @@ void SceneDataTest::transformations2DTRSIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> mapping{data.size};
-        Containers::Array<Matrix3> field{data.size};
+        Containers::Array<UnsignedInt> mapping{NoInit, data.size};
+        Containers::Array<Matrix3> field{NoInit, data.size};
         CORRADE_COMPARE(scene.transformations2DInto(data.offset,
             data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
@@ -5158,10 +5158,10 @@ void SceneDataTest::transformations2DIntoArrayTRS() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> mapping{data.size};
-        Containers::Array<Vector2> translations{data.size};
-        Containers::Array<Complex> rotations{data.size};
-        Containers::Array<Vector2> scalings{data.size};
+        Containers::Array<UnsignedInt> mapping{NoInit, data.size};
+        Containers::Array<Vector2> translations{NoInit, data.size};
+        Containers::Array<Complex> rotations{NoInit, data.size};
+        Containers::Array<Vector2> scalings{NoInit, data.size};
         CORRADE_COMPARE(scene.translationsRotationsScalings2DInto(data.offset,
             data.mapping ? arrayView(mapping) : nullptr,
             data.field1 ? arrayView(translations) : nullptr,
@@ -5602,8 +5602,8 @@ void SceneDataTest::transformations3DIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> mapping{data.size};
-        Containers::Array<Matrix4> field{data.size};
+        Containers::Array<UnsignedInt> mapping{NoInit, data.size};
+        Containers::Array<Matrix4> field{NoInit, data.size};
         CORRADE_COMPARE(scene.transformations3DInto(data.offset,
             data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
@@ -5676,8 +5676,8 @@ void SceneDataTest::transformations3DTRSIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> mapping{data.size};
-        Containers::Array<Matrix4> field{data.size};
+        Containers::Array<UnsignedInt> mapping{NoInit, data.size};
+        Containers::Array<Matrix4> field{NoInit, data.size};
         CORRADE_COMPARE(scene.transformations3DInto(data.offset,
             data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
@@ -5754,10 +5754,10 @@ void SceneDataTest::transformations3DIntoArrayTRS() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> mapping{data.size};
-        Containers::Array<Vector3> translations{data.size};
-        Containers::Array<Quaternion> rotations{data.size};
-        Containers::Array<Vector3> scalings{data.size};
+        Containers::Array<UnsignedInt> mapping{NoInit, data.size};
+        Containers::Array<Vector3> translations{NoInit, data.size};
+        Containers::Array<Quaternion> rotations{NoInit, data.size};
+        Containers::Array<Vector3> scalings{NoInit, data.size};
         CORRADE_COMPARE(scene.translationsRotationsScalings3DInto(data.offset,
             data.mapping ? arrayView(mapping) : nullptr,
             data.field1 ? arrayView(translations) : nullptr,
@@ -5967,9 +5967,9 @@ void SceneDataTest::meshesMaterialsIntoArray() {
 
     /* The offset variant should give back only a subset */
     } {
-        Containers::Array<UnsignedInt> mapping{data.size};
-        Containers::Array<UnsignedInt> meshes{data.size};
-        Containers::Array<Int> meshMaterials{data.size};
+        Containers::Array<UnsignedInt> mapping{NoInit, data.size};
+        Containers::Array<UnsignedInt> meshes{NoInit, data.size};
+        Containers::Array<Int> meshMaterials{NoInit, data.size};
         CORRADE_COMPARE(scene.meshesMaterialsInto(data.offset,
             data.mapping ? arrayView(mapping) : nullptr,
             data.field1 ? arrayView(meshes) : nullptr,
@@ -6100,8 +6100,8 @@ void SceneDataTest::lightsIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> mapping{data.size};
-        Containers::Array<UnsignedInt> field{data.size};
+        Containers::Array<UnsignedInt> mapping{NoInit, data.size};
+        Containers::Array<UnsignedInt> field{NoInit, data.size};
         CORRADE_COMPARE(scene.lightsInto(data.offset,
             data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
@@ -6219,8 +6219,8 @@ void SceneDataTest::camerasIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> mapping{data.size};
-        Containers::Array<UnsignedInt> field{data.size};
+        Containers::Array<UnsignedInt> mapping{NoInit, data.size};
+        Containers::Array<UnsignedInt> field{NoInit, data.size};
         CORRADE_COMPARE(scene.camerasInto(data.offset,
             data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
@@ -6342,8 +6342,8 @@ void SceneDataTest::skinsIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> mapping{data.size};
-        Containers::Array<UnsignedInt> field{data.size};
+        Containers::Array<UnsignedInt> mapping{NoInit, data.size};
+        Containers::Array<UnsignedInt> field{NoInit, data.size};
         CORRADE_COMPARE(scene.skinsInto(data.offset,
             data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
@@ -6468,8 +6468,8 @@ void SceneDataTest::importerStateIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> mapping{data.size};
-        Containers::Array<const void*> field{data.size};
+        Containers::Array<UnsignedInt> mapping{NoInit, data.size};
+        Containers::Array<const void*> field{NoInit, data.size};
         CORRADE_COMPARE(scene.importerStateInto(data.offset,
             data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
@@ -7641,7 +7641,7 @@ void SceneDataTest::releaseFieldData() {
         SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
     });
-    SceneFieldData* originalFields = fields;
+    SceneFieldData* originalFields = fields.data();
 
     SceneData scene{SceneMappingType::UnsignedByte, 50, Utility::move(data), Utility::move(fields)};
 
@@ -7650,7 +7650,7 @@ void SceneDataTest::releaseFieldData() {
     CORRADE_COMPARE(released.size(), 2);
 
     /* Fields are all gone */
-    CORRADE_COMPARE(static_cast<const void*>(scene.fieldData()), nullptr);
+    CORRADE_COMPARE(static_cast<const void*>(scene.fieldData().data()), nullptr);
     CORRADE_COMPARE(scene.fieldCount(), 0);
 
     /* Data stays untouched, object count and type as well, as it con't result
@@ -7679,7 +7679,7 @@ void SceneDataTest::releaseData() {
     CORRADE_COMPARE(released.size(), 3*sizeof(Field));
 
     /* Data are gone */
-    CORRADE_COMPARE(static_cast<const void*>(scene.data()), nullptr);
+    CORRADE_COMPARE(static_cast<const void*>(scene.data().data()), nullptr);
 
     /* Fields stay untouched so it's possible to release them separately
        without being forced to order these two releases in any way */

src/Magnum/Trade/Test/SkinDataTest.cpp

@@ -130,8 +130,8 @@ void SkinDataTest::release() {
         Matrix3::translation(Vector2::yAxis(4.0f))
     }};
 
-    const void* jointsPointer = joints;
-    const void* inverseBindMatricesPointer = inverseBindMatrices;
+    const void* jointsPointer = joints.data();
+    const void* inverseBindMatricesPointer = inverseBindMatrices.data();
 
     SkinData2D data{Utility::move(joints), Utility::move(inverseBindMatrices)};
 
@@ -139,13 +139,13 @@ void SkinDataTest::release() {
     CORRADE_COMPARE(data.joints().size(), 0);
     CORRADE_COMPARE(data.inverseBindMatrices().size(), 3);
     CORRADE_COMPARE(releasedJoints.size(), 3);
-    CORRADE_COMPARE(releasedJoints, jointsPointer);
+    CORRADE_COMPARE(releasedJoints.data(), jointsPointer);
 
     Containers::Array<Matrix3> releasedInverseBindMatrices = data.releaseInverseBindMatrixData();
     CORRADE_COMPARE(data.joints().size(), 0);
     CORRADE_COMPARE(data.inverseBindMatrices().size(), 0);
     CORRADE_COMPARE(releasedInverseBindMatrices.size(), 3);
-    CORRADE_COMPARE(releasedInverseBindMatrices, inverseBindMatricesPointer);
+    CORRADE_COMPARE(releasedInverseBindMatrices.data(), inverseBindMatricesPointer);
 }
 
 }}}}

src/Magnum/Vk/Buffer.cpp

@@ -222,11 +222,11 @@ CopyBufferInfo::CopyBufferInfo(const VkBuffer source, const VkBuffer destination
     for(std::size_t i = 0; i != regions.size(); ++i) {
         /* Can't use {} with GCC 4.8 here because it tries to initialize the
            first member instead of doing a copy */
-        new(vkBufferCopies2 + i) VkBufferCopy2KHR(BufferCopy{regions[i]});
+        new(vkBufferCopies2.data() + i) VkBufferCopy2KHR(BufferCopy{regions[i]});
     }
 
     _info.regionCount = regions.size();
-    _info.pRegions = vkBufferCopies2;
+    _info.pRegions = vkBufferCopies2.data();
 }
 
 CopyBufferInfo::CopyBufferInfo(const VkBuffer source, const VkBuffer destination, const std::initializer_list<BufferCopy> regions): CopyBufferInfo{source, destination, Containers::arrayView(regions)} {}
@@ -241,7 +241,7 @@ CopyBufferInfo::CopyBufferInfo(const VkCopyBufferInfo2KHR& info):
 Containers::Array<VkBufferCopy> CopyBufferInfo::vkBufferCopies() const {
     Containers::Array<VkBufferCopy> out{NoInit, _info.regionCount};
     for(std::size_t i = 0; i != _info.regionCount; ++i)
-        new(out + i) VkBufferCopy(vkBufferCopy(_info.pRegions[i]));
+        new(out.data() + i) VkBufferCopy(vkBufferCopy(_info.pRegions[i]));
     return out;
 }
 
@@ -258,7 +258,7 @@ CommandBuffer& CommandBuffer::copyBuffer(const CopyBufferInfo& info) {
 void CommandBuffer::copyBufferImplementationDefault(CommandBuffer& self, const CopyBufferInfo& info) {
     CORRADE_ASSERT(!info->pNext,
         "Vk::CommandBuffer::copyBuffer(): disallowing extraction of CopyBufferInfo with non-empty pNext to prevent information loss", );
-    return (**self._device).CmdCopyBuffer(self, info->srcBuffer, info->dstBuffer, info->regionCount, info.vkBufferCopies());
+    return (**self._device).CmdCopyBuffer(self, info->srcBuffer, info->dstBuffer, info->regionCount, info.vkBufferCopies().data());
 }
 
 void CommandBuffer::copyBufferImplementationKHR(CommandBuffer& self, const CopyBufferInfo& info) {

src/Magnum/Vk/DescriptorPool.cpp

@@ -63,7 +63,7 @@ DescriptorPoolCreateInfo::DescriptorPoolCreateInfo(const UnsignedInt maxSets, co
     _info.flags = VkDescriptorPoolCreateFlags(flags);
     _info.maxSets = maxSets;
     _info.poolSizeCount = poolSizesCopy.size();
-    _info.pPoolSizes = poolSizesCopy;
+    _info.pPoolSizes = poolSizesCopy.data();
 }
 
 DescriptorPoolCreateInfo::DescriptorPoolCreateInfo(const UnsignedInt maxSets, const std::initializer_list<Containers::Pair<DescriptorType, UnsignedInt>> poolSizes, const Flags flags): DescriptorPoolCreateInfo{maxSets, Containers::arrayView(poolSizes), flags} {}

src/Magnum/Vk/DescriptorSetLayout.cpp

@@ -55,7 +55,7 @@ DescriptorSetLayoutBinding::DescriptorSetLayoutBinding(const UnsignedInt binding
     _binding.binding = binding;
     _binding.descriptorType = VkDescriptorType(descriptorType);
     _binding.descriptorCount = immutableSamplers.size();
-    _binding.pImmutableSamplers = immutableSamplersCopy;
+    _binding.pImmutableSamplers = immutableSamplersCopy.data();
     _binding.stageFlags = VkShaderStageFlags(stages);
 }
 
@@ -131,7 +131,7 @@ DescriptorSetLayoutCreateInfo::DescriptorSetLayoutCreateInfo(const Containers::I
                    for some reason */
                 Containers::arrayView(b->pImmutableSamplers, b->descriptorCount),
                 immutableSamplersCopy.slice(immutableSamplerOffset, immutableSamplerOffset + b->descriptorCount));
-            bindingsCopy[i].pImmutableSamplers = immutableSamplersCopy + immutableSamplerOffset;
+            bindingsCopy[i].pImmutableSamplers = immutableSamplersCopy.data() + immutableSamplerOffset;
             immutableSamplerOffset += b->descriptorCount;
         }
         if(hasBindingFlags)
@@ -142,12 +142,12 @@ DescriptorSetLayoutCreateInfo::DescriptorSetLayoutCreateInfo(const Containers::I
     _info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
     _info.flags = VkDescriptorSetLayoutCreateFlags(flags);
     _info.bindingCount = bindings.size();
-    _info.pBindings = bindingsCopy;
+    _info.pBindings = bindingsCopy.data();
     if(hasBindingFlags) {
         bindingsCreateInfoView[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
         bindingsCreateInfoView[0].bindingCount = bindings.size();
-        bindingsCreateInfoView[0].pBindingFlags = bindingFlagsCopy;
-        _info.pNext = bindingsCreateInfoView;
+        bindingsCreateInfoView[0].pBindingFlags = bindingFlagsCopy.data();
+        _info.pNext = bindingsCreateInfoView.data();
     }
 }
 

src/Magnum/Vk/Device.cpp

@@ -589,7 +589,7 @@ DeviceCreateInfo& DeviceCreateInfo::addQueues(const UnsignedInt family, const Co
     info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
     info.queueFamilyIndex = family;
     info.queueCount = priorities.size();
-    info.pQueuePriorities = _state->queuePriorities + _state->nextQueuePriority;
+    info.pQueuePriorities = _state->queuePriorities.data() + _state->nextQueuePriority;
 
     /* Copy the passed queue priorities and output queue references to an
        internal storage that never reallocates. If this blows up, see the
@@ -643,7 +643,7 @@ DeviceCreateInfo& DeviceCreateInfo::addQueues(const VkDeviceQueueCreateInfo& inf
        This handles a potential reallocation and also the case of replacing the
        default queue on the first call to addQueues(). */
     arrayAppend(_state->queues, info);
-    _info.pQueueCreateInfos = _state->queues;
+    _info.pQueueCreateInfos = _state->queues.data();
     _info.queueCreateInfoCount = _state->queues.size();
 
     return *this;

src/Magnum/Vk/DeviceProperties.cpp

@@ -392,7 +392,7 @@ Containers::ArrayView<const VkQueueFamilyProperties2> DeviceProperties::queueFam
         _state->queueFamilyProperties = Containers::Array<VkQueueFamilyProperties2>{ValueInit, count};
         for(VkQueueFamilyProperties2& i: _state->queueFamilyProperties)
             i.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
-        _state->getQueueFamilyPropertiesImplementation(*this, count, _state->queueFamilyProperties);
+        _state->getQueueFamilyPropertiesImplementation(*this, count, _state->queueFamilyProperties.data());
         CORRADE_INTERNAL_ASSERT(count == _state->queueFamilyProperties.size());
     }
 

src/Magnum/Vk/ExtensionProperties.cpp

@@ -76,7 +76,7 @@ ExtensionProperties::ExtensionProperties(const Containers::StringIterable& layer
         MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(enumerator(state,
             i == 0 ? nullptr :
                 Containers::String::nullTerminatedView(layers[i - 1]).data(),
-            &count, _extensions + offset));
+            &count, _extensions.data() + offset));
         for(std::size_t j = 0; j != count; ++j) _extensionLayers[offset + j] = i;
         offset += count;
     }
@@ -99,8 +99,8 @@ ExtensionProperties::ExtensionProperties(const Containers::StringIterable& layer
        costly enumeration. */
     if(offset < totalCount) {
         Warning{} << "Vk::ExtensionProperties: inconsistent extension count reported by the driver, expected" << totalCount << "but got only" << offset;
-        _names = {_names, offset};
-        _extensionLayers = {_extensionLayers, offset};
+        _names = {_names.data(), offset};
+        _extensionLayers = {_extensionLayers.data(), offset};
     } else CORRADE_INTERNAL_ASSERT(offset == totalCount);
 
     /* Populate the views, sort them and remove duplicates so we can search in

src/Magnum/Vk/Framebuffer.cpp

@@ -57,7 +57,7 @@ FramebufferCreateInfo::FramebufferCreateInfo(const VkRenderPass renderPass, cons
     for(std::size_t i = 0; i != attachments.size(); ++i)
         _state->attachments[i] = *attachments[i];
     _info.attachmentCount = _state->attachments.size();
-    _info.pAttachments = _state->attachments;
+    _info.pAttachments = _state->attachments.data();
 }
 
 FramebufferCreateInfo::FramebufferCreateInfo(const VkRenderPass renderPass, const std::initializer_list<Containers::Reference<ImageView>> attachments, const Vector3i& size, const Flags flags): FramebufferCreateInfo{renderPass, Containers::arrayView(attachments), size, flags} {}

src/Magnum/Vk/Image.cpp

@@ -310,11 +310,11 @@ CopyImageInfo::CopyImageInfo(const VkImage source, const ImageLayout sourceLayou
     for(std::size_t i = 0; i != regions.size(); ++i) {
         /* Can't use {} with GCC 4.8 here because it tries to initialize the
            first member instead of doing a copy */
-        new(vkImageCopies2 + i) VkImageCopy2KHR(ImageCopy{regions[i]});
+        new(vkImageCopies2.data() + i) VkImageCopy2KHR(ImageCopy{regions[i]});
     }
 
     _info.regionCount = regions.size();
-    _info.pRegions = vkImageCopies2;
+    _info.pRegions = vkImageCopies2.data();
 }
 
 CopyImageInfo::CopyImageInfo(const VkImage source, const ImageLayout sourceLayout, const VkImage destination, const ImageLayout destinationLayout, const std::initializer_list<ImageCopy> regions): CopyImageInfo{source, sourceLayout, destination, destinationLayout, Containers::arrayView(regions)} {}
@@ -329,7 +329,7 @@ CopyImageInfo::CopyImageInfo(const VkCopyImageInfo2KHR& info):
 Containers::Array<VkImageCopy> CopyImageInfo::vkImageCopies() const {
     Containers::Array<VkImageCopy> out{NoInit, _info.regionCount};
     for(std::size_t i = 0; i != _info.regionCount; ++i)
-        new(out + i) VkImageCopy(vkImageCopy(_info.pRegions[i]));
+        new(out.data() + i) VkImageCopy(vkImageCopy(_info.pRegions[i]));
     return out;
 }
 
@@ -419,14 +419,14 @@ CopyBufferToImageInfo::CopyBufferToImageInfo(const VkBuffer source, const VkImag
     };
 
     for(std::size_t i = 0; i != regions.size(); ++i) {
-        new(wrappers + i) BufferImageCopy{regions[i]};
+        new(wrappers.data() + i) BufferImageCopy{regions[i]};
         /* Can't use {} with GCC 4.8 here because it tries to initialize the
            first member instead of doing a copy */
-        new(vkBufferImageCopies2 + i) VkBufferImageCopy2KHR(wrappers[i]);
+        new(vkBufferImageCopies2.data() + i) VkBufferImageCopy2KHR(wrappers[i]);
     }
 
     _info.regionCount = regions.size();
-    _info.pRegions = vkBufferImageCopies2;
+    _info.pRegions = vkBufferImageCopies2.data();
 }
 
 CopyBufferToImageInfo::CopyBufferToImageInfo(NoInitT) noexcept {}
@@ -441,7 +441,7 @@ CopyBufferToImageInfo::CopyBufferToImageInfo(const VkBuffer source, const VkImag
 Containers::Array<VkBufferImageCopy> CopyBufferToImageInfo::vkBufferImageCopies() const {
     Containers::Array<VkBufferImageCopy> out{NoInit, _info.regionCount};
     for(std::size_t i = 0; i != _info.regionCount; ++i)
-        new(out + i) VkBufferImageCopy(vkBufferImageCopy(_info.pRegions[i]));
+        new(out.data() + i) VkBufferImageCopy(vkBufferImageCopy(_info.pRegions[i]));
     return out;
 }
 
@@ -491,14 +491,14 @@ CopyImageToBufferInfo::CopyImageToBufferInfo(const VkImage source, const ImageLa
     };
 
     for(std::size_t i = 0; i != regions.size(); ++i) {
-        new(wrappers + i) BufferImageCopy{regions[i]};
+        new(wrappers.data() + i) BufferImageCopy{regions[i]};
         /* Can't use {} with GCC 4.8 here because it tries to initialize the
            first member instead of doing a copy */
-        new(vkBufferImageCopies2 + i) VkBufferImageCopy2KHR(wrappers[i]);
+        new(vkBufferImageCopies2.data() + i) VkBufferImageCopy2KHR(wrappers[i]);
     }
 
     _info.regionCount = regions.size();
-    _info.pRegions = vkBufferImageCopies2;
+    _info.pRegions = vkBufferImageCopies2.data();
 }
 
 CopyImageToBufferInfo::CopyImageToBufferInfo(const VkImage source, const ImageLayout sourceLayout, const VkBuffer destination, const std::initializer_list<BufferImageCopy> regions): CopyImageToBufferInfo{source, sourceLayout, destination, Containers::arrayView(regions)} {}
@@ -513,7 +513,7 @@ CopyImageToBufferInfo::CopyImageToBufferInfo(const VkCopyImageToBufferInfo2KHR&
 Containers::Array<VkBufferImageCopy> CopyImageToBufferInfo::vkBufferImageCopies() const {
     Containers::Array<VkBufferImageCopy> out{NoInit, _info.regionCount};
     for(std::size_t i = 0; i != _info.regionCount; ++i)
-        new(out + i) VkBufferImageCopy(vkBufferImageCopy(_info.pRegions[i]));
+        new(out.data() + i) VkBufferImageCopy(vkBufferImageCopy(_info.pRegions[i]));
     return out;
 }
 
@@ -668,7 +668,7 @@ void fixupImageCopySwiftShader(VkImageSubresourceLayers& subresource, VkOffset3D
 void CommandBuffer::copyImageImplementationDefault(CommandBuffer& self, const CopyImageInfo& info) {
     CORRADE_ASSERT(!info->pNext,
         "Vk::CommandBuffer::copyImage(): disallowing extraction of CopyImageInfo with non-empty pNext to prevent information loss", );
-    return (**self._device).CmdCopyImage(self, info->srcImage, info->srcImageLayout, info->dstImage, info->dstImageLayout, info->regionCount, info.vkImageCopies());
+    return (**self._device).CmdCopyImage(self, info->srcImage, info->srcImageLayout, info->dstImage, info->dstImageLayout, info->regionCount, info.vkImageCopies().data());
 }
 
 void CommandBuffer::copyImageImplementationSwiftShader(CommandBuffer& self, const CopyImageInfo& info) {
@@ -681,7 +681,7 @@ void CommandBuffer::copyImageImplementationSwiftShader(CommandBuffer& self, cons
         fixupImageCopySwiftShader(copy.dstSubresource, copy.dstOffset, copy.extent);
     }
 
-    return (**self._device).CmdCopyImage(self, info->srcImage, info->srcImageLayout, info->dstImage, info->dstImageLayout, info->regionCount, copies);
+    return (**self._device).CmdCopyImage(self, info->srcImage, info->srcImageLayout, info->dstImage, info->dstImageLayout, info->regionCount, copies.data());
 }
 
 void CommandBuffer::copyImageImplementationKHR(CommandBuffer& self, const CopyImageInfo& info) {
@@ -696,7 +696,7 @@ CommandBuffer& CommandBuffer::copyBufferToImage(const CopyBufferToImageInfo& inf
 void CommandBuffer::copyBufferToImageImplementationDefault(CommandBuffer& self, const CopyBufferToImageInfo& info) {
     CORRADE_ASSERT(!info->pNext,
         "Vk::CommandBuffer::copyBufferToImage(): disallowing extraction of CopyBufferToImageInfo with non-empty pNext to prevent information loss", );
-    return (**self._device).CmdCopyBufferToImage(self, info->srcBuffer, info->dstImage, info->dstImageLayout, info->regionCount, info.vkBufferImageCopies());
+    return (**self._device).CmdCopyBufferToImage(self, info->srcBuffer, info->dstImage, info->dstImageLayout, info->regionCount, info.vkBufferImageCopies().data());
 }
 
 void CommandBuffer::copyBufferToImageImplementationSwiftShader(CommandBuffer& self, const CopyBufferToImageInfo& info) {
@@ -708,7 +708,7 @@ void CommandBuffer::copyBufferToImageImplementationSwiftShader(CommandBuffer& se
         fixupImageCopySwiftShader(copy.imageSubresource, copy.imageOffset, copy.imageExtent);
     }
 
-    return (**self._device).CmdCopyBufferToImage(self, info->srcBuffer, info->dstImage, info->dstImageLayout, info->regionCount, copies);
+    return (**self._device).CmdCopyBufferToImage(self, info->srcBuffer, info->dstImage, info->dstImageLayout, info->regionCount, copies.data());
 }
 
 void CommandBuffer::copyBufferToImageImplementationKHR(CommandBuffer& self, const CopyBufferToImageInfo& info) {
@@ -723,7 +723,7 @@ CommandBuffer& CommandBuffer::copyImageToBuffer(const CopyImageToBufferInfo& inf
 void CommandBuffer::copyImageToBufferImplementationDefault(CommandBuffer& self, const CopyImageToBufferInfo& info) {
     CORRADE_ASSERT(!info->pNext,
         "Vk::CommandBuffer::copyImageToBuffer(): disallowing extraction of CopyImageToBufferInfo with non-empty pNext to prevent information loss", );
-    return (**self._device).CmdCopyImageToBuffer(self, info->srcImage, info->srcImageLayout, info->dstBuffer, info->regionCount, info.vkBufferImageCopies());
+    return (**self._device).CmdCopyImageToBuffer(self, info->srcImage, info->srcImageLayout, info->dstBuffer, info->regionCount, info.vkBufferImageCopies().data());
 }
 
 void CommandBuffer::copyImageToBufferImplementationSwiftShader(CommandBuffer& self, const CopyImageToBufferInfo& info) {
@@ -735,7 +735,7 @@ void CommandBuffer::copyImageToBufferImplementationSwiftShader(CommandBuffer& se
         fixupImageCopySwiftShader(copy.imageSubresource, copy.imageOffset, copy.imageExtent);
     }
 
-    return (**self._device).CmdCopyImageToBuffer(self, info->srcImage, info->srcImageLayout, info->dstBuffer, info->regionCount, copies);
+    return (**self._device).CmdCopyImageToBuffer(self, info->srcImage, info->srcImageLayout, info->dstBuffer, info->regionCount, copies.data());
 }
 
 void CommandBuffer::copyImageToBufferImplementationKHR(CommandBuffer& self, const CopyImageToBufferInfo& info) {

src/Magnum/Vk/Mesh.cpp

@@ -221,10 +221,10 @@ CommandBuffer& CommandBuffer::draw(Mesh& mesh) {
         /** @todo don't call this for each binding, detect ranges */
         _device->state().cmdBindVertexBuffersImplementation(*this,
             bindings[i].binding, 1,
-            mesh.vertexBuffers() + i,
-            mesh.vertexBufferOffsets() + i,
+            mesh.vertexBuffers().data() + i,
+            mesh.vertexBufferOffsets().data() + i,
             _dynamicRasterizationStates & DynamicRasterizationState::VertexInputBindingStride ?
-                mesh.vertexBufferStrides() + i : nullptr
+                mesh.vertexBufferStrides().data() + i : nullptr
         );
     }
 

src/Magnum/Vk/MeshLayout.cpp

@@ -136,12 +136,12 @@ bool MeshLayout::hasNoExternalPointers() const {
 
         /* Vertex binding descriptions should point to our data, if any,
            otherwise it should be null and the count zero */
-        ((!_vertexInfo.vertexBindingDescriptionCount && !_vertexInfo.pVertexBindingDescriptions) || (_state && _vertexInfo.pVertexBindingDescriptions == _state->bindings)) &&
+        ((!_vertexInfo.vertexBindingDescriptionCount && !_vertexInfo.pVertexBindingDescriptions) || (_state && _vertexInfo.pVertexBindingDescriptions == _state->bindings.data())) &&
         /* Attribute descriptions should point to our data, if any,
            otherwise it should be null and the count zero */
-        ((!_vertexInfo.vertexAttributeDescriptionCount && !_vertexInfo.pVertexAttributeDescriptions) || (_state && _vertexInfo.pVertexAttributeDescriptions == _state->attributes)) &&
+        ((!_vertexInfo.vertexAttributeDescriptionCount && !_vertexInfo.pVertexAttributeDescriptions) || (_state && _vertexInfo.pVertexAttributeDescriptions == _state->attributes.data())) &&
         /* Vertex divisor descriptions should point to our data, if any */
-        (!_state || _state->vertexDivisorInfo.pVertexBindingDivisors == _state->bindingDivisors);
+        (!_state || _state->vertexDivisorInfo.pVertexBindingDivisors == _state->bindingDivisors.data());
 }
 #endif
 
@@ -169,9 +169,9 @@ bool MeshLayout::operator==(const MeshLayout& other) const {
            enforce), otherwise this wouldn't be enough */
         /** @todo use Utility::equal() once it exists, this is way too
             error-prone */
-        std::memcmp(other._state->bindings, _state->bindings, _vertexInfo.vertexBindingDescriptionCount*sizeof(decltype(_state->bindings)::Type)) == 0 &&
-        std::memcmp(other._state->bindingDivisors, _state->bindingDivisors, _state->vertexDivisorInfo.vertexBindingDivisorCount*sizeof(decltype(_state->bindingDivisors)::Type)) == 0 &&
-        std::memcmp(other._state->attributes, _state->attributes, _vertexInfo.vertexAttributeDescriptionCount*sizeof(decltype(_state->attributes)::Type)) == 0;
+        std::memcmp(other._state->bindings.data(), _state->bindings.data(), _vertexInfo.vertexBindingDescriptionCount*sizeof(decltype(_state->bindings)::Type)) == 0 &&
+        std::memcmp(other._state->bindingDivisors.data(), _state->bindingDivisors.data(), _state->vertexDivisorInfo.vertexBindingDivisorCount*sizeof(decltype(_state->bindingDivisors)::Type)) == 0 &&
+        std::memcmp(other._state->attributes.data(), _state->attributes.data(), _vertexInfo.vertexAttributeDescriptionCount*sizeof(decltype(_state->attributes)::Type)) == 0;
     #undef _c
 }
 
@@ -189,7 +189,7 @@ MeshLayout& MeshLayout::addBinding(const UnsignedInt binding, const UnsignedInt
     description.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
     arrayAppend(_state->bindings, description);
     _vertexInfo.vertexBindingDescriptionCount = _state->bindings.size();
-    _vertexInfo.pVertexBindingDescriptions = _state->bindings;
+    _vertexInfo.pVertexBindingDescriptions = _state->bindings.data();
 
     return *this;
 }
@@ -212,7 +212,7 @@ MeshLayout& MeshLayout::addInstancedBinding(const UnsignedInt binding, const Uns
     description.inputRate = VK_VERTEX_INPUT_RATE_INSTANCE;
     arrayAppend(_state->bindings, description);
     _vertexInfo.vertexBindingDescriptionCount = _state->bindings.size();
-    _vertexInfo.pVertexBindingDescriptions = _state->bindings;
+    _vertexInfo.pVertexBindingDescriptions = _state->bindings.data();
 
     if(divisor != 1) {
         VkVertexInputBindingDivisorDescriptionEXT divisorDescription{};
@@ -220,7 +220,7 @@ MeshLayout& MeshLayout::addInstancedBinding(const UnsignedInt binding, const Uns
         divisorDescription.divisor = divisor;
         arrayAppend(_state->bindingDivisors, divisorDescription);
         _state->vertexDivisorInfo.vertexBindingDivisorCount = _state->bindingDivisors.size();
-        _state->vertexDivisorInfo.pVertexBindingDivisors = _state->bindingDivisors;
+        _state->vertexDivisorInfo.pVertexBindingDivisors = _state->bindingDivisors.data();
 
         /* Attach the structure if not already */
         if(!_state->vertexDivisorInfo.sType)
@@ -249,7 +249,7 @@ MeshLayout& MeshLayout::addAttribute(const UnsignedInt location, const UnsignedI
     description.offset = offset;
     arrayAppend(_state->attributes, description);
     _vertexInfo.vertexAttributeDescriptionCount = _state->attributes.size();
-    _vertexInfo.pVertexAttributeDescriptions = _state->attributes;
+    _vertexInfo.pVertexAttributeDescriptions = _state->attributes.data();
 
     return *this;
 }