From ec19c25e46aede76ccfd4b0938d3b6f8c66f3319 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Fri, 30 Apr 2021 15:01:41 +0200 Subject: [PATCH] Adapt to Corrade changes. --- doc/generated/colormaps.cpp | 2 +- src/Magnum/Animation/Player.hpp | 4 +- src/Magnum/Animation/Test/Benchmark.cpp | 4 +- src/Magnum/Animation/Test/TrackTest.cpp | 12 ++--- src/Magnum/Animation/Track.h | 12 ++--- .../Audio/Test/AbstractImporterTest.cpp | 2 +- src/Magnum/DebugTools/CompareImage.cpp | 4 +- src/Magnum/DebugTools/FrameProfiler.cpp | 14 +++--- .../DebugTools/Test/CompareImageTest.cpp | 8 +-- .../DebugTools/Test/ForceRendererGLTest.cpp | 2 +- .../DebugTools/Test/FrameProfilerTest.cpp | 3 +- .../DebugTools/Test/ObjectRendererGLTest.cpp | 2 +- src/Magnum/GL/Context.cpp | 4 +- src/Magnum/GL/DefaultFramebuffer.cpp | 2 +- src/Magnum/GL/Framebuffer.cpp | 2 +- src/Magnum/GL/Implementation/State.cpp | 28 +++++------ .../GL/Implementation/driverSpecific.cpp | 6 +-- src/Magnum/GL/Test/FramebufferGLTest.cpp | 50 +++++++++---------- src/Magnum/GL/Test/PixelStorageGLTest.cpp | 12 ++--- src/Magnum/Implementation/ImageProperties.h | 4 +- .../Math/Algorithms/Test/KahanSumTest.cpp | 6 +-- src/Magnum/Math/Tags.h | 2 - src/Magnum/MeshTools/Combine.cpp | 9 ++-- src/Magnum/MeshTools/CompressIndices.cpp | 2 +- src/Magnum/MeshTools/Concatenate.cpp | 4 +- src/Magnum/MeshTools/Concatenate.h | 4 +- src/Magnum/MeshTools/Duplicate.h | 2 +- src/Magnum/MeshTools/GenerateIndices.cpp | 24 ++++----- src/Magnum/MeshTools/GenerateNormals.cpp | 10 ++-- src/Magnum/MeshTools/Implementation/Tipsify.h | 4 +- src/Magnum/MeshTools/Interleave.cpp | 2 +- src/Magnum/MeshTools/Interleave.h | 2 +- src/Magnum/MeshTools/Reference.cpp | 4 +- src/Magnum/MeshTools/RemoveDuplicates.cpp | 16 +++--- src/Magnum/MeshTools/Subdivide.h | 4 +- src/Magnum/MeshTools/Test/ConcatenateTest.cpp | 4 +- .../Test/FullScreenTriangleGLTest.cpp | 4 +- .../MeshTools/Test/GenerateNormalsTest.cpp | 8 +-- src/Magnum/MeshTools/Test/InterleaveTest.cpp | 2 +- .../MeshTools/Test/RemoveDuplicatesTest.cpp | 2 +- src/Magnum/MeshTools/Test/SubdivideTest.cpp | 4 +- src/Magnum/MeshTools/Tipsify.cpp | 2 +- src/Magnum/MeshTools/sceneconverter.cpp | 2 +- src/Magnum/Platform/AbstractXApplication.cpp | 2 +- src/Magnum/Platform/AndroidApplication.cpp | 2 +- src/Magnum/Primitives/Circle.cpp | 2 +- src/Magnum/Primitives/Icosphere.cpp | 4 +- src/Magnum/Primitives/Plane.cpp | 2 +- src/Magnum/ShaderTools/AbstractConverter.cpp | 6 +-- src/Magnum/ShaderTools/shaderconverter.cpp | 8 +-- src/Magnum/Shaders/Phong.cpp | 10 ++-- src/Magnum/Shaders/Test/FlatGLTest.cpp | 4 +- src/Magnum/Shaders/Test/PhongGLTest.cpp | 20 ++++---- src/Magnum/Shaders/Test/VertexColorGLTest.cpp | 8 +-- src/Magnum/Tags.h | 18 +++++-- src/Magnum/Test/CMakeLists.txt | 5 +- src/Magnum/Test/ImageTest.cpp | 6 +-- src/Magnum/Test/ResourceManagerTest.cpp | 4 +- .../Text/Test/AbstractFontConverterTest.cpp | 8 +-- src/Magnum/Text/Test/RendererGLTest.cpp | 24 ++++----- .../Trade/Implementation/converterUtilities.h | 6 +-- src/Magnum/Trade/Test/AnimationDataTest.cpp | 6 +-- src/Magnum/Trade/Test/MaterialDataTest.cpp | 2 +- src/Magnum/Trade/Test/SkinDataTest.cpp | 4 +- src/Magnum/Vk/DescriptorPool.cpp | 2 +- src/Magnum/Vk/DescriptorSetLayout.cpp | 10 ++-- src/Magnum/Vk/Device.cpp | 4 +- src/Magnum/Vk/DeviceProperties.cpp | 8 +-- src/Magnum/Vk/Framebuffer.cpp | 4 +- .../Vk/Implementation/DriverWorkaround.cpp | 6 +-- src/Magnum/Vk/Implementation/spirvPatching.h | 4 +- src/Magnum/Vk/Instance.cpp | 4 +- src/Magnum/Vk/Mesh.cpp | 8 +-- src/Magnum/Vk/Pipeline.cpp | 6 +-- src/Magnum/Vk/PipelineLayout.cpp | 2 +- src/Magnum/Vk/Queue.cpp | 4 +- src/Magnum/Vk/RenderPass.cpp | 8 +-- src/Magnum/Vk/Shader.cpp | 2 +- src/Magnum/Vk/ShaderSet.cpp | 6 +-- src/Magnum/Vk/Test/PipelineTest.cpp | 6 +-- src/Magnum/Vk/Test/RenderPassTest.cpp | 2 +- .../AnyShaderConverter/AnyConverter.cpp | 2 +- .../Test/MagnumFontConverterTest.cpp | 2 +- src/MagnumPlugins/ObjImporter/ObjImporter.cpp | 4 +- .../TgaImageConverter/TgaImageConverter.cpp | 2 +- 85 files changed, 275 insertions(+), 272 deletions(-) diff --git a/doc/generated/colormaps.cpp b/doc/generated/colormaps.cpp index c811e620a..637655f69 100644 --- a/doc/generated/colormaps.cpp +++ b/doc/generated/colormaps.cpp @@ -56,7 +56,7 @@ int main() { constexpr Vector2i OutputSize{256, 12}; CORRADE_INTERNAL_ASSERT(image.first.size() == std::size_t(OutputSize.x())); - Containers::Array data{Containers::NoInit, std::size_t(OutputSize.product())}; + Containers::Array data{NoInit, std::size_t(OutputSize.product())}; Containers::StridedArrayView2D src{image.first, {std::size_t(OutputSize.y()), std::size_t(OutputSize.x())}, {0, 3}}; Containers::StridedArrayView2D dst{data, diff --git a/src/Magnum/Animation/Player.hpp b/src/Magnum/Animation/Player.hpp index 228ac600b..898bf802f 100644 --- a/src/Magnum/Animation/Player.hpp +++ b/src/Magnum/Animation/Player.hpp @@ -106,7 +106,7 @@ template Player& Player::addInternal(const TrackVi _duration = track.duration(); else _duration = Math::join(track.duration(), _duration); - arrayAppend(_tracks, Containers::InPlaceInit, track, advancer, destination, userCallback, userCallbackData, 0u); + arrayAppend(_tracks, InPlaceInit, track, advancer, destination, userCallback, userCallbackData, 0u); return *this; } @@ -252,7 +252,7 @@ template Containers::Optional> playe } } - return {Containers::InPlaceInit, playIteration, key}; + return {InPlaceInit, playIteration, key}; } } diff --git a/src/Magnum/Animation/Test/Benchmark.cpp b/src/Magnum/Animation/Test/Benchmark.cpp index b06460d64..13b7e02a8 100644 --- a/src/Magnum/Animation/Test/Benchmark.cpp +++ b/src/Magnum/Animation/Test/Benchmark.cpp @@ -83,8 +83,8 @@ Benchmark::Benchmark() { &Benchmark::playerAdvanceRawCallbackDirectInterpolator}, 10); _keys = Containers::Array{DataSize}; - _values = Containers::Array{Containers::DirectInit, DataSize, 1}; - _interleaved = Containers::Array>{Containers::DirectInit, DataSize, 0.0f, 1}; + _values = Containers::Array{DirectInit, DataSize, 1}; + _interleaved = Containers::Array>{DirectInit, DataSize, 0.0f, 1}; for(std::size_t i = 0; i != DataSize; ++i) _keys[i] = _interleaved[i].first = Float(i)*3.1254f; diff --git a/src/Magnum/Animation/Test/TrackTest.cpp b/src/Magnum/Animation/Test/TrackTest.cpp index 7a9dc88bc..5b1bc79d6 100644 --- a/src/Magnum/Animation/Test/TrackTest.cpp +++ b/src/Magnum/Animation/Test/TrackTest.cpp @@ -132,7 +132,7 @@ void TrackTest::constructEmpty() { void TrackTest::constructArrayInterpolator() { Track a{ - Containers::Array>{Containers::InPlaceInit, + Containers::Array>{InPlaceInit, {{1.0f, {3.0f, 1.0f, 0.1f}}, {5.0f, {0.3f, 0.6f, 1.0f}}}}, Math::select, Extrapolation::Extrapolated, Extrapolation::Constant}; @@ -162,7 +162,7 @@ void TrackTest::constructArrayInterpolator() { void TrackTest::constructArrayInterpolatorDefaults() { const Track a{ - Containers::Array>{Containers::InPlaceInit, + Containers::Array>{InPlaceInit, {{1.0f, {3.0f, 1.0f, 0.1f}}}}, Math::lerp, Extrapolation::DefaultConstructed}; @@ -183,7 +183,7 @@ void TrackTest::constructArrayInterpolatorDefaults() { void TrackTest::constructArrayInterpolation() { const Track a{ - Containers::Array>{Containers::InPlaceInit, + Containers::Array>{InPlaceInit, {{1.0f, {3.0f, 1.0f, 0.1f}}, {5.0f, {0.3f, 0.6f, 1.0f}}}}, Interpolation::Linear, Extrapolation::Extrapolated, Extrapolation::Constant}; @@ -205,7 +205,7 @@ void TrackTest::constructArrayInterpolation() { void TrackTest::constructArrayInterpolationDefaults() { const Track a{ - Containers::Array>{Containers::InPlaceInit, + Containers::Array>{InPlaceInit, {{1.0f, {3.0f, 1.0f, 0.1f}}}}, Interpolation::Constant, Extrapolation::DefaultConstructed}; @@ -228,7 +228,7 @@ Vector3 customLerp(const Vector3&, const Vector3&, Float) { return {}; } void TrackTest::constructArrayInterpolationInterpolator() { const Track a{ - Containers::Array>{Containers::InPlaceInit, + Containers::Array>{InPlaceInit, {{1.0f, {3.0f, 1.0f, 0.1f}}, {5.0f, {0.3f, 0.6f, 1.0f}}}}, Interpolation::Linear, customLerp, Extrapolation::Extrapolated, Extrapolation::Constant}; @@ -250,7 +250,7 @@ void TrackTest::constructArrayInterpolationInterpolator() { void TrackTest::constructArrayInterpolationInterpolationDefaults() { const Track a{ - Containers::Array>{Containers::InPlaceInit, + Containers::Array>{InPlaceInit, {{1.0f, {3.0f, 1.0f, 0.1f}}}}, Interpolation::Constant, customLerp, Extrapolation::DefaultConstructed}; diff --git a/src/Magnum/Animation/Track.h b/src/Magnum/Animation/Track.h index d31466a86..25b1ed463 100644 --- a/src/Magnum/Animation/Track.h +++ b/src/Magnum/Animation/Track.h @@ -164,7 +164,7 @@ template>&& data, Interpolator interpolator, Extrapolation before, Extrapolation after) noexcept: _data{std::move(data)}, _interpolator{interpolator}, _interpolation{Interpolation::Custom}, _before{before}, _after{after} {} /** @overload */ - explicit Track(std::initializer_list> data, Interpolator interpolator, Extrapolation before, Extrapolation after): Track{Containers::Array>{Containers::InPlaceInit, data}, interpolator, before, after} {} + explicit Track(std::initializer_list> data, Interpolator interpolator, Extrapolation before, Extrapolation after): Track{Containers::Array>{InPlaceInit, data}, interpolator, before, after} {} /** @overload * Equivalent to calling @ref Track(Containers::Array>&&, Interpolator, Extrapolation, Extrapolation) @@ -173,7 +173,7 @@ template>&& data, Interpolator interpolator, Extrapolation extrapolation = Extrapolation::Constant) noexcept: Track{std::move(data), interpolator, extrapolation, extrapolation} {} /** @overload */ - explicit Track(std::initializer_list> data, Interpolator interpolator, Extrapolation extrapolation = Extrapolation::Constant): Track{Containers::Array>{Containers::InPlaceInit, data}, interpolator, extrapolation, extrapolation} {} + explicit Track(std::initializer_list> data, Interpolator interpolator, Extrapolation extrapolation = Extrapolation::Constant): Track{Containers::Array>{InPlaceInit, data}, interpolator, extrapolation, extrapolation} {} /** * @brief Construct with both generic and custom interpolator @@ -192,7 +192,7 @@ template>&& data, Interpolation interpolation, Interpolator interpolator, Extrapolation before, Extrapolation after) noexcept: _data{std::move(data)}, _interpolator{interpolator}, _interpolation{interpolation}, _before{before}, _after{after} {} /** @overload */ - explicit Track(std::initializer_list> data, Interpolation interpolation, Interpolator interpolator, Extrapolation before, Extrapolation after): Track{Containers::Array>{Containers::InPlaceInit, data}, interpolation, interpolator, before, after} {} + explicit Track(std::initializer_list> data, Interpolation interpolation, Interpolator interpolator, Extrapolation before, Extrapolation after): Track{Containers::Array>{InPlaceInit, data}, interpolation, interpolator, before, after} {} /** @overload * Equivalent to calling @ref Track(Containers::Array>&&, Interpolation, Interpolator, Extrapolation, Extrapolation) @@ -201,7 +201,7 @@ template>&& data, Interpolation interpolation, Interpolator interpolator, Extrapolation extrapolation = Extrapolation::Constant) noexcept: Track{std::move(data), interpolation, interpolator, extrapolation, extrapolation} {} /** @overload */ - explicit Track(std::initializer_list> data, Interpolation interpolation, Interpolator interpolator, Extrapolation extrapolation = Extrapolation::Constant): Track{Containers::Array>{Containers::InPlaceInit, data}, interpolation, interpolator, extrapolation} {} + explicit Track(std::initializer_list> data, Interpolation interpolation, Interpolator interpolator, Extrapolation extrapolation = Extrapolation::Constant): Track{Containers::Array>{InPlaceInit, data}, interpolation, interpolator, extrapolation} {} /** * @brief Construct with generic interpolation behavior @@ -219,7 +219,7 @@ template>&& data, Interpolation interpolation, Extrapolation before, Extrapolation after) noexcept: _data{std::move(data)}, _interpolator{interpolatorFor(interpolation)}, _interpolation{interpolation}, _before{before}, _after{after} {} /** @overload */ - explicit Track(std::initializer_list> data, Interpolation interpolation, Extrapolation before, Extrapolation after): Track{Containers::Array>{Containers::InPlaceInit, data}, interpolation, before, after} {} + explicit Track(std::initializer_list> data, Interpolation interpolation, Extrapolation before, Extrapolation after): Track{Containers::Array>{InPlaceInit, data}, interpolation, before, after} {} /** @overload * Equivalent to calling @ref Track(Containers::Array>&&, Interpolation, Extrapolation, Extrapolation) @@ -228,7 +228,7 @@ template>&& data, Interpolation interpolation, Extrapolation extrapolation = Extrapolation::Constant) noexcept: Track{std::move(data), interpolation, extrapolation, extrapolation} {} /** @overload */ - explicit Track(std::initializer_list> data, Interpolation interpolation, Extrapolation extrapolation = Extrapolation::Constant): Track{Containers::Array>{Containers::InPlaceInit, data}, interpolation, extrapolation, extrapolation} {} + explicit Track(std::initializer_list> data, Interpolation interpolation, Extrapolation extrapolation = Extrapolation::Constant): Track{Containers::Array>{InPlaceInit, data}, interpolation, extrapolation, extrapolation} {} /** @brief Copying is not allowed */ Track(const Track&) = delete; diff --git a/src/Magnum/Audio/Test/AbstractImporterTest.cpp b/src/Magnum/Audio/Test/AbstractImporterTest.cpp index 28f6c3fe7..5a0453b1a 100644 --- a/src/Magnum/Audio/Test/AbstractImporterTest.cpp +++ b/src/Magnum/Audio/Test/AbstractImporterTest.cpp @@ -340,7 +340,7 @@ void AbstractImporterTest::data() { } } importer; - CORRADE_COMPARE_AS(importer.data(), (Containers::Array{Containers::InPlaceInit, {'H'}}), TestSuite::Compare::Container); + CORRADE_COMPARE_AS(importer.data(), (Containers::Array{InPlaceInit, {'H'}}), TestSuite::Compare::Container); } void AbstractImporterTest::dataNoFile() { diff --git a/src/Magnum/DebugTools/CompareImage.cpp b/src/Magnum/DebugTools/CompareImage.cpp index 2b9f4db6d..57f83db10 100644 --- a/src/Magnum/DebugTools/CompareImage.cpp +++ b/src/Magnum/DebugTools/CompareImage.cpp @@ -95,7 +95,7 @@ template Float calculateImageDelta(const Containers:: std::tuple, Float, Float> calculateImageDelta(const PixelFormat actualFormat, const Containers::StridedArrayView3D& actualPixels, const ImageView2D& expected) { /* Calculate a delta image */ - Containers::Array deltaData{Containers::NoInit, + Containers::Array deltaData{NoInit, std::size_t(expected.size().product())}; Containers::StridedArrayView2D delta{deltaData, {std::size_t(expected.size().y()), std::size_t(expected.size().x())}}; @@ -446,7 +446,7 @@ class ImageComparatorBase::State { Containers::Array delta; }; -ImageComparatorBase::ImageComparatorBase(PluginManager::Manager* importerManager, PluginManager::Manager* converterManager, Float maxThreshold, Float meanThreshold): _state{Containers::InPlaceInit, importerManager, converterManager, maxThreshold, meanThreshold} { +ImageComparatorBase::ImageComparatorBase(PluginManager::Manager* importerManager, PluginManager::Manager* converterManager, Float maxThreshold, Float meanThreshold): _state{InPlaceInit, importerManager, converterManager, maxThreshold, meanThreshold} { CORRADE_ASSERT(!Math::isNan(maxThreshold) && !Math::isInf(maxThreshold) && !Math::isNan(meanThreshold) && !Math::isInf(meanThreshold), "DebugTools::CompareImage: thresholds can't be NaN or infinity", ); diff --git a/src/Magnum/DebugTools/FrameProfiler.cpp b/src/Magnum/DebugTools/FrameProfiler.cpp index f2f32f2a9..95aacdf12 100644 --- a/src/Magnum/DebugTools/FrameProfiler.cpp +++ b/src/Magnum/DebugTools/FrameProfiler.cpp @@ -181,7 +181,7 @@ void FrameProfiler::endFrame() { /* If we don't have all frames yet, enlarge the array */ if(++_measuredFrameCount <= _maxFrameCount) - arrayAppend(_data, Containers::NoInit, _measurements.size()); + arrayAppend(_data, NoInit, _measurements.size()); /* Wrap up measurements for this frame */ for(std::size_t i = 0; i != _measurements.size(); ++i) { @@ -448,7 +448,7 @@ struct GLFrameProfiler::State { #endif }; -GLFrameProfiler::GLFrameProfiler(): _state{Containers::InPlaceInit} {} +GLFrameProfiler::GLFrameProfiler(): _state{InPlaceInit} {} GLFrameProfiler::GLFrameProfiler(const Values values, const UnsignedInt maxFrameCount): GLFrameProfiler{} { @@ -468,7 +468,7 @@ void GLFrameProfiler::setup(const Values values, const UnsignedInt maxFrameCount /* Fucking hell, STL. When I first saw std::chrono back in 2010 I should have flipped the table and learn carpentry instead. BUT NO, I'm still suffering this abomination a decade later! */ - arrayAppend(measurements, Containers::InPlaceInit, + arrayAppend(measurements, InPlaceInit, "Frame time", Units::Nanoseconds, UnsignedInt(Containers::arraySize(_state->frameTimeStartFrame)), [](void* state, UnsignedInt current) { static_cast(state)->frameTimeStartFrame[current] = std::chrono::duration_cast(std::chrono::high_resolution_clock::now().time_since_epoch()).count(); @@ -482,7 +482,7 @@ void GLFrameProfiler::setup(const Values values, const UnsignedInt maxFrameCount _state->frameTimeIndex = index++; } if(values & Value::CpuDuration) { - arrayAppend(measurements, Containers::InPlaceInit, + arrayAppend(measurements, InPlaceInit, "CPU duration", Units::Nanoseconds, [](void* state) { static_cast(state)->cpuDurationStartFrame = std::chrono::duration_cast(std::chrono::high_resolution_clock::now().time_since_epoch()).count(); @@ -496,7 +496,7 @@ void GLFrameProfiler::setup(const Values values, const UnsignedInt maxFrameCount if(values & Value::GpuDuration) { for(GL::TimeQuery& q: _state->timeQueries) q = GL::TimeQuery{GL::TimeQuery::Target::TimeElapsed}; - arrayAppend(measurements, Containers::InPlaceInit, + arrayAppend(measurements, InPlaceInit, "GPU duration", Units::Nanoseconds, UnsignedInt(Containers::arraySize(_state->timeQueries)), [](void* state, UnsignedInt current) { @@ -516,7 +516,7 @@ void GLFrameProfiler::setup(const Values values, const UnsignedInt maxFrameCount q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::VerticesSubmitted}; for(GL::PipelineStatisticsQuery& q: _state->vertexShaderInvocationsQueries) q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::VertexShaderInvocations}; - arrayAppend(measurements, Containers::InPlaceInit, + arrayAppend(measurements, InPlaceInit, "Vertex fetch ratio", Units::RatioThousandths, UnsignedInt(Containers::arraySize(_state->verticesSubmittedQueries)), [](void* state, UnsignedInt current) { @@ -541,7 +541,7 @@ void GLFrameProfiler::setup(const Values values, const UnsignedInt maxFrameCount q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::ClippingInputPrimitives}; for(GL::PipelineStatisticsQuery& q: _state->clippingOutputPrimitivesQueries) q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::ClippingOutputPrimitives}; - arrayAppend(measurements, Containers::InPlaceInit, + arrayAppend(measurements, InPlaceInit, "Primitives clipped", Units::PercentageThousandths, UnsignedInt(Containers::arraySize(_state->clippingInputPrimitivesQueries)), [](void* state, UnsignedInt current) { diff --git a/src/Magnum/DebugTools/Test/CompareImageTest.cpp b/src/Magnum/DebugTools/Test/CompareImageTest.cpp index 82600d78c..ad63602c6 100644 --- a/src/Magnum/DebugTools/Test/CompareImageTest.cpp +++ b/src/Magnum/DebugTools/Test/CompareImageTest.cpp @@ -317,10 +317,10 @@ void CompareImageTest::calculateDeltaStorage() { Float max, mean; std::tie(delta, max, mean) = Implementation::calculateImageDelta(ActualRgb.format(), ActualRgb.pixels(), ExpectedRgb); - CORRADE_COMPARE_AS(delta, (Containers::Array{Containers::InPlaceInit, { + CORRADE_COMPARE_AS(delta, Containers::arrayView({ 1.0f/3.0f, (55.0f + 1.0f)/3.0f, 48.0f/3.0f, 117.0f/3.0f - }}), TestSuite::Compare::Container); + }), TestSuite::Compare::Container); CORRADE_COMPARE(max, 117.0f/3.0f); CORRADE_COMPARE(mean, 18.5f); } @@ -381,9 +381,9 @@ void CompareImageTest::calculateDeltaSpecials3() { Containers::Array delta; Float max, mean; std::tie(delta, max, mean) = Implementation::calculateImageDelta(actualSpecials3.format(), actualSpecials3.pixels(), expectedSpecials3); - CORRADE_COMPARE_AS(delta, (Containers::Array{Containers::InPlaceInit, { + CORRADE_COMPARE_AS(delta, Containers::arrayView({ Constants::nan(), Constants::nan(), 1.15f - }}), TestSuite::Compare::Container); + }), TestSuite::Compare::Container); /* Max and mean should be calculated *without* the specials because otherwise every other potential difference will be zero compared to infinity */ diff --git a/src/Magnum/DebugTools/Test/ForceRendererGLTest.cpp b/src/Magnum/DebugTools/Test/ForceRendererGLTest.cpp index c2d9ad56c..524c58960 100644 --- a/src/Magnum/DebugTools/Test/ForceRendererGLTest.cpp +++ b/src/Magnum/DebugTools/Test/ForceRendererGLTest.cpp @@ -117,7 +117,7 @@ void ForceRendererGLTest::render2D() { the arrowhead to be on a different place (but the rest is okay and the 3D case matches exactly), however to avoid false negatives elsewhere I'm making it conditional. */ - Containers::Optional comparator{Containers::InPlaceInit, _manager}; + Containers::Optional comparator{InPlaceInit, _manager}; #ifdef CORRADE_TARGET_ANDROID if(GL::Context::current().detectedDriver() & GL::Context::DetectedDriver::ArmMali) comparator.emplace(_manager, 79.0f, 0.22f); diff --git a/src/Magnum/DebugTools/Test/FrameProfilerTest.cpp b/src/Magnum/DebugTools/Test/FrameProfilerTest.cpp index 1d65f718e..16a65fc83 100644 --- a/src/Magnum/DebugTools/Test/FrameProfilerTest.cpp +++ b/src/Magnum/DebugTools/Test/FrameProfilerTest.cpp @@ -1114,8 +1114,7 @@ void FrameProfilerTest::gl() { setTestCaseDescription(data.name); /* Test that we use the right state pointers to survive a move */ - Containers::Pointer profiler_{Containers::InPlaceInit, - data.values, 4u}; + Containers::Pointer profiler_{InPlaceInit, data.values, 4u}; GLFrameProfiler profiler = std::move(*profiler_); profiler_ = nullptr; CORRADE_COMPARE(profiler.values(), data.values); diff --git a/src/Magnum/DebugTools/Test/ObjectRendererGLTest.cpp b/src/Magnum/DebugTools/Test/ObjectRendererGLTest.cpp index 9b0b82d15..d7ee1b490 100644 --- a/src/Magnum/DebugTools/Test/ObjectRendererGLTest.cpp +++ b/src/Magnum/DebugTools/Test/ObjectRendererGLTest.cpp @@ -164,7 +164,7 @@ void ObjectRendererGLTest::render3D() { the bottom blue line to be on a different place (but the rest is okay and the 2D case matches exactly), however to avoid false negatives elsewhere I'm making it conditional. */ - Containers::Optional comparator{Containers::InPlaceInit, _manager, 71.6f, 0.018f}; + Containers::Optional comparator{InPlaceInit, _manager, 71.6f, 0.018f}; #ifdef CORRADE_TARGET_ANDROID if(GL::Context::current().detectedDriver() & GL::Context::DetectedDriver::ArmMali) comparator.emplace(_manager, 127.6f, 0.54f); diff --git a/src/Magnum/GL/Context.cpp b/src/Magnum/GL/Context.cpp index 8d04b9a7d..53d9463bf 100644 --- a/src/Magnum/GL/Context.cpp +++ b/src/Magnum/GL/Context.cpp @@ -796,7 +796,7 @@ bool Context::tryCreate(const Configuration& configuration) { /* Driver workarounds get merged. Not using disableDriverWorkaround() here since the Configuration already contains the internal string views. */ for(const Containers::StringView workaround: configuration.disabledWorkarounds()) - arrayAppend(_driverWorkarounds, Containers::InPlaceInit, workaround, true); + arrayAppend(_driverWorkarounds, InPlaceInit, workaround, true); /* Extensions get merged also. Here we had the chance to force users to give us the predefined extension types so no need to search for their @@ -1208,7 +1208,7 @@ Context::Configuration& Context::Configuration::operator=(const Configuration& o _flags = other._flags; arrayResize(_disabledWorkarounds, 0); /** @todo arrayClear(), ffs */ - arrayResize(_disabledExtensions, Containers::NoInit, 0); + arrayResize(_disabledExtensions, NoInit, 0); addDisabledWorkarounds(other._disabledWorkarounds); addDisabledExtensions(other._disabledExtensions); return *this; diff --git a/src/Magnum/GL/DefaultFramebuffer.cpp b/src/Magnum/GL/DefaultFramebuffer.cpp index b86c3b852..8c2bb1642 100644 --- a/src/Magnum/GL/DefaultFramebuffer.cpp +++ b/src/Magnum/GL/DefaultFramebuffer.cpp @@ -69,7 +69,7 @@ DefaultFramebuffer& DefaultFramebuffer::mapForDraw(std::initializer_list _attachments{Containers::ValueInit, max+1}; + Containers::Array _attachments{ValueInit, max+1}; for(const auto& attachment: attachments) _attachments[attachment.first] = GLenum(attachment.second); diff --git a/src/Magnum/GL/Framebuffer.cpp b/src/Magnum/GL/Framebuffer.cpp index e1edba78a..eef4bd57b 100644 --- a/src/Magnum/GL/Framebuffer.cpp +++ b/src/Magnum/GL/Framebuffer.cpp @@ -185,7 +185,7 @@ Framebuffer& Framebuffer::mapForDraw(std::initializer_list _attachments{Containers::ValueInit, max+1}; + Containers::Array _attachments{ValueInit, max+1}; for(const auto& attachment: attachments) _attachments[attachment.first] = GLenum(attachment.second); diff --git a/src/Magnum/GL/Implementation/State.cpp b/src/Magnum/GL/Implementation/State.cpp index 03225464e..582bf6ef7 100644 --- a/src/Magnum/GL/Implementation/State.cpp +++ b/src/Magnum/GL/Implementation/State.cpp @@ -92,25 +92,25 @@ std::pair State::allocate(Context& context, std: Containers::ArrayView transformFeedbackStateView; #endif Containers::ArrayTuple data{ - {Containers::NoInit, 1, stateView}, - {Containers::NoInit, 1, bufferStateView}, - {Containers::NoInit, 1, contextStateView}, + {NoInit, 1, stateView}, + {NoInit, 1, bufferStateView}, + {NoInit, 1, contextStateView}, #ifndef MAGNUM_TARGET_WEBGL - {Containers::NoInit, 1, debugStateView}, + {NoInit, 1, debugStateView}, #endif - {Containers::NoInit, 1, framebufferStateView}, - {Containers::NoInit, 1, meshStateView}, - {Containers::NoInit, 1, queryStateView}, - {Containers::NoInit, 1, rendererStateView}, - {Containers::NoInit, 1, shaderStateView}, - {Containers::NoInit, 1, shaderProgramStateView}, - {Containers::NoInit, 1, textureStateView}, - {Containers::ValueInit, std::size_t(maxTextureUnits), textureBindings}, + {NoInit, 1, framebufferStateView}, + {NoInit, 1, meshStateView}, + {NoInit, 1, queryStateView}, + {NoInit, 1, rendererStateView}, + {NoInit, 1, shaderStateView}, + {NoInit, 1, shaderProgramStateView}, + {NoInit, 1, textureStateView}, + {ValueInit, std::size_t(maxTextureUnits), textureBindings}, #if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL) - {Containers::ValueInit, std::size_t(maxImageUnits), imageBindings}, + {ValueInit, std::size_t(maxImageUnits), imageBindings}, #endif #ifndef MAGNUM_TARGET_GLES2 - {Containers::NoInit, 1, transformFeedbackStateView} + {NoInit, 1, transformFeedbackStateView} #endif }; diff --git a/src/Magnum/GL/Implementation/driverSpecific.cpp b/src/Magnum/GL/Implementation/driverSpecific.cpp index 9ac84a136..6f999a175 100644 --- a/src/Magnum/GL/Implementation/driverSpecific.cpp +++ b/src/Magnum/GL/Implementation/driverSpecific.cpp @@ -496,7 +496,7 @@ void Context::disableDriverWorkaround(const Containers::StringView workaround) { return; } - arrayAppend(_driverWorkarounds, Containers::InPlaceInit, found, true); + arrayAppend(_driverWorkarounds, InPlaceInit, found, true); } bool Context::isDriverWorkaroundDisabled(const Containers::StringView workaround) { @@ -512,7 +512,7 @@ bool Context::isDriverWorkaroundDisabled(const Containers::StringView workaround the views in the KnownWorkarounds list. */ for(const auto& i: _driverWorkarounds) if(i.first.data() == found.data()) return i.second; - arrayAppend(_driverWorkarounds, Containers::InPlaceInit, found, false); + arrayAppend(_driverWorkarounds, InPlaceInit, found, false); return false; } @@ -633,7 +633,7 @@ Context::Configuration& Context::Configuration::addDisabledWorkarounds(Container continue; } - arrayAppend(_disabledWorkarounds, Containers::InPlaceInit, found); + arrayAppend(_disabledWorkarounds, InPlaceInit, found); } return *this; diff --git a/src/Magnum/GL/Test/FramebufferGLTest.cpp b/src/Magnum/GL/Test/FramebufferGLTest.cpp index d4dfddb58..1fed5ef74 100644 --- a/src/Magnum/GL/Test/FramebufferGLTest.cpp +++ b/src/Magnum/GL/Test/FramebufferGLTest.cpp @@ -1728,7 +1728,7 @@ void FramebufferGLTest::copyImageTexture1D() { CORRADE_COMPARE(texture.imageSize(0)[0], 2); CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(), - (Containers::Array{Containers::InPlaceInit, {0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b}}), + Containers::arrayView({0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b}), TestSuite::Compare::Container); } #endif @@ -1770,9 +1770,9 @@ void FramebufferGLTest::copyImageTexture2D() { #ifndef MAGNUM_TARGET_GLES CORRADE_COMPARE(texture.imageSize(0), Vector2i{2}); CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, - 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}}), + 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}), TestSuite::Compare::Container); #endif } @@ -1798,9 +1798,9 @@ void FramebufferGLTest::copyImageTexture1DArray() { CORRADE_COMPARE(texture.imageSize(0), Vector2i{2}); CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, - 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}}), + 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}), TestSuite::Compare::Container); } @@ -1824,9 +1824,9 @@ void FramebufferGLTest::copyImageRectangleTexture() { CORRADE_COMPARE(texture.imageSize(), Vector2i{2}); CORRADE_COMPARE_AS(texture.image({PixelFormat::RGBA, PixelType::UnsignedByte}).release(), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, - 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}}), + 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}), TestSuite::Compare::Container); } #endif @@ -1875,9 +1875,9 @@ void FramebufferGLTest::copyImageCubeMapTexture() { #ifndef MAGNUM_TARGET_GLES CORRADE_COMPARE(texture.imageSize(0), Vector2i{2}); CORRADE_COMPARE_AS(texture.image(CubeMapCoordinate::PositiveX, 0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, - 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}}), + 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}), TestSuite::Compare::Container); #endif } @@ -1902,8 +1902,8 @@ void FramebufferGLTest::copySubImageTexture1D() { MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(), - (Containers::Array{Containers::InPlaceInit, { - 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00}}), + Containers::arrayView({ + 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00}), TestSuite::Compare::Container); } #endif @@ -1946,11 +1946,11 @@ void FramebufferGLTest::copySubImageTexture2D() { #ifndef MAGNUM_TARGET_GLES CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}), + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), TestSuite::Compare::Container); #endif } @@ -1993,7 +1993,7 @@ void FramebufferGLTest::copySubImageTexture3D() { #ifndef MAGNUM_TARGET_GLES CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -2002,7 +2002,7 @@ void FramebufferGLTest::copySubImageTexture3D() { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}), + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), TestSuite::Compare::Container); #endif } @@ -2030,11 +2030,11 @@ void FramebufferGLTest::copySubImageTexture1DArray() { MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}), + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), TestSuite::Compare::Container); } #endif @@ -2064,7 +2064,7 @@ void FramebufferGLTest::copySubImageTexture2DArray() { #ifndef MAGNUM_TARGET_GLES CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -2073,7 +2073,7 @@ void FramebufferGLTest::copySubImageTexture2DArray() { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}), + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), TestSuite::Compare::Container); #endif } @@ -2101,11 +2101,11 @@ void FramebufferGLTest::copySubImageRectangleTexture() { MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_AS(texture.image({PixelFormat::RGBA, PixelType::UnsignedByte}).release(), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}), + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), TestSuite::Compare::Container); } #endif @@ -2148,11 +2148,11 @@ void FramebufferGLTest::copySubImageCubeMapTexture() { #ifndef MAGNUM_TARGET_GLES CORRADE_COMPARE_AS(texture.image(CubeMapCoordinate::NegativeY, 0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}), + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), TestSuite::Compare::Container); #endif } @@ -2185,7 +2185,7 @@ void FramebufferGLTest::copySubImageCubeMapTextureArray() { #ifndef MAGNUM_TARGET_GLES CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -2214,7 +2214,7 @@ void FramebufferGLTest::copySubImageCubeMapTextureArray() { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}), + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), TestSuite::Compare::Container); #endif } diff --git a/src/Magnum/GL/Test/PixelStorageGLTest.cpp b/src/Magnum/GL/Test/PixelStorageGLTest.cpp index 5bb4d1809..7e163e3c2 100644 --- a/src/Magnum/GL/Test/PixelStorageGLTest.cpp +++ b/src/Magnum/GL/Test/PixelStorageGLTest.cpp @@ -120,7 +120,7 @@ void PixelStorageGLTest::unpack2D() { /* Read into zero-initialized array to avoid comparing random memory in padding bytes (confirmed on NVidia 355.11, AMD 15.300.1025.0) */ Image2D actual{PixelFormat::RGB, PixelType::UnsignedByte, {}, - Containers::Array{Containers::ValueInit, sizeof(ActualData)}}; + Containers::Array{ValueInit, sizeof(ActualData)}}; #ifndef MAGNUM_TARGET_GLES texture.image(0, actual); @@ -158,7 +158,7 @@ void PixelStorageGLTest::pack2D() { .setAlignment(2) .setRowLength(3) .setSkip({1, 3, 0}), - PixelFormat::RGB, PixelType::UnsignedByte, {}, Containers::Array{Containers::ValueInit, sizeof(Data2D)}}; + PixelFormat::RGB, PixelType::UnsignedByte, {}, Containers::Array{ValueInit, sizeof(Data2D)}}; #ifndef MAGNUM_TARGET_GLES texture.image(0, image); @@ -218,7 +218,7 @@ void PixelStorageGLTest::unpack3D() { /* Read into zero-initialized array to avoid comparing random memory in padding bytes (confirmed on AMD 15.300.1025.0) */ Image3D actual{PixelFormat::RGB, PixelType::UnsignedByte, {}, - Containers::Array{Containers::ValueInit, sizeof(ActualData)}}; + Containers::Array{ValueInit, sizeof(ActualData)}}; texture.image(0, actual); @@ -252,7 +252,7 @@ void PixelStorageGLTest::pack3D() { .setRowLength(3) .setImageHeight(5) .setSkip({1, 2, 1}), - PixelFormat::RGB, PixelType::UnsignedByte, {}, Containers::Array{Containers::ValueInit, sizeof(Data3D)}}; + PixelFormat::RGB, PixelType::UnsignedByte, {}, Containers::Array{ValueInit, sizeof(Data3D)}}; texture.image(0, image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -330,7 +330,7 @@ void PixelStorageGLTest::packCompressed2D() { .setCompressedBlockDataSize(16) .setRowLength(12) .setSkip({4, 4, 0}), - CompressedPixelFormat::RGBAS3tcDxt3, {}, Containers::Array{Containers::ValueInit, sizeof(CompressedData2D)}}; + CompressedPixelFormat::RGBAS3tcDxt3, {}, Containers::Array{ValueInit, sizeof(CompressedData2D)}}; texture.compressedImage(0, image); MAGNUM_VERIFY_NO_GL_ERROR(); @@ -438,7 +438,7 @@ void PixelStorageGLTest::packCompressed3D() { .setRowLength(8) .setImageHeight(8) .setSkip({4, 4, 4}), - CompressedPixelFormat::RGBAS3tcDxt3, {}, Containers::Array{Containers::ValueInit, sizeof(CompressedData3D)}}; + CompressedPixelFormat::RGBAS3tcDxt3, {}, Containers::Array{ValueInit, sizeof(CompressedData3D)}}; texture.compressedImage(0, image); MAGNUM_VERIFY_NO_GL_ERROR(); diff --git a/src/Magnum/Implementation/ImageProperties.h b/src/Magnum/Implementation/ImageProperties.h index 3e164a14e..c94068afc 100644 --- a/src/Magnum/Implementation/ImageProperties.h +++ b/src/Magnum/Implementation/ImageProperties.h @@ -51,7 +51,7 @@ template Containers::S /* Size in the last dimension is byte size of the pixel, the remaining dimensions are reverted (first images, then rows, then pixels, last pixel bytes) */ - Containers::StridedDimensions size{Containers::NoInit}; + Containers::StridedDimensions size{NoInit}; size[dimensions] = image.pixelSize(); for(UnsignedInt i = dimensions; i != 0; --i) size[i - 1] = image.size()[dimensions - i]; @@ -61,7 +61,7 @@ template Containers::S (first image size, then row size, then pixel size, last 1). The data properties include pixel size in row size, so we have to take it out from the cumulative product. */ - Containers::StridedDimensions stride{Containers::NoInit}; + Containers::StridedDimensions stride{NoInit}; stride[dimensions] = 1; stride[dimensions - 1] = 1; for(UnsignedInt i = dimensions - 1; i != 0; --i) diff --git a/src/Magnum/Math/Algorithms/Test/KahanSumTest.cpp b/src/Magnum/Math/Algorithms/Test/KahanSumTest.cpp index 3ff7e0024..6095290d9 100644 --- a/src/Magnum/Math/Algorithms/Test/KahanSumTest.cpp +++ b/src/Magnum/Math/Algorithms/Test/KahanSumTest.cpp @@ -143,7 +143,7 @@ void KahanSumTest::iterative() { } void KahanSumTest::accumulate100kFloats() { - Containers::Array data(Containers::DirectInit, 100000, 1.0f); + Containers::Array data(DirectInit, 100000, 1.0f); volatile Float a; /* to avoid optimizing the loop out */ CORRADE_BENCHMARK(10) { @@ -154,7 +154,7 @@ void KahanSumTest::accumulate100kFloats() { } void KahanSumTest::accumulate100kDoubles() { - Containers::Array data(Containers::DirectInit, 100000, 1.0); + Containers::Array data(DirectInit, 100000, 1.0); volatile Double a; /* to avoid optimizing the loop out */ CORRADE_BENCHMARK(10) { @@ -165,7 +165,7 @@ void KahanSumTest::accumulate100kDoubles() { } void KahanSumTest::kahan100kFloats() { - Containers::Array data(Containers::DirectInit, 100000, 1.0f); + Containers::Array data(DirectInit, 100000, 1.0f); volatile Float a; /* to avoid optimizing the loop out */ CORRADE_BENCHMARK(10) { diff --git a/src/Magnum/Math/Tags.h b/src/Magnum/Math/Tags.h index 0e655bbb1..f130ed6f2 100644 --- a/src/Magnum/Math/Tags.h +++ b/src/Magnum/Math/Tags.h @@ -29,8 +29,6 @@ * @brief Tag type @ref Magnum::Math::ZeroInitT, @ref Magnum::Math::IdentityInitT, tag @ref Magnum::Math::ZeroInit, @ref Magnum::Math::IdentityInit */ -#include - #include "Magnum/Tags.h" #ifdef MAGNUM_BUILD_DEPRECATED diff --git a/src/Magnum/MeshTools/Combine.cpp b/src/Magnum/MeshTools/Combine.cpp index 5e567374f..7f0792e5e 100644 --- a/src/Magnum/MeshTools/Combine.cpp +++ b/src/Magnum/MeshTools/Combine.cpp @@ -59,8 +59,7 @@ Trade::MeshData combineIndexedImplementation(const MeshPrimitive primitive, Cont /* Allocate resulting attribute and vertex data and duplicate the attributes there according to the combined index buffer */ - Containers::Array vertexData{Containers::NoInit, - vertexStride*vertexCount}; + Containers::Array vertexData{NoInit, vertexStride*vertexCount}; Containers::Array attributeData{attributeCount}; { std::size_t indexOffset = 0; @@ -133,8 +132,7 @@ Trade::MeshData combineIndexedAttributes(const Containers::ArrayView combinedIndices{Containers::NoInit, - indexCount*indexStride}; + Containers::Array combinedIndices{NoInit, indexCount*indexStride}; { std::size_t indexOffset = 0; for(const Trade::MeshData& mesh: data) { @@ -177,8 +175,7 @@ Trade::MeshData combineFaceAttributes(const Trade::MeshData& mesh, const Trade:: const UnsignedInt faceIndexSize = faceAttributes.isIndexed() ? meshIndexTypeSize(faceAttributes.indexType()) : 4; const UnsignedInt indexStride = meshIndexSize + faceIndexSize; - Containers::Array combinedIndices{Containers::NoInit, - meshIndexCount*indexStride}; + Containers::Array combinedIndices{NoInit, meshIndexCount*indexStride}; Utility::copy(mesh.indices(), Containers::StridedArrayView2D{combinedIndices, {meshIndexCount, meshIndexSize}, {std::ptrdiff_t(indexStride), 1}}); diff --git a/src/Magnum/MeshTools/CompressIndices.cpp b/src/Magnum/MeshTools/CompressIndices.cpp index 261e0d1e7..82f0b226a 100644 --- a/src/Magnum/MeshTools/CompressIndices.cpp +++ b/src/Magnum/MeshTools/CompressIndices.cpp @@ -127,7 +127,7 @@ Trade::MeshData compressIndices(Trade::MeshData&& data, MeshIndexType atLeast) { if(data.vertexDataFlags() & Trade::DataFlag::Owned) vertexData = data.releaseVertexData(); else { - vertexData = Containers::Array{Containers::NoInit, data.vertexData().size()}; + vertexData = Containers::Array{NoInit, data.vertexData().size()}; Utility::copy(data.vertexData(), vertexData); } diff --git a/src/Magnum/MeshTools/Concatenate.cpp b/src/Magnum/MeshTools/Concatenate.cpp index 16ade1747..f50596b5e 100644 --- a/src/Magnum/MeshTools/Concatenate.cpp +++ b/src/Magnum/MeshTools/Concatenate.cpp @@ -208,9 +208,9 @@ Trade::MeshData concatenate(const Containers::ArrayView indexVertexCount = Implementation::concatenateIndexVertexCount(meshes); - Containers::Array indexData{Containers::NoInit, + Containers::Array indexData{NoInit, indexVertexCount.first*sizeof(UnsignedInt)}; - Containers::Array vertexData{Containers::ValueInit, + Containers::Array vertexData{ValueInit, attributeData.empty() ? 0 : (attributeData[0].stride()*indexVertexCount.second)}; return Implementation::concatenate(std::move(indexData), indexVertexCount.second, std::move(vertexData), std::move(attributeData), meshes, "MeshTools::concatenate():"); } diff --git a/src/Magnum/MeshTools/Concatenate.h b/src/Magnum/MeshTools/Concatenate.h index 88db82de5..a2f9230c3 100644 --- a/src/Magnum/MeshTools/Concatenate.h +++ b/src/Magnum/MeshTools/Concatenate.h @@ -106,7 +106,7 @@ template class Allocator = Containers::ArrayAllocator> void conc indexData = destination.releaseIndexData(); /* Everything is overwritten here so we don't need to zero-out the memory */ - Containers::arrayResize(indexData, Containers::NoInit, indexVertexCount.first*sizeof(UnsignedInt)); + Containers::arrayResize(indexData, NoInit, indexVertexCount.first*sizeof(UnsignedInt)); } Containers::Array attributeData = Implementation::interleavedLayout(std::move(destination), {}); @@ -118,7 +118,7 @@ template class Allocator = Containers::ArrayAllocator> void conc there, otherwise attributes that are not present in `meshes` would be garbage */ Containers::arrayResize(vertexData, 0); - Containers::arrayResize(vertexData, Containers::ValueInit, attributeStride*indexVertexCount.second); + Containers::arrayResize(vertexData, ValueInit, attributeStride*indexVertexCount.second); } destination = Implementation::concatenate(std::move(indexData), indexVertexCount.second, std::move(vertexData), std::move(attributeData), meshes, "MeshTools::concatenateInto():"); diff --git a/src/Magnum/MeshTools/Duplicate.h b/src/Magnum/MeshTools/Duplicate.h index 7515babd5..bb537e3f5 100644 --- a/src/Magnum/MeshTools/Duplicate.h +++ b/src/Magnum/MeshTools/Duplicate.h @@ -62,7 +62,7 @@ use @ref duplicateInto(). @see @ref removeDuplicatesInPlace(), @ref combineIndexedAttributes() */ template Containers::Array duplicate(const Containers::StridedArrayView1D& indices, const Containers::StridedArrayView1D& data) { - Containers::Array out{Containers::NoInit, indices.size()}; + Containers::Array out{NoInit, indices.size()}; duplicateInto(indices, data, out); return out; } diff --git a/src/Magnum/MeshTools/GenerateIndices.cpp b/src/Magnum/MeshTools/GenerateIndices.cpp index c628c24f4..60a7cae65 100644 --- a/src/Magnum/MeshTools/GenerateIndices.cpp +++ b/src/Magnum/MeshTools/GenerateIndices.cpp @@ -76,7 +76,7 @@ void generateLineStripIndicesInto(const UnsignedInt vertexCount, const Container } Containers::Array generateLineStripIndices(const UnsignedInt vertexCount) { - Containers::Array indices{Containers::NoInit, 2*(vertexCount - 1)}; + Containers::Array indices{NoInit, 2*(vertexCount - 1)}; generateLineStripIndicesInto(vertexCount, indices); return indices; } @@ -105,7 +105,7 @@ void generateLineLoopIndicesInto(const UnsignedInt vertexCount, const Containers } Containers::Array generateLineLoopIndices(const UnsignedInt vertexCount) { - Containers::Array indices{Containers::NoInit, 2*vertexCount}; + Containers::Array indices{NoInit, 2*vertexCount}; generateLineLoopIndicesInto(vertexCount, indices); return indices; } @@ -134,7 +134,7 @@ void generateTriangleStripIndicesInto(const UnsignedInt vertexCount, const Conta } Containers::Array generateTriangleStripIndices(const UnsignedInt vertexCount) { - Containers::Array indices{Containers::NoInit, 3*(vertexCount - 2)}; + Containers::Array indices{NoInit, 3*(vertexCount - 2)}; generateTriangleStripIndicesInto(vertexCount, indices); return indices; } @@ -164,7 +164,7 @@ void generateTriangleFanIndicesInto(const UnsignedInt vertexCount, const Contain } Containers::Array generateTriangleFanIndices(const UnsignedInt vertexCount) { - Containers::Array indices{Containers::NoInit, 3*(vertexCount - 2)}; + Containers::Array indices{NoInit, 3*(vertexCount - 2)}; generateTriangleFanIndicesInto(vertexCount, indices); return indices; } @@ -216,14 +216,14 @@ template inline void generateQuadIndicesIntoImplementation(const Contai Containers::Array generateQuadIndices(const Containers::StridedArrayView1D& positions, const Containers::StridedArrayView1D& quads) { /* We can skip zero-initialization here */ - Containers::Array out{Containers::NoInit, quads.size()*6/4}; + Containers::Array out{NoInit, quads.size()*6/4}; generateQuadIndicesIntoImplementation(positions, quads, Containers::stridedArrayView(out)); return out; } Containers::Array generateQuadIndices(const Containers::StridedArrayView1D& positions, const Containers::StridedArrayView1D& quads) { /* Explicitly ensure we have the unused bytes zeroed out */ - Containers::Array out{Containers::ValueInit, quads.size()*6/4}; + Containers::Array out{ValueInit, quads.size()*6/4}; generateQuadIndicesIntoImplementation(positions, quads, /* Could be just arrayCast(stridedArrayView(out) on LE, but I want to be sure as much as possible that this compiles on BE @@ -241,7 +241,7 @@ Containers::Array generateQuadIndices(const Containers::StridedArra Containers::Array generateQuadIndices(const Containers::StridedArrayView1D& positions, const Containers::StridedArrayView1D& quads) { /* Explicitly ensure we have the unused bytes zeroed out */ - Containers::Array out{Containers::ValueInit, quads.size()*6/4}; + Containers::Array out{ValueInit, quads.size()*6/4}; generateQuadIndicesIntoImplementation(positions, quads, /* Could be just arrayCast(stridedArrayView(out) on LE, but I want to be sure as much as possible that this compiles on BE @@ -281,7 +281,7 @@ Trade::MeshData generateIndices(Trade::MeshData&& data) { if(data.vertexDataFlags() & Trade::DataFlag::Owned) vertexData = data.releaseVertexData(); else { - vertexData = Containers::Array{Containers::NoInit, data.vertexData().size()}; + vertexData = Containers::Array{NoInit, data.vertexData().size()}; Utility::copy(data.vertexData(), vertexData); } @@ -301,19 +301,19 @@ Trade::MeshData generateIndices(Trade::MeshData&& data) { Containers::Array indexData; if(data.primitive() == MeshPrimitive::LineStrip) { primitive = MeshPrimitive::Lines; - indexData = Containers::Array{Containers::NoInit, 2*(vertexCount - 1)*sizeof(UnsignedInt)}; + indexData = Containers::Array{NoInit, 2*(vertexCount - 1)*sizeof(UnsignedInt)}; generateLineStripIndicesInto(vertexCount, Containers::arrayCast(indexData)); } else if(data.primitive() == MeshPrimitive::LineLoop) { primitive = MeshPrimitive::Lines; - indexData = Containers::Array{Containers::NoInit, 2*vertexCount*sizeof(UnsignedInt)}; + indexData = Containers::Array{NoInit, 2*vertexCount*sizeof(UnsignedInt)}; generateLineLoopIndicesInto(vertexCount, Containers::arrayCast(indexData)); } else if(data.primitive() == MeshPrimitive::TriangleStrip) { primitive = MeshPrimitive::Triangles; - indexData = Containers::Array{Containers::NoInit, 3*(vertexCount - 2)*sizeof(UnsignedInt)}; + indexData = Containers::Array{NoInit, 3*(vertexCount - 2)*sizeof(UnsignedInt)}; generateTriangleStripIndicesInto(vertexCount, Containers::arrayCast(indexData)); } else if(data.primitive() == MeshPrimitive::TriangleFan) { primitive = MeshPrimitive::Triangles; - indexData = Containers::Array{Containers::NoInit, 3*(vertexCount - 2)*sizeof(UnsignedInt)}; + indexData = Containers::Array{NoInit, 3*(vertexCount - 2)*sizeof(UnsignedInt)}; generateTriangleFanIndicesInto(vertexCount, Containers::arrayCast(indexData)); } else CORRADE_ASSERT_UNREACHABLE("MeshTools::generateIndices(): invalid primitive" << data.primitive(), (Trade::MeshData{MeshPrimitive::Triangles, 0})); diff --git a/src/Magnum/MeshTools/GenerateNormals.cpp b/src/Magnum/MeshTools/GenerateNormals.cpp index 31264ed82..214300d50 100644 --- a/src/Magnum/MeshTools/GenerateNormals.cpp +++ b/src/Magnum/MeshTools/GenerateNormals.cpp @@ -53,7 +53,7 @@ void generateFlatNormalsInto(const Containers::StridedArrayView1D } Containers::Array generateFlatNormals(const Containers::StridedArrayView1D& positions) { - Containers::Array out{Containers::NoInit, positions.size()}; + Containers::Array out{NoInit, positions.size()}; generateFlatNormalsInto(positions, Containers::arrayView(out)); return out; } @@ -120,7 +120,7 @@ template inline void generateSmoothNormalsIntoImplementation(const Cont /* Turn that into a running offset array: triangleOffset[i + 1] - triangleOffset[i] is triangle count for vertex i triangleOffset[i] is offset into an triangle ID array for vertex i */ - Containers::Array triangleOffset{Containers::NoInit, positions.size() + 1}; + Containers::Array triangleOffset{NoInit, positions.size() + 1}; triangleOffset[0] = 0; for(std::size_t i = 0; i != triangleCount.size(); ++i) triangleOffset[i + 1] = triangleOffset[i] + triangleCount[i]; @@ -130,7 +130,7 @@ template inline void generateSmoothNormalsIntoImplementation(const Cont /* Gather triangle IDs for every vertex. For vertex i, triangleIds[triangleOffset[i]] until triangleIds[triangleOffset[i + 1]] contains IDs of triangles that contain it. */ - Containers::Array triangleIds{Containers::NoInit, indices.size()}; + Containers::Array triangleIds{NoInit, indices.size()}; for(std::size_t i = 0; i != indices.size(); ++i) { const T triangleId = i/3; const T vertexId = indices[i]; @@ -251,7 +251,7 @@ void generateSmoothNormalsInto(const Containers::StridedArrayView2D& namespace { template inline Containers::Array generateSmoothNormalsImplementation(const Containers::StridedArrayView1D& indices, const Containers::StridedArrayView1D& positions) { - Containers::Array out{Containers::NoInit, positions.size()}; + Containers::Array out{NoInit, positions.size()}; generateSmoothNormalsInto(indices, positions, out); return out; } @@ -272,7 +272,7 @@ Containers::Array generateSmoothNormals(const Containers::StridedArrayV } Containers::Array generateSmoothNormals(const Containers::StridedArrayView2D& indices, const Containers::StridedArrayView1D& positions) { - Containers::Array out{Containers::NoInit, positions.size()}; + Containers::Array out{NoInit, positions.size()}; generateSmoothNormalsInto(indices, positions, out); return out; } diff --git a/src/Magnum/MeshTools/Implementation/Tipsify.h b/src/Magnum/MeshTools/Implementation/Tipsify.h index 70dbae654..1660c65e4 100644 --- a/src/Magnum/MeshTools/Implementation/Tipsify.h +++ b/src/Magnum/MeshTools/Implementation/Tipsify.h @@ -45,7 +45,7 @@ template void buildAdjacency(const Containers::StridedArrayView1D{Containers::NoInit, vertexCount + 1}; + neighborOffset = Containers::Array{NoInit, vertexCount + 1}; neighborOffset[0] = 0; UnsignedInt sum = 0; for(std::size_t i = 0; i != vertexCount; ++i) { @@ -55,7 +55,7 @@ template void buildAdjacency(const Containers::StridedArrayView1D{Containers::NoInit, sum}; + neighbors = Containers::Array{NoInit, sum}; for(std::size_t i = 0; i != indices.size(); ++i) neighbors[neighborOffset[indices[i]+1]++] = i/3; } diff --git a/src/Magnum/MeshTools/Interleave.cpp b/src/Magnum/MeshTools/Interleave.cpp index 0cc73adf5..82565f981 100644 --- a/src/Magnum/MeshTools/Interleave.cpp +++ b/src/Magnum/MeshTools/Interleave.cpp @@ -216,7 +216,7 @@ Trade::MeshData interleavedLayout(Trade::MeshData&& data, const UnsignedInt vert return Trade::MeshData{data.primitive(), vertexCount}; /* Allocate new data array */ - Containers::Array vertexData{Containers::NoInit, attributeData[0].stride()*vertexCount}; + Containers::Array vertexData{NoInit, attributeData[0].stride()*vertexCount}; /* Convert the attributes from offset-only and zero vertex count to absolute, referencing the above-allocated data array */ diff --git a/src/Magnum/MeshTools/Interleave.h b/src/Magnum/MeshTools/Interleave.h index e9f7f0680..974729682 100644 --- a/src/Magnum/MeshTools/Interleave.h +++ b/src/Magnum/MeshTools/Interleave.h @@ -160,7 +160,7 @@ template data{Containers::ValueInit, attributeCount*stride}; + Containers::Array data{ValueInit, attributeCount*stride}; Implementation::writeInterleaved(stride, data.begin(), first, next...); return data; diff --git a/src/Magnum/MeshTools/Reference.cpp b/src/Magnum/MeshTools/Reference.cpp index 80a84adbc..5473cbc5e 100644 --- a/src/Magnum/MeshTools/Reference.cpp +++ b/src/Magnum/MeshTools/Reference.cpp @@ -67,7 +67,7 @@ Trade::MeshData owned(Trade::MeshData&& data) { /* Otherwise copy them, if the mesh is indexed. If not, the default-constructed instances are fine. */ } else if(data.isIndexed()) { - indexData = Containers::Array{Containers::NoInit, data.indexData().size()}; + indexData = Containers::Array{NoInit, data.indexData().size()}; indices = Trade::MeshIndexData{data.indexType(), indexData.slice(data.indexOffset(), data.indexOffset() + data.indexCount()*meshIndexTypeSize(data.indexType()))}; Utility::copy(data.indexData(), indexData); } @@ -83,7 +83,7 @@ Trade::MeshData owned(Trade::MeshData&& data) { /* Otherwise copy them */ } else { - vertexData = Containers::Array{Containers::NoInit, originalVertexData.size()}; + vertexData = Containers::Array{NoInit, originalVertexData.size()}; Utility::copy(originalVertexData, vertexData); } diff --git a/src/Magnum/MeshTools/RemoveDuplicates.cpp b/src/Magnum/MeshTools/RemoveDuplicates.cpp index c6cfcd934..fdb287db3 100644 --- a/src/Magnum/MeshTools/RemoveDuplicates.cpp +++ b/src/Magnum/MeshTools/RemoveDuplicates.cpp @@ -98,7 +98,7 @@ std::size_t removeDuplicatesInto(const Containers::StridedArrayView2D, std::size_t> removeDuplicates(const Containers::StridedArrayView2D& data) { - Containers::Array indices{Containers::NoInit, data.size()[0]}; + Containers::Array indices{NoInit, data.size()[0]}; const std::size_t size = removeDuplicatesInto(data, indices); return {std::move(indices), size}; } @@ -156,7 +156,7 @@ std::size_t removeDuplicatesInPlaceInto(const Containers::StridedArrayView2D, std::size_t> removeDuplicatesInPlace(const Containers::StridedArrayView2D& data) { - Containers::Array indices{Containers::NoInit, data.size()[0]}; + Containers::Array indices{NoInit, data.size()[0]}; const std::size_t size = removeDuplicatesInPlaceInto(data, indices); return {std::move(indices), size}; } @@ -223,7 +223,7 @@ template std::size_t removeDuplicatesFuzzyIndexedInPla to be robust. */ const std::size_t vectorSize = data.size()[1]; T range = T(0.0); - Containers::Array offsets{Containers::NoInit, vectorSize}; + Containers::Array offsets{NoInit, vectorSize}; { /** @todo this isn't really cache-efficient, do differently */ std::size_t i = 0; @@ -249,8 +249,8 @@ template std::size_t removeDuplicatesFuzzyIndexedInPla /* Index array that'll be filled in each pass and then used for remapping the `indices`; discretized storage for all map keys. */ - Containers::Array remapping{Containers::NoInit, dataSize}; - Containers::Array discretized{Containers::NoInit, dataSize*vectorSize}; + Containers::Array remapping{NoInit, dataSize}; + Containers::Array discretized{NoInit, dataSize*vectorSize}; /* First go with original coordinates, then move them by epsilon/2 in each dimension. */ @@ -349,7 +349,7 @@ template std::size_t removeDuplicatesFuzzyInPlaceIntoImplementation(con } template std::pair, std::size_t> removeDuplicatesFuzzyInPlaceImplementation(const Containers::StridedArrayView2D& data, const T epsilon) { - Containers::Array indices{Containers::NoInit, data.size()[0]}; + Containers::Array indices{NoInit, data.size()[0]}; const std::size_t size = removeDuplicatesFuzzyInPlaceIntoImplementation(data, indices, epsilon); return {std::move(indices), size}; } @@ -425,7 +425,7 @@ Trade::MeshData removeDuplicates(Trade::MeshData&& data) { indexData = ownedInterleaved.releaseIndexData(); indexType = ownedInterleaved.indexType(); } else { - indexData = Containers::Array{Containers::NoInit, ownedInterleaved.vertexCount()*sizeof(UnsignedInt)}; + indexData = Containers::Array{NoInit, ownedInterleaved.vertexCount()*sizeof(UnsignedInt)}; uniqueVertexCount = removeDuplicatesInPlaceInto(vertexData, Containers::arrayCast(indexData)); indexType = MeshIndexType::UnsignedInt; } @@ -435,7 +435,7 @@ Trade::MeshData removeDuplicates(Trade::MeshData&& data) { or interleave() above, arrayResize() wouldn't release the excessive memory in any way. This is basically equivalent to STL's shrink_to_fit(), which also copies */ - Containers::Array uniqueVertexData{Containers::NoInit, uniqueVertexCount*vertexData.size()[1]}; + Containers::Array uniqueVertexData{NoInit, uniqueVertexCount*vertexData.size()[1]}; Utility::copy(vertexData.prefix(uniqueVertexCount), Containers::StridedArrayView2D{uniqueVertexData, {uniqueVertexCount, vertexData.size()[1]}}); diff --git a/src/Magnum/MeshTools/Subdivide.h b/src/Magnum/MeshTools/Subdivide.h index df1f75bdc..e3ed60904 100644 --- a/src/Magnum/MeshTools/Subdivide.h +++ b/src/Magnum/MeshTools/Subdivide.h @@ -64,8 +64,8 @@ vertices in the mesh is up to the user. template void subdivide(Containers::Array& indices, Containers::Array& vertices, Interpolator interpolator) { CORRADE_ASSERT(!(indices.size()%3), "MeshTools::subdivide(): index count is not divisible by 3", ); - arrayResize(vertices, Containers::NoInit, vertices.size() + indices.size()); - arrayResize(indices, Containers::NoInit, indices.size()*4); + arrayResize(vertices, NoInit, vertices.size() + indices.size()); + arrayResize(indices, NoInit, indices.size()*4); subdivideInPlace(Containers::stridedArrayView(indices), Containers::stridedArrayView(vertices), interpolator); } diff --git a/src/Magnum/MeshTools/Test/ConcatenateTest.cpp b/src/Magnum/MeshTools/Test/ConcatenateTest.cpp index cf57e0b09..1827a75f1 100644 --- a/src/Magnum/MeshTools/Test/ConcatenateTest.cpp +++ b/src/Magnum/MeshTools/Test/ConcatenateTest.cpp @@ -379,9 +379,9 @@ void ConcatenateTest::concatenateInto() { Containers::Array attributeData{2}; Containers::Array vertexData; Containers::Array indexData; - arrayResize(vertexData, Containers::DirectInit, (sizeof(Vector2) + sizeof(Vector3))*7, '\xff'); + arrayResize(vertexData, DirectInit, (sizeof(Vector2) + sizeof(Vector3))*7, '\xff'); arrayResize(vertexData, 0); - arrayResize(indexData, Containers::DirectInit, sizeof(UnsignedInt)*9, '\xff'); + arrayResize(indexData, DirectInit, sizeof(UnsignedInt)*9, '\xff'); arrayResize(indexData, 0); const void* attributeDataPointer = attributeData; const void* vertexDataPointer = vertexData; diff --git a/src/Magnum/MeshTools/Test/FullScreenTriangleGLTest.cpp b/src/Magnum/MeshTools/Test/FullScreenTriangleGLTest.cpp index fd02a123c..79e648fd7 100644 --- a/src/Magnum/MeshTools/Test/FullScreenTriangleGLTest.cpp +++ b/src/Magnum/MeshTools/Test/FullScreenTriangleGLTest.cpp @@ -133,12 +133,12 @@ void main() { using namespace Math::Literals; Image2D image = framebuffer.read({{}, Vector2i{4}}, PixelFormat::RGBA8Unorm); - CORRADE_COMPARE_AS(Containers::arrayCast(image.data()), Containers::arrayView(Containers::Array{Containers::InPlaceInit, { + CORRADE_COMPARE_AS(Containers::arrayCast(image.data()), Containers::arrayView({ 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba - }}), TestSuite::Compare::Container); + }), TestSuite::Compare::Container); } }}}} diff --git a/src/Magnum/MeshTools/Test/GenerateNormalsTest.cpp b/src/Magnum/MeshTools/Test/GenerateNormalsTest.cpp index 969c4bdc0..e916b465d 100644 --- a/src/Magnum/MeshTools/Test/GenerateNormalsTest.cpp +++ b/src/Magnum/MeshTools/Test/GenerateNormalsTest.cpp @@ -366,11 +366,11 @@ void GenerateNormalsTest::smoothZeroAreaTriangle() { }; CORRADE_COMPARE_AS(generateSmoothNormals(indices, positions), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ Vector3::zAxis(), Vector3::zAxis(), Vector3::zAxis() - }}), TestSuite::Compare::Container); + }), TestSuite::Compare::Container); } void GenerateNormalsTest::smoothNanPosition() { @@ -442,7 +442,7 @@ void GenerateNormalsTest::benchmarkFlat() { Containers::stridedArrayView(BeveledCubeIndices), Containers::stridedArrayView(BeveledCubePositions)); - Containers::Array normals{Containers::NoInit, positions.size()}; + Containers::Array normals{NoInit, positions.size()}; CORRADE_BENCHMARK(10) { generateFlatNormalsInto(positions, normals); } @@ -451,7 +451,7 @@ void GenerateNormalsTest::benchmarkFlat() { } void GenerateNormalsTest::benchmarkSmooth() { - Containers::Array normals{Containers::NoInit, Containers::arraySize(BeveledCubePositions)}; + Containers::Array normals{NoInit, Containers::arraySize(BeveledCubePositions)}; CORRADE_BENCHMARK(10) { generateSmoothNormalsInto(BeveledCubeIndices, BeveledCubePositions, normals); } diff --git a/src/Magnum/MeshTools/Test/InterleaveTest.cpp b/src/Magnum/MeshTools/Test/InterleaveTest.cpp index 4d76589e5..77bf86d21 100644 --- a/src/Magnum/MeshTools/Test/InterleaveTest.cpp +++ b/src/Magnum/MeshTools/Test/InterleaveTest.cpp @@ -233,7 +233,7 @@ void InterleaveTest::interleaveEmpty() { } void InterleaveTest::interleaveInto() { - Containers::Array data{Containers::InPlaceInit, { + Containers::Array data{InPlaceInit, { 0x11, 0x33, 0x55, 0x77, 0x11, 0x33, 0x55, 0x77, 0x11, 0x33, 0x55, 0x77, 0x11, 0x33, 0x55, 0x77, 0x11, 0x33, 0x55, 0x77, 0x11, 0x33, 0x55, 0x77, 0x11, 0x33, 0x55, 0x77, 0x11, 0x33, 0x55, 0x77, 0x11, 0x33, 0x55, 0x77, diff --git a/src/Magnum/MeshTools/Test/RemoveDuplicatesTest.cpp b/src/Magnum/MeshTools/Test/RemoveDuplicatesTest.cpp index fbdec37a9..69d2fb905 100644 --- a/src/Magnum/MeshTools/Test/RemoveDuplicatesTest.cpp +++ b/src/Magnum/MeshTools/Test/RemoveDuplicatesTest.cpp @@ -441,7 +441,7 @@ template void RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceInto() {T(1.0), T(5.0)} }; - Containers::Array indices{Containers::NoInit, Containers::arraySize(data)}; + Containers::Array indices{NoInit, Containers::arraySize(data)}; std::size_t result = MeshTools::removeDuplicatesFuzzyInPlaceInto( Containers::arrayCast<2, T>(Containers::stridedArrayView(data)), indices, T(2.0)); diff --git a/src/Magnum/MeshTools/Test/SubdivideTest.cpp b/src/Magnum/MeshTools/Test/SubdivideTest.cpp index f57496203..080fc7428 100644 --- a/src/Magnum/MeshTools/Test/SubdivideTest.cpp +++ b/src/Magnum/MeshTools/Test/SubdivideTest.cpp @@ -173,11 +173,11 @@ void SubdivideTest::benchmark() { CORRADE_BENCHMARK(3) { Containers::Array indices; - arrayResize(indices, Containers::NoInit, icosphere.indexCount()); + arrayResize(indices, NoInit, icosphere.indexCount()); Utility::copy(icosphere.indices(), indices); Containers::Array positions; - arrayResize(positions, Containers::NoInit, icosphere.vertexCount()); + arrayResize(positions, NoInit, icosphere.vertexCount()); Utility::copy(icosphere.attribute(Trade::MeshAttribute::Position), positions); /* Subdivide 5 times */ diff --git a/src/Magnum/MeshTools/Tipsify.cpp b/src/Magnum/MeshTools/Tipsify.cpp index 6c301499f..d27e87194 100644 --- a/src/Magnum/MeshTools/Tipsify.cpp +++ b/src/Magnum/MeshTools/Tipsify.cpp @@ -49,7 +49,7 @@ template void tipsifyInPlaceImplementation(const Containers::StridedArr Containers::Array deadEndStack; /* Output index buffer */ - Containers::Array outputIndices{Containers::NoInit, indices.size()}; + Containers::Array outputIndices{NoInit, indices.size()}; std::size_t outputIndex = 0; /* Array with candidates for next fanning vertex (in 1-ring around diff --git a/src/Magnum/MeshTools/sceneconverter.cpp b/src/Magnum/MeshTools/sceneconverter.cpp index 770f943fc..fcb3f58c6 100644 --- a/src/Magnum/MeshTools/sceneconverter.cpp +++ b/src/Magnum/MeshTools/sceneconverter.cpp @@ -468,7 +468,7 @@ used.)") break; } - arrayAppend(info.attributes, Containers::InPlaceInit, + arrayAppend(info.attributes, InPlaceInit, mesh->attributeOffset(k), mesh->attributeStride(k), mesh->attributeArraySize(k), diff --git a/src/Magnum/Platform/AbstractXApplication.cpp b/src/Magnum/Platform/AbstractXApplication.cpp index d816e8363..b07188318 100644 --- a/src/Magnum/Platform/AbstractXApplication.cpp +++ b/src/Magnum/Platform/AbstractXApplication.cpp @@ -41,7 +41,7 @@ AbstractXApplication::AbstractXApplication(Implementation::AbstractContextHandle create(configuration, glConfiguration); } -AbstractXApplication::AbstractXApplication(Implementation::AbstractContextHandler* contextHandler, const Arguments& arguments, NoCreateT): _contextHandler{contextHandler}, _context{Containers::InPlaceInit, NoCreate, arguments.argc, arguments.argv}, _flags{Flag::Redraw} {} +AbstractXApplication::AbstractXApplication(Implementation::AbstractContextHandler* contextHandler, const Arguments& arguments, NoCreateT): _contextHandler{contextHandler}, _context{InPlaceInit, NoCreate, arguments.argc, arguments.argv}, _flags{Flag::Redraw} {} void AbstractXApplication::create() { create({}); } diff --git a/src/Magnum/Platform/AndroidApplication.cpp b/src/Magnum/Platform/AndroidApplication.cpp index f3ee497f0..d70dccbd2 100644 --- a/src/Magnum/Platform/AndroidApplication.cpp +++ b/src/Magnum/Platform/AndroidApplication.cpp @@ -70,7 +70,7 @@ AndroidApplication::AndroidApplication(const Arguments& arguments, const Configu create(configuration, glConfiguration); } -AndroidApplication::AndroidApplication(const Arguments& arguments, NoCreateT): _state{arguments}, _context{Containers::InPlaceInit, NoCreate} { +AndroidApplication::AndroidApplication(const Arguments& arguments, NoCreateT): _state{arguments}, _context{InPlaceInit, NoCreate} { /* Redirect debug output to Android log */ _logOutput.reset(new LogOutput); } diff --git a/src/Magnum/Primitives/Circle.cpp b/src/Magnum/Primitives/Circle.cpp index d078829ff..3d1b6789d 100644 --- a/src/Magnum/Primitives/Circle.cpp +++ b/src/Magnum/Primitives/Circle.cpp @@ -132,7 +132,7 @@ Trade::MeshData circle3DSolid(const UnsignedInt segments, const Circle3DFlags fl } /* Set up the layout */ - Containers::Array vertexData{Containers::NoInit, (segments + 2)*stride}; + Containers::Array vertexData{NoInit, (segments + 2)*stride}; Containers::Array attributeData{attributeCount}; std::size_t attributeIndex = 0; std::size_t attributeOffset = 0; diff --git a/src/Magnum/Primitives/Icosphere.cpp b/src/Magnum/Primitives/Icosphere.cpp index 8ce558e31..839146c9f 100644 --- a/src/Magnum/Primitives/Icosphere.cpp +++ b/src/Magnum/Primitives/Icosphere.cpp @@ -96,8 +96,8 @@ Trade::MeshData icosphereSolid(const UnsignedInt subdivisions) { Vector3 normal; }; Containers::Array vertexData; - Containers::arrayResize(vertexData, - Containers::NoInit, sizeof(Vertex)*vertexCount); + Containers::arrayResize(vertexData, NoInit, + sizeof(Vertex)*vertexCount); /* Build up the subdivided positions */ { diff --git a/src/Magnum/Primitives/Plane.cpp b/src/Magnum/Primitives/Plane.cpp index 463a98f42..6fc3e395f 100644 --- a/src/Magnum/Primitives/Plane.cpp +++ b/src/Magnum/Primitives/Plane.cpp @@ -76,7 +76,7 @@ Trade::MeshData planeSolid(const PlaneFlags flags) { } /* Set up the layout */ - Containers::Array vertexData{Containers::NoInit, 4*stride}; + Containers::Array vertexData{NoInit, 4*stride}; Containers::Array attributeData{attributeCount}; std::size_t attributeIndex = 0; std::size_t attributeOffset = 0; diff --git a/src/Magnum/ShaderTools/AbstractConverter.cpp b/src/Magnum/ShaderTools/AbstractConverter.cpp index d5558259c..07520c72f 100644 --- a/src/Magnum/ShaderTools/AbstractConverter.cpp +++ b/src/Magnum/ShaderTools/AbstractConverter.cpp @@ -467,7 +467,7 @@ bool AbstractConverter::linkDataToFile(const std::initializer_list AbstractConverter::linkDataToDataUsingInputFileCallbacks(const char* const prefix, const Containers::ArrayView> filenames) { - Containers::Array>> data{Containers::NoInit, filenames.size()}; + Containers::Array>> data{NoInit, filenames.size()}; /* First load all files. Remember how many of these succeeded so we can close them again after */ @@ -573,7 +573,7 @@ bool AbstractConverter::doLinkFilesToFile(const Containers::ArrayView>> data{Containers::NoInit, from.size()}; + Containers::Array>> data{NoInit, from.size()}; for(std::size_t i = 0; i != from.size(); ++i) { data[i].first = from[i].first; data[i].second = fileData[i]; @@ -652,7 +652,7 @@ Containers::Array AbstractConverter::doLinkFilesToData(const Containers::A } /** @todo merge the allocations once we have an ArrayTuple */ - Containers::Array>> data{Containers::NoInit, filenames.size()}; + Containers::Array>> data{NoInit, filenames.size()}; for(std::size_t i = 0; i != filenames.size(); ++i) { data[i].first = filenames[i].first; data[i].second = fileData[i]; diff --git a/src/Magnum/ShaderTools/shaderconverter.cpp b/src/Magnum/ShaderTools/shaderconverter.cpp index bca984b01..d0c2c0233 100644 --- a/src/Magnum/ShaderTools/shaderconverter.cpp +++ b/src/Magnum/ShaderTools/shaderconverter.cpp @@ -208,7 +208,7 @@ void printSpirvInfo(Containers::ArrayView data) { Debug d; d << "Entrypoint" << entrypoint->name << "(" << Debug::nospace << spvExecutionModelToStage(entrypoint->executionModel) << Debug::nospace << ")" << Debug::newline; - Containers::Array interface{Containers::ValueInit, entrypoint->interfaces.size()}; + Containers::Array interface{ValueInit, entrypoint->interfaces.size()}; ShaderTools::Implementation::spirvEntrypointInterface(data, *entrypoint, interface); for(const ShaderTools::Implementation::SpirvEntrypointInterface& i: interface) { d << " "; @@ -433,11 +433,11 @@ see documentation of a particular converter for more information.)") for(std::size_t i = 0; i != args.arrayValueCount("define"); ++i) { const Containers::Array3 define = args.arrayValue("define", i).partition('='); - arrayAppend(definitions, Containers::InPlaceInit, + arrayAppend(definitions, InPlaceInit, define[0], define[2]); } for(std::size_t i = 0; i != args.arrayValueCount("undefine"); ++i) { - arrayAppend(definitions, Containers::InPlaceInit, + arrayAppend(definitions, InPlaceInit, args.arrayValue("undefine", i), nullptr); } @@ -465,7 +465,7 @@ see documentation of a particular converter for more information.)") if(args.isSet("link")) { arrayReserve(linkInputs, args.arrayValueCount("input")); for(std::size_t i = 0; i != args.arrayValueCount("input"); ++i) - arrayAppend(linkInputs, Containers::InPlaceInit, + arrayAppend(linkInputs, InPlaceInit, ShaderTools::Stage::Unspecified, args.arrayValue("input", i)); } } diff --git a/src/Magnum/Shaders/Phong.cpp b/src/Magnum/Shaders/Phong.cpp index f443eb541..6cb4505a0 100644 --- a/src/Magnum/Shaders/Phong.cpp +++ b/src/Magnum/Shaders/Phong.cpp @@ -260,11 +260,11 @@ Phong::Phong(const Flags flags, const UnsignedInt lightCount): _flags{flags}, _l setShininess(80.0f); if(flags & Flag::NormalTexture) setNormalTextureScale(1.0f); - setLightPositions(Containers::Array{Containers::DirectInit, lightCount, Vector4{0.0f, 0.0f, 1.0f, 0.0f}}); - Containers::Array colors{Containers::DirectInit, lightCount, Magnum::Color3{1.0f}}; + setLightPositions(Containers::Array{DirectInit, lightCount, Vector4{0.0f, 0.0f, 1.0f, 0.0f}}); + Containers::Array colors{DirectInit, lightCount, Magnum::Color3{1.0f}}; setLightColors(colors); setLightSpecularColors(colors); - setLightRanges(Containers::Array{Containers::DirectInit, lightCount, Constants::inf()}); + setLightRanges(Containers::Array{DirectInit, lightCount, Constants::inf()}); /* Light position is zero by default */ setNormalMatrix(Matrix3x3{Math::IdentityInit}); } @@ -390,7 +390,7 @@ Phong& Phong::setLightPositions(const std::initializer_list positions) #ifdef MAGNUM_BUILD_DEPRECATED Phong& Phong::setLightPositions(const Containers::ArrayView positions) { - Containers::Array fourComponent{Containers::NoInit, positions.size()}; + Containers::Array fourComponent{NoInit, positions.size()}; for(std::size_t i = 0; i != positions.size(); ++i) fourComponent[i] = Vector4{positions[i], 0.0f}; setLightPositions(fourComponent); @@ -431,7 +431,7 @@ Phong& Phong::setLightColors(const Containers::ArrayView c #ifdef MAGNUM_BUILD_DEPRECATED Phong& Phong::setLightColors(const Containers::ArrayView colors) { - Containers::Array threeComponent{Containers::NoInit, colors.size()}; + Containers::Array threeComponent{NoInit, colors.size()}; for(std::size_t i = 0; i != colors.size(); ++i) threeComponent[i] = colors[i].rgb(); setLightColors(threeComponent); diff --git a/src/Magnum/Shaders/Test/FlatGLTest.cpp b/src/Magnum/Shaders/Test/FlatGLTest.cpp index 8cbfaad89..d70caf85b 100644 --- a/src/Magnum/Shaders/Test/FlatGLTest.cpp +++ b/src/Magnum/Shaders/Test/FlatGLTest.cpp @@ -775,7 +775,7 @@ template void FlatGLTest::renderVertexColor2D() { Primitives::Circle2DFlag::TextureCoordinates); /* Highlight a quarter */ - Containers::Array colorData{Containers::DirectInit, circleData.vertexCount(), 0x999999_rgbf}; + Containers::Array colorData{DirectInit, circleData.vertexCount(), 0x999999_rgbf}; for(std::size_t i = 8; i != 16; ++i) colorData[i + 1] = 0xffff99_rgbf*1.5f; @@ -829,7 +829,7 @@ template void FlatGLTest::renderVertexColor3D() { Primitives::UVSphereFlag::TextureCoordinates); /* Highlight the middle rings */ - Containers::Array colorData{Containers::DirectInit, sphereData.vertexCount(), 0x999999_rgbf}; + Containers::Array colorData{DirectInit, sphereData.vertexCount(), 0x999999_rgbf}; for(std::size_t i = 6*33; i != 9*33; ++i) colorData[i + 1] = 0xffff99_rgbf*1.5f; diff --git a/src/Magnum/Shaders/Test/PhongGLTest.cpp b/src/Magnum/Shaders/Test/PhongGLTest.cpp index 28da301c0..8a811c711 100644 --- a/src/Magnum/Shaders/Test/PhongGLTest.cpp +++ b/src/Magnum/Shaders/Test/PhongGLTest.cpp @@ -353,7 +353,7 @@ const struct { {"directional", "light-directional.tga", {1.0f, -1.5f, 0.5f, 0.0f}, Color3{1.0f}, Color3{1.0f}, 1.0f, Constants::inf(), - {Containers::InPlaceInit, { + {InPlaceInit, { /* Ambient isn't affected by light direction, otherwise it's a dot product of a normalized direction */ {{40, 40}, 0x222222_rgb + 0xff8080_rgb*dot(Vector3{1.0f, -1.5f, 0.5f}.normalized(), Vector3::zAxis())}, @@ -380,7 +380,7 @@ const struct { {"directional, from back", "light-none.tga", {-1.0f, 1.5f, -0.5f, 0.0f}, Color3{1.0f}, Color3{1.0f}, 1.0f, Constants::inf(), - {Containers::InPlaceInit, { + {InPlaceInit, { /* Only ambient color left */ {{40, 40}, 0x222222_rgb} }}}, @@ -389,13 +389,13 @@ const struct { {"directional, intensity=2", "light-directional-intensity2.tga", {1.0f, -1.5f, 0.5f, 0.0f}, Color3{1.0f}, Color3{1.0f}, 2.0f, 1.0f, - {Containers::InPlaceInit, { + {InPlaceInit, { {{40, 40}, 0x222222_rgb + 0xff8080_rgb*dot(Vector3{1.0f, -1.5f, 0.5f}.normalized(), Vector3::zAxis())*2.0f} }}}, {"point", "light-point.tga", {0.75f, -0.75f, -0.75f, 1.0f}, Color3{1.0f}, Color3{1.0f}, 1.0f, Constants::inf(), - {Containers::InPlaceInit, { + {InPlaceInit, { /* The range is inf, so it doesn't get fully ambient even at the edge */ {{8, 71}, 0x2c2727_rgb}, @@ -407,21 +407,21 @@ const struct { {"point, specular material color", "light-point-specular-color.tga", {0.75f, -0.75f, -0.75f, 1.0f}, 0x80ff80_rgbf, Color3{1.0f}, 1.0f, Constants::inf(), - {Containers::InPlaceInit, { + {InPlaceInit, { /* Colored specular highlight */ {{60, 19}, 0xc27573_rgb} }}}, {"point, specular light color", "light-point-specular-color.tga", {0.75f, -0.75f, -0.75f, 1.0f}, Color3{1.0f}, 0x80ff80_rgbf, 1.0f, Constants::inf(), - {Containers::InPlaceInit, { + {InPlaceInit, { /* Colored specular highlight */ {{60, 19}, 0xc27573_rgb} }}}, {"point, attenuated specular", "light-point-attenuated-specular.tga", {1.0f, -1.0f, -0.25f, 1.0f}, Color3{1.0f}, Color3{1.0f}, 1.0f, 2.5f, - {Containers::InPlaceInit, { + {InPlaceInit, { /* Specular highlight shouldn't be brighter than the attenuated intensity */ {{57, 22}, 0xa68787_rgb} @@ -429,7 +429,7 @@ const struct { {"point, range=1.5, specular color", "light-point-range1.5.tga", {0.75f, -0.75f, -0.75f, 1.0f}, Color3{1.0f}, 0x80ff80_rgbf, 1.0f, 1.5f, - {Containers::InPlaceInit, { + {InPlaceInit, { /* Color goes back to ambient at distance = 1.5 */ {{59, 60}, 0x222222_rgb}, {{29, 50}, 0x222222_rgb}, @@ -1071,7 +1071,7 @@ void PhongGLTest::renderTexturedNormal() { Vector3 bitangent; } tangentBitangent{data.tangent, data.bitangent}; GL::Buffer tangents; - tangents.setData(Containers::Array{Containers::DirectInit, 4, tangentBitangent}); + tangents.setData(Containers::Array{DirectInit, 4, tangentBitangent}); plane.addVertexBuffer(tangents, 0, sizeof(TangentBitangent), GL::DynamicAttribute{Shaders::Phong::Tangent4{data.tangentComponents}}); plane.addVertexBuffer(std::move(tangents), sizeof(Vector4), @@ -1148,7 +1148,7 @@ template void PhongGLTest::renderVertexColor() { Primitives::UVSphereFlag::TextureCoordinates); /* Highlight the pole vertices and the middle rings */ - Containers::Array colorData{Containers::DirectInit, sphereData.vertexCount(), 0x999999_rgbf}; + Containers::Array colorData{DirectInit, sphereData.vertexCount(), 0x999999_rgbf}; for(std::size_t i = 0; i != 3*33 + 1; ++i) colorData[sphereData.vertexCount() - i - 1] = 0xff0000_rgbf*5.0f; for(std::size_t i = 6*33; i != 9*33; ++i) diff --git a/src/Magnum/Shaders/Test/VertexColorGLTest.cpp b/src/Magnum/Shaders/Test/VertexColorGLTest.cpp index 16bb823dd..8740beb6f 100644 --- a/src/Magnum/Shaders/Test/VertexColorGLTest.cpp +++ b/src/Magnum/Shaders/Test/VertexColorGLTest.cpp @@ -200,7 +200,7 @@ template void VertexColorGLTest::renderDefaults2D() { Primitives::Circle2DFlag::TextureCoordinates); /* All a single color */ - Containers::Array colorData{Containers::DirectInit, circleData.vertexCount(), 0xffffff_rgbf}; + Containers::Array colorData{DirectInit, circleData.vertexCount(), 0xffffff_rgbf}; GL::Buffer colors; colors.setData(colorData); @@ -241,7 +241,7 @@ template void VertexColorGLTest::renderDefaults3D() { Primitives::UVSphereFlag::TextureCoordinates); /* All a single color */ - Containers::Array colorData{Containers::DirectInit, sphereData.vertexCount(), 0xffffff_rgbf}; + Containers::Array colorData{DirectInit, sphereData.vertexCount(), 0xffffff_rgbf}; GL::Buffer colors; colors.setData(colorData); @@ -274,7 +274,7 @@ template void VertexColorGLTest::render2D() { Primitives::Circle2DFlag::TextureCoordinates); /* Highlight a quarter */ - Containers::Array colorData{Containers::DirectInit, circleData.vertexCount(), 0x9999ff_rgbf}; + Containers::Array colorData{DirectInit, circleData.vertexCount(), 0x9999ff_rgbf}; for(std::size_t i = 8; i != 16; ++i) colorData[i + 1] = 0xffff99_rgbf; @@ -319,7 +319,7 @@ template void VertexColorGLTest::render3D() { Primitives::UVSphereFlag::TextureCoordinates); /* Highlight the middle rings */ - Containers::Array colorData{Containers::DirectInit, sphereData.vertexCount(), 0x9999ff_rgbf}; + Containers::Array colorData{DirectInit, sphereData.vertexCount(), 0x9999ff_rgbf}; for(std::size_t i = 6*33; i != 9*33; ++i) colorData[i + 1] = 0xffff99_rgbf; diff --git a/src/Magnum/Tags.h b/src/Magnum/Tags.h index cd1c5cd5b..1069353d9 100644 --- a/src/Magnum/Tags.h +++ b/src/Magnum/Tags.h @@ -29,7 +29,7 @@ * @brief Tag type @ref Magnum::NoInitT, @ref Magnum::NoCreateT, tag @ref Magnum::NoInit, @ref Magnum::NoCreate */ -#include +#include #include "Magnum/configure.h" @@ -42,7 +42,11 @@ namespace Magnum { Used to distinguish construction with no initialization at all. @see @ref NoInit */ -typedef Corrade::Containers::NoInitT NoInitT; +#ifdef DOXYGEN_GENERATING_OUTPUT +typedef Corrade::NoInitT NoInitT; +#else +using Corrade::NoInitT; +#endif /** @brief No creation tag type @@ -51,7 +55,11 @@ Used to distinguish construction without creating the underlying OpenGL / Vulkan / ... object. @see @ref NoCreate */ -typedef Corrade::Containers::NoCreateT NoCreateT; +#ifdef DOXYGEN_GENERATING_OUTPUT +typedef Corrade::NoCreateT NoCreateT; +#else +using Corrade::NoCreateT; +#endif /** @brief No allocation tag type @@ -77,7 +85,7 @@ Use for construction with no initialization at all. #ifdef DOXYGEN_GENERATING_OUTPUT constexpr NoInitT NoInit{}; #else -using Corrade::Containers::NoInit; +using Corrade::NoInit; #endif /** @@ -92,7 +100,7 @@ overhead), wrap the objects in an @ref Corrade::Containers::Optional. #ifdef DOXYGEN_GENERATING_OUTPUT constexpr NoCreateT NoCreate{}; #else -using Corrade::Containers::NoCreate; +using Corrade::NoCreate; #endif /** diff --git a/src/Magnum/Test/CMakeLists.txt b/src/Magnum/Test/CMakeLists.txt index 30ef374f9..e9623f23d 100644 --- a/src/Magnum/Test/CMakeLists.txt +++ b/src/Magnum/Test/CMakeLists.txt @@ -31,7 +31,8 @@ corrade_add_test(PixelFormatTest PixelFormatTest.cpp LIBRARIES MagnumTestLib) corrade_add_test(PixelStorageTest PixelStorageTest.cpp LIBRARIES Magnum) corrade_add_test(ResourceManagerTest ResourceManagerTest.cpp LIBRARIES Magnum) corrade_add_test(SamplerTest SamplerTest.cpp LIBRARIES MagnumTestLib) -corrade_add_test(TagsTest TagsTest.cpp LIBRARIES Magnum) +# Prefixed with project name to avoid conflicts with TagsTest in Corrade +corrade_add_test(MagnumTagsTest TagsTest.cpp LIBRARIES Magnum) # Prefixed with project name to avoid conflicts with VersionTest in Corrade and # other repos @@ -47,7 +48,7 @@ set_target_properties( PixelStorageTest ResourceManagerTest SamplerTest - TagsTest + MagnumTagsTest MagnumVersionTest VertexFormatTest PROPERTIES FOLDER "Magnum/Test") diff --git a/src/Magnum/Test/ImageTest.cpp b/src/Magnum/Test/ImageTest.cpp index b23017236..5e48c0d7a 100644 --- a/src/Magnum/Test/ImageTest.cpp +++ b/src/Magnum/Test/ImageTest.cpp @@ -743,7 +743,7 @@ void ImageTest::pixels1D() { .setAlignment(1) /** @todo alignment 4 expects 17 bytes. what */ .setSkip({3, 0, 0}), PixelFormat::RGB8Unorm, 2, - Containers::Array{Containers::InPlaceInit, { + Containers::Array{InPlaceInit, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 5, 6, 7, 8 }}}; const Image1D& cimage = image; @@ -772,7 +772,7 @@ void ImageTest::pixels2D() { .setSkip({3, 2, 0}) .setRowLength(6), PixelFormat::RGB8Unorm, {2, 4}, - Containers::Array{Containers::InPlaceInit, { + Containers::Array{InPlaceInit, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, @@ -807,7 +807,7 @@ void ImageTest::pixels3D() { .setRowLength(6) .setImageHeight(7), PixelFormat::RGB8Unorm, {2, 4, 3}, - Containers::Array{Containers::InPlaceInit, { + Containers::Array{InPlaceInit, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, diff --git a/src/Magnum/Test/ResourceManagerTest.cpp b/src/Magnum/Test/ResourceManagerTest.cpp index 98bab5535..77b9123eb 100644 --- a/src/Magnum/Test/ResourceManagerTest.cpp +++ b/src/Magnum/Test/ResourceManagerTest.cpp @@ -457,7 +457,7 @@ void ResourceManagerTest::loader() { { ResourceManager rm; - Containers::Pointer loaderPtr{Containers::InPlaceInit, rm}; + Containers::Pointer loaderPtr{InPlaceInit, rm}; IntResourceLoader& loader = *loaderPtr; rm.setLoader(std::move(loaderPtr)); @@ -507,7 +507,7 @@ void ResourceManagerTest::loaderSetNullptr() { }; ResourceManager rm; - Containers::Pointer loaderPtr{Containers::InPlaceInit}; + Containers::Pointer loaderPtr{InPlaceInit}; IntResourceLoader& loader = *loaderPtr; rm.setLoader(std::move(loaderPtr)); diff --git a/src/Magnum/Text/Test/AbstractFontConverterTest.cpp b/src/Magnum/Text/Test/AbstractFontConverterTest.cpp index 8be39c0fc..272cc85bc 100644 --- a/src/Magnum/Text/Test/AbstractFontConverterTest.cpp +++ b/src/Magnum/Text/Test/AbstractFontConverterTest.cpp @@ -507,7 +507,7 @@ void AbstractFontConverterTest::exportGlyphCacheToSingleData() { Containers::Array out = converter.exportGlyphCacheToSingleData(dummyGlyphCache); CORRADE_COMPARE_AS(out, - (Containers::Array{Containers::InPlaceInit, {'\xee'}}), + (Containers::Array{InPlaceInit, {'\xee'}}), TestSuite::Compare::Container); } @@ -640,7 +640,7 @@ void AbstractFontConverterTest::exportGlyphCacheToDataThroughSingleData() { CORRADE_COMPARE(ret.size(), 1); CORRADE_COMPARE(ret[0].first, "font.out"); CORRADE_COMPARE_AS(ret[0].second, - (Containers::Array{Containers::InPlaceInit, {'\xee'}}), + (Containers::Array{InPlaceInit, {'\xee'}}), TestSuite::Compare::Container); } @@ -730,8 +730,8 @@ void AbstractFontConverterTest::exportGlyphCacheToFileThroughData() { std::vector>> doExportGlyphCacheToData(AbstractGlyphCache&, const std::string& filename) const override { std::vector>> ret; - ret.emplace_back(filename, Containers::Array{Containers::InPlaceInit, {'\xf0'}}); - ret.emplace_back(filename + ".dat", Containers::Array{Containers::InPlaceInit, {'\xfe', '\xed'}}); + ret.emplace_back(filename, Containers::Array{InPlaceInit, {'\xf0'}}); + ret.emplace_back(filename + ".dat", Containers::Array{InPlaceInit, {'\xfe', '\xed'}}); return ret; } } converter; diff --git a/src/Magnum/Text/Test/RendererGLTest.cpp b/src/Magnum/Text/Test/RendererGLTest.cpp index f099cf627..3013b4013 100644 --- a/src/Magnum/Text/Test/RendererGLTest.cpp +++ b/src/Magnum/Text/Test/RendererGLTest.cpp @@ -192,7 +192,7 @@ void RendererGLTest::renderMesh() { /* Vertex buffer contents */ Containers::Array vertices = vertexBuffer.data(); CORRADE_COMPARE_AS(Containers::arrayCast(vertices), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0.0f + offset.x(), 0.5f + offset.y(), 0.0f, 10.0f, 0.0f + offset.x(), 0.0f + offset.y(), 0.0f, 0.0f, 0.75f + offset.x(), 0.5f + offset.y(), 6.0f, 10.0f, @@ -207,15 +207,15 @@ void RendererGLTest::renderMesh() { 2.75f + offset.x(), -0.5f + offset.y(), 12.0f, 0.0f, 5.0f + offset.x(), 1.0f + offset.y(), 18.0f, 10.0f, 5.0f + offset.x(), -0.5f + offset.y(), 18.0f, 0.0f - }}), TestSuite::Compare::Container); + }), TestSuite::Compare::Container); Containers::Array indices = indexBuffer.data(); CORRADE_COMPARE_AS(Containers::arrayCast(indices), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0, 1, 2, 1, 3, 2, 4, 5, 6, 5, 7, 6, 8, 9, 10, 9, 11, 10 - }}), TestSuite::Compare::Container); + }), TestSuite::Compare::Container); #endif } @@ -236,11 +236,11 @@ void RendererGLTest::renderMeshIndexType() { CORRADE_COMPARE(vertexBuffer.size(), 256*(2 + 2)*4); CORRADE_COMPARE(indicesByte.size(), 64*6); CORRADE_COMPARE_AS(Containers::arrayCast(indicesByte).prefix(18), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0, 1, 2, 1, 3, 2, 4, 5, 6, 5, 7, 6, 8, 9, 10, 9, 11, 10 - }}), TestSuite::Compare::Container); + }), TestSuite::Compare::Container); /* 16-bit indices (260 vertices) */ std::tie(mesh, std::ignore) = Text::Renderer3D::render(font, nullGlyphCache, @@ -250,11 +250,11 @@ void RendererGLTest::renderMeshIndexType() { CORRADE_COMPARE(vertexBuffer.size(), 260*(2 + 2)*4); CORRADE_COMPARE(indicesShort.size(), 65*6*2); CORRADE_COMPARE_AS(Containers::arrayCast(indicesShort).prefix(18), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0, 1, 2, 1, 3, 2, 4, 5, 6, 5, 7, 6, 8, 9, 10, 9, 11, 10 - }}), TestSuite::Compare::Container); + }), TestSuite::Compare::Container); #else CORRADE_SKIP("Can't verify buffer contents on OpenGL ES."); #endif @@ -284,12 +284,12 @@ void RendererGLTest::mutableText() { #ifndef MAGNUM_TARGET_GLES Containers::Array indices = renderer.indexBuffer().data(); CORRADE_COMPARE_AS(Containers::arrayCast(indices).prefix(24), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0, 1, 2, 1, 3, 2, 4, 5, 6, 5, 7, 6, 8, 9, 10, 9, 11, 10, 12, 13, 14, 13, 15, 14 - }}), TestSuite::Compare::Container); + }), TestSuite::Compare::Container); #endif /* Render text */ @@ -305,7 +305,7 @@ void RendererGLTest::mutableText() { #ifndef MAGNUM_TARGET_GLES Containers::Array vertices = renderer.vertexBuffer().data(); CORRADE_COMPARE_AS(Containers::arrayCast(vertices).prefix(48), - (Containers::Array{Containers::InPlaceInit, { + Containers::arrayView({ 0.0f, 0.5f, 0.0f, 10.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.75f, 0.5f, 6.0f, 10.0f, @@ -320,7 +320,7 @@ void RendererGLTest::mutableText() { 2.75f, -0.5f, 12.0f, 0.0f, 5.0f, 1.0f, 18.0f, 10.0f, 5.0f, -0.5f, 18.0f, 0.0f - }}), TestSuite::Compare::Container); + }), TestSuite::Compare::Container); #endif } diff --git a/src/Magnum/Trade/Implementation/converterUtilities.h b/src/Magnum/Trade/Implementation/converterUtilities.h index a6ef9fa5d..c5f465342 100644 --- a/src/Magnum/Trade/Implementation/converterUtilities.h +++ b/src/Magnum/Trade/Implementation/converterUtilities.h @@ -57,7 +57,7 @@ Containers::Array imageInfo(AbstractImporter& importer, bool& error, error = true; continue; } - arrayAppend(infos, Containers::InPlaceInit, i, j, + arrayAppend(infos, InPlaceInit, i, j, image->isCompressed(), image->isCompressed() ? PixelFormat{} : image->format(), @@ -78,7 +78,7 @@ Containers::Array imageInfo(AbstractImporter& importer, bool& error, error = true; continue; } - arrayAppend(infos, Containers::InPlaceInit, i, j, + arrayAppend(infos, InPlaceInit, i, j, image->isCompressed(), image->isCompressed() ? PixelFormat{} : image->format(), @@ -99,7 +99,7 @@ Containers::Array imageInfo(AbstractImporter& importer, bool& error, error = true; continue; } - arrayAppend(infos, Containers::InPlaceInit, i, j, + arrayAppend(infos, InPlaceInit, i, j, image->isCompressed(), image->isCompressed() ? PixelFormat{} : image->format(), diff --git a/src/Magnum/Trade/Test/AnimationDataTest.cpp b/src/Magnum/Trade/Test/AnimationDataTest.cpp index a1d7a45cc..e32343670 100644 --- a/src/Magnum/Trade/Test/AnimationDataTest.cpp +++ b/src/Magnum/Trade/Test/AnimationDataTest.cpp @@ -116,7 +116,7 @@ void AnimationDataTest::constructTrackData() { nullptr, Animation::Interpolation::Linear, animationInterpolatorFor(Animation::Interpolation::Linear)}}; - AnimationData data{nullptr, Containers::Array{Containers::InPlaceInit, {trackData}}}; + AnimationData data{nullptr, Containers::Array{InPlaceInit, {trackData}}}; CORRADE_COMPARE(data.trackType(0), AnimationTrackType::Vector3); CORRADE_COMPARE(data.trackResultType(0), AnimationTrackType::Vector3); CORRADE_COMPARE(data.trackTargetType(0), AnimationTrackTargetType::Translation3D); @@ -133,7 +133,7 @@ void AnimationDataTest::constructTrackDataResultType() { nullptr, Animation::Interpolation::Linear, animationInterpolatorFor(Animation::Interpolation::Linear)}}; - AnimationData data{nullptr, Containers::Array{Containers::InPlaceInit, {trackData}}}; + AnimationData data{nullptr, Containers::Array{InPlaceInit, {trackData}}}; CORRADE_COMPARE(data.trackType(0), AnimationTrackType::CubicHermite3D); CORRADE_COMPARE(data.trackResultType(0), AnimationTrackType::Vector3); CORRADE_COMPARE(data.trackTargetType(0), AnimationTrackTargetType::Translation3D); @@ -148,7 +148,7 @@ void AnimationDataTest::constructTrackDataTemplate() { nullptr, Animation::Interpolation::Linear, animationInterpolatorFor(Animation::Interpolation::Linear)}}; - AnimationData data{nullptr, Containers::Array{Containers::InPlaceInit, {trackData}}}; + AnimationData data{nullptr, Containers::Array{InPlaceInit, {trackData}}}; CORRADE_COMPARE(data.trackType(0), AnimationTrackType::CubicHermite3D); CORRADE_COMPARE(data.trackResultType(0), AnimationTrackType::Vector3); CORRADE_COMPARE(data.trackTargetType(0), AnimationTrackTargetType::Translation3D); diff --git a/src/Magnum/Trade/Test/MaterialDataTest.cpp b/src/Magnum/Trade/Test/MaterialDataTest.cpp index 746f7ec5d..0c5824543 100644 --- a/src/Magnum/Trade/Test/MaterialDataTest.cpp +++ b/src/Magnum/Trade/Test/MaterialDataTest.cpp @@ -888,7 +888,7 @@ void MaterialDataTest::constructDuplicateAttribute() { CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions"); #endif - auto attributes = Containers::Array{Containers::InPlaceInit, { + Containers::Array attributes{InPlaceInit, { {MaterialAttribute::DoubleSided, true}, {MaterialAttribute::DiffuseTextureCoordinates, 5u}, {"highlightColor", 0x335566ff_rgbaf}, diff --git a/src/Magnum/Trade/Test/SkinDataTest.cpp b/src/Magnum/Trade/Test/SkinDataTest.cpp index 58e4e18ea..f7deb7780 100644 --- a/src/Magnum/Trade/Test/SkinDataTest.cpp +++ b/src/Magnum/Trade/Test/SkinDataTest.cpp @@ -125,8 +125,8 @@ void SkinDataTest::constructMove() { } void SkinDataTest::release() { - Containers::Array joints{Containers::InPlaceInit, {0, 2, 3}}; - Containers::Array inverseBindMatrices{Containers::InPlaceInit, { + Containers::Array joints{InPlaceInit, {0, 2, 3}}; + Containers::Array inverseBindMatrices{InPlaceInit, { Matrix3::translation(Vector2::yAxis(0.0f)), Matrix3::translation(Vector2::yAxis(2.0f)), Matrix3::translation(Vector2::yAxis(4.0f)) diff --git a/src/Magnum/Vk/DescriptorPool.cpp b/src/Magnum/Vk/DescriptorPool.cpp index aca95238e..ab4ca541f 100644 --- a/src/Magnum/Vk/DescriptorPool.cpp +++ b/src/Magnum/Vk/DescriptorPool.cpp @@ -48,7 +48,7 @@ DescriptorPoolCreateInfo::DescriptorPoolCreateInfo(const UnsignedInt maxSets, co Containers::ArrayView poolSizesCopy; _data = Containers::ArrayTuple{ - {Containers::NoInit, poolSizes.size(), poolSizesCopy} + {NoInit, poolSizes.size(), poolSizesCopy} }; for(std::size_t i = 0; i != poolSizes.size(); ++i) { CORRADE_ASSERT(poolSizes[i].second, diff --git a/src/Magnum/Vk/DescriptorSetLayout.cpp b/src/Magnum/Vk/DescriptorSetLayout.cpp index c6a9becd8..b62c2bc53 100644 --- a/src/Magnum/Vk/DescriptorSetLayout.cpp +++ b/src/Magnum/Vk/DescriptorSetLayout.cpp @@ -46,7 +46,7 @@ DescriptorSetLayoutBinding::DescriptorSetLayoutBinding(const UnsignedInt binding DescriptorSetLayoutBinding::DescriptorSetLayoutBinding(const UnsignedInt binding, const DescriptorType descriptorType, const Containers::ArrayView immutableSamplers, const ShaderStages stages, Flags flags): _binding{}, _flags{VkDescriptorBindingFlags(flags)} { Containers::ArrayView immutableSamplersCopy; _data = Containers::ArrayTuple{ - {Containers::NoInit, immutableSamplers.size(), immutableSamplersCopy} + {NoInit, immutableSamplers.size(), immutableSamplersCopy} }; Utility::copy(immutableSamplers, immutableSamplersCopy); @@ -109,10 +109,10 @@ DescriptorSetLayoutCreateInfo::DescriptorSetLayoutCreateInfo(const Containers::A Containers::ArrayView bindingsCreateInfoView; Containers::ArrayView immutableSamplersCopy; _data = Containers::ArrayTuple{ - {Containers::NoInit, bindings.size(), bindingsCopy}, - {Containers::NoInit, hasBindingFlags ? bindings.size() : 0, bindingFlagsCopy}, - {Containers::ValueInit, hasBindingFlags ? 1u : 0u, bindingsCreateInfoView}, - {Containers::NoInit, immutableSamplerCount, immutableSamplersCopy} + {NoInit, bindings.size(), bindingsCopy}, + {NoInit, hasBindingFlags ? bindings.size() : 0, bindingFlagsCopy}, + {ValueInit, hasBindingFlags ? 1u : 0u, bindingsCreateInfoView}, + {NoInit, immutableSamplerCount, immutableSamplersCopy} }; /* Copy the binding and then for each manually copy and reroute the diff --git a/src/Magnum/Vk/Device.cpp b/src/Magnum/Vk/Device.cpp index 1546130fc..245982a93 100644 --- a/src/Magnum/Vk/Device.cpp +++ b/src/Magnum/Vk/Device.cpp @@ -120,7 +120,7 @@ struct DeviceCreateInfo::State { DeviceProperties properties{NoCreate}; }; -DeviceCreateInfo::DeviceCreateInfo(DeviceProperties& deviceProperties, const ExtensionProperties* extensionProperties, const Flags flags): _physicalDevice{deviceProperties}, _info{}, _state{Containers::InPlaceInit} { +DeviceCreateInfo::DeviceCreateInfo(DeviceProperties& deviceProperties, const ExtensionProperties* extensionProperties, const Flags flags): _physicalDevice{deviceProperties}, _info{}, _state{InPlaceInit} { Utility::Arguments args = Implementation::arguments(); args.parse(deviceProperties._instance->state().argc, deviceProperties._instance->state().argv); @@ -307,7 +307,7 @@ DeviceCreateInfo& DeviceCreateInfo::addEnabledExtensions(const Containers::Array don't get invalidated when the array gets reallocated. */ const char* data; if(!(extension.flags() >= (Containers::StringViewFlag::NullTerminated|Containers::StringViewFlag::Global))) - data = arrayAppend(_state->ownedStrings, Containers::InPlaceInit, + data = arrayAppend(_state->ownedStrings, InPlaceInit, Containers::AllocatedInit, extension).data(); else data = extension.data(); diff --git a/src/Magnum/Vk/DeviceProperties.cpp b/src/Magnum/Vk/DeviceProperties.cpp index f3c2d3786..fd08daaf5 100644 --- a/src/Magnum/Vk/DeviceProperties.cpp +++ b/src/Magnum/Vk/DeviceProperties.cpp @@ -379,7 +379,7 @@ Containers::ArrayView DeviceProperties::queueFam UnsignedInt count; _state->getQueueFamilyPropertiesImplementation(*this, count, nullptr); - _state->queueFamilyProperties = Containers::Array{Containers::ValueInit, count}; + _state->queueFamilyProperties = Containers::Array{ValueInit, count}; for(VkQueueFamilyProperties2& i: _state->queueFamilyProperties) i.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2; _state->getQueueFamilyPropertiesImplementation(*this, count, _state->queueFamilyProperties); @@ -587,7 +587,7 @@ Containers::Array enumerateDevices(Instance& instance) { /* Fetch device handles, expect the device count didn't change between calls */ - Containers::Array out{Containers::NoInit, count}; + Containers::Array out{NoInit, count}; CORRADE_INTERNAL_ASSERT_OUTPUT(Implementation::enumerateDevicesInto(instance, out) == out.size()); return out; @@ -599,7 +599,7 @@ Containers::Optional tryPickDevice(Instance& instance) { /* Pick the first by default */ if(args.value("device").empty()) { - Containers::Array1 devices{Containers::NoInit}; + Containers::Array1 devices{NoInit}; if(!Implementation::enumerateDevicesInto(instance, devices)) { Error{} << "Vk::tryPickDevice(): no Vulkan devices found"; return {}; @@ -611,7 +611,7 @@ Containers::Optional tryPickDevice(Instance& instance) { /* Pick by ID */ if(args.value("device")[0] >= '0' && args.value("device")[0] <= '9') { const UnsignedInt id = args.value("device"); - Containers::Array devices{Containers::NoInit, id + 1}; + Containers::Array devices{NoInit, id + 1}; const UnsignedInt count = Implementation::enumerateDevicesInto(instance, devices); if(id >= count) { Error{} << "Vk::tryPickDevice(): index" << id << "out of bounds for" << count << "Vulkan devices"; diff --git a/src/Magnum/Vk/Framebuffer.cpp b/src/Magnum/Vk/Framebuffer.cpp index 70f69c14b..438c2f360 100644 --- a/src/Magnum/Vk/Framebuffer.cpp +++ b/src/Magnum/Vk/Framebuffer.cpp @@ -40,7 +40,7 @@ struct FramebufferCreateInfo::State { Containers::Array attachments; }; -FramebufferCreateInfo::FramebufferCreateInfo(const VkRenderPass renderPass, const Containers::ArrayView> attachments, const Vector3i& size, const Flags flags): _info{}, _state{Containers::InPlaceInit} { +FramebufferCreateInfo::FramebufferCreateInfo(const VkRenderPass renderPass, const Containers::ArrayView> attachments, const Vector3i& size, const Flags flags): _info{}, _state{InPlaceInit} { _info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; _info.flags = VkFramebufferCreateFlags(flags); _info.renderPass = renderPass; @@ -52,7 +52,7 @@ FramebufferCreateInfo::FramebufferCreateInfo(const VkRenderPass renderPass, cons /** @todo combine the state and array allocations into one (could use ArrayTuple, however that one includes ArrayView so not much better than including Array directly in the header which I don't want to do) */ - _state->attachments = Containers::Array{Containers::NoInit, attachments.size()}; + _state->attachments = Containers::Array{NoInit, attachments.size()}; for(std::size_t i = 0; i != attachments.size(); ++i) _state->attachments[i] = *attachments[i]; _info.attachmentCount = _state->attachments.size(); diff --git a/src/Magnum/Vk/Implementation/DriverWorkaround.cpp b/src/Magnum/Vk/Implementation/DriverWorkaround.cpp index 3df15b989..1caf65fb5 100644 --- a/src/Magnum/Vk/Implementation/DriverWorkaround.cpp +++ b/src/Magnum/Vk/Implementation/DriverWorkaround.cpp @@ -100,13 +100,13 @@ void disableWorkaround(Containers::Array return; } - arrayAppend(encounteredWorkarounds, Containers::InPlaceInit, found, true); + arrayAppend(encounteredWorkarounds, InPlaceInit, found, true); } Containers::Array> disableAllWorkarounds() { Containers::Array> encounteredWorkarounds; for(const Containers::StringView i: KnownWorkarounds) - arrayAppend(encounteredWorkarounds, Containers::InPlaceInit, i, true); + arrayAppend(encounteredWorkarounds, InPlaceInit, i, true); return encounteredWorkarounds; } @@ -123,7 +123,7 @@ bool isDriverWorkaroundDisabled(Containers::Array vertexInterface, fragmentInterface; Containers::ArrayTuple interfaceData{ - {Containers::ValueInit, vertexEntryPoint->interfaces.size(), vertexInterface}, - {Containers::ValueInit, fragmentEntryPoint->interfaces.size(), fragmentInterface} + {ValueInit, vertexEntryPoint->interfaces.size(), vertexInterface}, + {ValueInit, fragmentEntryPoint->interfaces.size(), fragmentInterface} }; spirvEntrypointInterface(data, *vertexEntryPoint, vertexInterface); spirvEntrypointInterface(data, *fragmentEntryPoint, fragmentInterface); diff --git a/src/Magnum/Vk/Instance.cpp b/src/Magnum/Vk/Instance.cpp index 3134c5858..d89ad4a36 100644 --- a/src/Magnum/Vk/Instance.cpp +++ b/src/Magnum/Vk/Instance.cpp @@ -189,7 +189,7 @@ InstanceCreateInfo& InstanceCreateInfo::addEnabledLayers(const Containers::Array don't get invalidated when the array gets reallocated. */ const char* data; if(!(layer.flags() >= (Containers::StringViewFlag::NullTerminated|Containers::StringViewFlag::Global))) - data = arrayAppend(_state->ownedStrings, Containers::InPlaceInit, + data = arrayAppend(_state->ownedStrings, InPlaceInit, Containers::AllocatedInit, layer).data(); else data = layer.data(); @@ -223,7 +223,7 @@ InstanceCreateInfo& InstanceCreateInfo::addEnabledExtensions(const Containers::A don't get invalidated when the array gets reallocated. */ const char* data; if(!(extension.flags() >= (Containers::StringViewFlag::NullTerminated|Containers::StringViewFlag::Global))) - data = arrayAppend(_state->ownedStrings, Containers::InPlaceInit, + data = arrayAppend(_state->ownedStrings, InPlaceInit, Containers::AllocatedInit, extension).data(); else data = extension.data(); diff --git a/src/Magnum/Vk/Mesh.cpp b/src/Magnum/Vk/Mesh.cpp index d174419df..f304ed758 100644 --- a/src/Magnum/Vk/Mesh.cpp +++ b/src/Magnum/Vk/Mesh.cpp @@ -91,10 +91,10 @@ Mesh::Mesh(MeshLayout&& layout): _layout{std::move(layout)} { if(const UnsignedInt count = _layout.vkPipelineVertexInputStateCreateInfo().vertexBindingDescriptionCount) { _state.emplace(); _state->vertexBufferData = Containers::ArrayTuple{ - {Containers::ValueInit, count, _state->vertexBuffers}, - {Containers::ValueInit, count, _state->vertexBufferOffsets}, - {Containers::ValueInit, count, _state->vertexBufferStrides}, - {Containers::NoInit, count, _state->ownedVertexBuffers} + {ValueInit, count, _state->vertexBuffers}, + {ValueInit, count, _state->vertexBufferOffsets}, + {ValueInit, count, _state->vertexBufferStrides}, + {NoInit, count, _state->ownedVertexBuffers} }; /** @tod use DirectInit once ArrayTuple can do that */ diff --git a/src/Magnum/Vk/Pipeline.cpp b/src/Magnum/Vk/Pipeline.cpp index 217d9fec0..22d7f143e 100644 --- a/src/Magnum/Vk/Pipeline.cpp +++ b/src/Magnum/Vk/Pipeline.cpp @@ -54,7 +54,7 @@ struct RasterizationPipelineCreateInfo::State { VkRect2D scissor; }; -RasterizationPipelineCreateInfo::RasterizationPipelineCreateInfo(const ShaderSet& shaderSet, const MeshLayout& meshLayout, const VkPipelineLayout pipelineLayout, const VkRenderPass renderPass, const UnsignedInt subpass, const UnsignedInt subpassColorAttachmentCount, Flags flags): _info{}, _viewportInfo{}, _rasterizationInfo{}, _multisampleInfo{}, _depthStencilInfo{}, _colorBlendInfo{}, _dynamicInfo{}, _state{Containers::InPlaceInit} { +RasterizationPipelineCreateInfo::RasterizationPipelineCreateInfo(const ShaderSet& shaderSet, const MeshLayout& meshLayout, const VkPipelineLayout pipelineLayout, const VkRenderPass renderPass, const UnsignedInt subpass, const UnsignedInt subpassColorAttachmentCount, Flags flags): _info{}, _viewportInfo{}, _rasterizationInfo{}, _multisampleInfo{}, _depthStencilInfo{}, _colorBlendInfo{}, _dynamicInfo{}, _state{InPlaceInit} { _info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; _info.flags = VkPipelineCreateFlags(flags); _info.stageCount = shaderSet.stages().size(); @@ -82,7 +82,7 @@ RasterizationPipelineCreateInfo::RasterizationPipelineCreateInfo(const ShaderSet _depthStencilInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; _info.pDepthStencilState = &_depthStencilInfo; - _state->colorBlendAttachments = Containers::Array{Containers::ValueInit, subpassColorAttachmentCount}; + _state->colorBlendAttachments = Containers::Array{ValueInit, subpassColorAttachmentCount}; for(VkPipelineColorBlendAttachmentState& i: _state->colorBlendAttachments) { i.colorWriteMask = VK_COLOR_COMPONENT_R_BIT| VK_COLOR_COMPONENT_G_BIT| @@ -254,7 +254,7 @@ RasterizationPipelineCreateInfo& RasterizationPipelineCreateInfo::setDynamicStat std::size_t count = 0; for(std::size_t i = 0; i != DynamicRasterizationStates::Size; ++i) count += Math::popcount(states.data()[i]); - _state->dynamicStateList = Containers::Array{Containers::NoInit, count}; + _state->dynamicStateList = Containers::Array{NoInit, count}; std::size_t offset = 0; for(std::uint64_t i = 0; i != Containers::arraySize(DynamicRasterizationStateMapping); ++i) diff --git a/src/Magnum/Vk/PipelineLayout.cpp b/src/Magnum/Vk/PipelineLayout.cpp index a4e5bcd9c..f36778811 100644 --- a/src/Magnum/Vk/PipelineLayout.cpp +++ b/src/Magnum/Vk/PipelineLayout.cpp @@ -39,7 +39,7 @@ PipelineLayoutCreateInfo::PipelineLayoutCreateInfo(const Containers::ArrayView descriptorSetLayoutsCopy; _data = Containers::ArrayTuple{ - {Containers::NoInit, descriptorSetLayouts.size(), descriptorSetLayoutsCopy} + {NoInit, descriptorSetLayouts.size(), descriptorSetLayoutsCopy} }; Utility::copy(descriptorSetLayouts, descriptorSetLayoutsCopy); diff --git a/src/Magnum/Vk/Queue.cpp b/src/Magnum/Vk/Queue.cpp index 378437713..50dd8957d 100644 --- a/src/Magnum/Vk/Queue.cpp +++ b/src/Magnum/Vk/Queue.cpp @@ -73,7 +73,7 @@ void Queue::submit(const Containers::ArrayView vkInfos{Containers::NoInit, infos.size()}; + Containers::Array vkInfos{NoInit, infos.size()}; for(std::size_t i = 0; i != infos.size(); ++i) vkInfos[i] = *infos[i]; @@ -140,7 +140,7 @@ SubmitInfo& SubmitInfo::operator=(SubmitInfo&& other) noexcept { SubmitInfo& SubmitInfo::setCommandBuffers(const Containers::ArrayView buffers) { if(!_state) _state.emplace(); - _state->commandBuffers = Containers::Array{Containers::NoInit, buffers.size()}; + _state->commandBuffers = Containers::Array{NoInit, buffers.size()}; Utility::copy(buffers, _state->commandBuffers); _info.commandBufferCount = _state->commandBuffers.size(); _info.pCommandBuffers = _state->commandBuffers; diff --git a/src/Magnum/Vk/RenderPass.cpp b/src/Magnum/Vk/RenderPass.cpp index bbe038415..0d777da9b 100644 --- a/src/Magnum/Vk/RenderPass.cpp +++ b/src/Magnum/Vk/RenderPass.cpp @@ -199,7 +199,7 @@ SubpassDescription::SubpassDescription(const VkSubpassDescription& description): nullptr, description.preserveAttachmentCount, description.pPreserveAttachments -}, _state{Containers::InPlaceInit} { +}, _state{InPlaceInit} { /* Convert all attachment references to the "version 2" format */ setInputAttachmentsInternal({description.pInputAttachments, description.inputAttachmentCount}); setColorAttachmentsInternal({description.pColorAttachments, description.colorAttachmentCount}, {description.pResolveAttachments, description.pResolveAttachments ? description.colorAttachmentCount : 0}); @@ -450,7 +450,7 @@ Containers::Array SubpassDescription::vkSubpassDescription converted VkAttachmentReference instances it needs. Expect the default deleter is used so we don't need to wrap some other below. */ const std::size_t extrasSize = vkSubpassDescriptionExtrasSize(_description); - Containers::Array storage{Containers::NoInit, sizeof(VkSubpassDescription) + extrasSize}; + Containers::Array storage{NoInit, sizeof(VkSubpassDescription) + extrasSize}; CORRADE_INTERNAL_ASSERT(!storage.deleter()); /* Fill it with data and return, faking a size of 1 and with a custom @@ -702,7 +702,7 @@ Containers::Array RenderPassCreateInfo::vkRenderPassCrea /* Allocate an array to fit VkRenderPassCreateInfo together with all extras it needs. Expect the default deleter is used so we don't need to wrap some other below. */ - Containers::Array storage{Containers::NoInit, sizeof(VkRenderPassCreateInfo) + structuresSize + extrasSize}; + Containers::Array storage{NoInit, sizeof(VkRenderPassCreateInfo) + structuresSize + extrasSize}; CORRADE_INTERNAL_ASSERT(!storage.deleter()); /* Copy what can be copied for the output info struct. The pointers will be @@ -889,7 +889,7 @@ RenderPassBeginInfo& RenderPassBeginInfo::clearDepthStencil(const UnsignedInt at RenderPassBeginInfo& RenderPassBeginInfo::clearInternal(const UnsignedInt attachment, const VkClearValue& value) { if(!_state) _state.emplace(); if(_state->clearValues.size() <= attachment) - arrayResize(_state->clearValues, Containers::NoInit, attachment + 1); + arrayResize(_state->clearValues, NoInit, attachment + 1); _state->clearValues[attachment] = value; _info.clearValueCount = _state->clearValues.size(); _info.pClearValues = _state->clearValues; diff --git a/src/Magnum/Vk/Shader.cpp b/src/Magnum/Vk/Shader.cpp index f5b4557ac..64c462730 100644 --- a/src/Magnum/Vk/Shader.cpp +++ b/src/Magnum/Vk/Shader.cpp @@ -137,7 +137,7 @@ VkResult Shader::createImplementationSwiftShaderMultiEntryPointPatching(Device& might not need to copy it, the owned code may also be read-only for whatever reason (memory-mapped location etc). Thus, to prevent issues, we go the safe route and copy always. */ - Containers::Array mutableCode{Containers::NoInit, info.codeSize}; + Containers::Array mutableCode{NoInit, info.codeSize}; Utility::copy(Containers::arrayView(reinterpret_cast(info.pCode), info.codeSize), mutableCode); /* If the code looks like SPIR-V, patch it. If not, supply the original and diff --git a/src/Magnum/Vk/ShaderSet.cpp b/src/Magnum/Vk/ShaderSet.cpp index 06f121ddd..96f7c5c79 100644 --- a/src/Magnum/Vk/ShaderSet.cpp +++ b/src/Magnum/Vk/ShaderSet.cpp @@ -82,7 +82,7 @@ ShaderSet& ShaderSet::addShader(const ShaderStage stage, const VkShaderModule sh if(!_state) _state.emplace(); /* Ensure the data are never SSO'd and so when the array reallocates we don't need to rewire existing name pointers */ - _stages[_stageCount].pName = arrayAppend(_state->entrypointNames, Containers::InPlaceInit, Containers::AllocatedInit, entrypoint).data(); + _stages[_stageCount].pName = arrayAppend(_state->entrypointNames, InPlaceInit, Containers::AllocatedInit, entrypoint).data(); } /* Specialization, also only if there are any to avoid allocating the state @@ -98,8 +98,8 @@ ShaderSet& ShaderSet::addShader(const ShaderStage stage, const VkShaderModule sh /* The data is (currently) always four bytes, so we don't need to do any extra work to calculate the total data size over all specializations */ - const Containers::ArrayView newSpecializationData = arrayAppend(_state->specializationData, Containers::NoInit, specializations.size()*4); - const Containers::ArrayView newSpecializations = arrayAppend(_state->specializations, Containers::NoInit, specializations.size()); + const Containers::ArrayView newSpecializationData = arrayAppend(_state->specializationData, NoInit, specializations.size()*4); + const Containers::ArrayView newSpecializations = arrayAppend(_state->specializations, NoInit, specializations.size()); /* Reroute the existing structures for possible reallocations */ for(std::size_t i = 0; i != _stageCount; ++i) { diff --git a/src/Magnum/Vk/Test/PipelineTest.cpp b/src/Magnum/Vk/Test/PipelineTest.cpp index d34971934..920826140 100644 --- a/src/Magnum/Vk/Test/PipelineTest.cpp +++ b/src/Magnum/Vk/Test/PipelineTest.cpp @@ -306,11 +306,11 @@ void PipelineTest::rasterizationCreateInfoConstructMove() { MeshLayout meshLayout{MeshPrimitive::Triangles}; - Containers::Pointer a{Containers::InPlaceInit, shaderSet, meshLayout, VkPipelineLayout{}, VkRenderPass{}, 0u, 3u}; + Containers::Pointer a{InPlaceInit, shaderSet, meshLayout, VkPipelineLayout{}, VkRenderPass{}, 0u, 3u}; (*a).setViewport(Range3D{}) .setDynamicStates(DynamicRasterizationState::CullMode); - Containers::Pointer b{Containers::InPlaceInit, std::move(*a)}; + Containers::Pointer b{InPlaceInit, std::move(*a)}; CORRADE_COMPARE((**a).stageCount, 0); CORRADE_VERIFY(!(**a).pStages); CORRADE_VERIFY(!(**a).pVertexInputState); @@ -344,7 +344,7 @@ void PipelineTest::rasterizationCreateInfoConstructMove() { CORRADE_VERIFY((**b).pDynamicState); CORRADE_COMPARE((**b).pDynamicState->sType, VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO); - Containers::Pointer c{Containers::InPlaceInit, VkGraphicsPipelineCreateInfo{}}; + Containers::Pointer c{InPlaceInit, VkGraphicsPipelineCreateInfo{}}; *c = std::move(*b); CORRADE_COMPARE((**b).stageCount, 0); CORRADE_VERIFY(!(**b).pStages); diff --git a/src/Magnum/Vk/Test/RenderPassTest.cpp b/src/Magnum/Vk/Test/RenderPassTest.cpp index 2432b49a0..653d8a854 100644 --- a/src/Magnum/Vk/Test/RenderPassTest.cpp +++ b/src/Magnum/Vk/Test/RenderPassTest.cpp @@ -242,7 +242,7 @@ template struct Traits; static const char* name() { return #type "2"; } \ /* So we have the same interface in both cases */ \ static Containers::Array convert(const type& instance) { \ - return {Containers::InPlaceInit, {*instance}}; \ + return {InPlaceInit, {*instance}}; \ } \ }; _c(AttachmentDescription) diff --git a/src/MagnumPlugins/AnyShaderConverter/AnyConverter.cpp b/src/MagnumPlugins/AnyShaderConverter/AnyConverter.cpp index 26e98ac27..274334d83 100644 --- a/src/MagnumPlugins/AnyShaderConverter/AnyConverter.cpp +++ b/src/MagnumPlugins/AnyShaderConverter/AnyConverter.cpp @@ -49,7 +49,7 @@ struct AnyConverter::State { AnyConverter::AnyConverter(PluginManager::Manager& manager): AbstractConverter{manager} {} -AnyConverter::AnyConverter(PluginManager::AbstractManager& manager, const std::string& plugin): AbstractConverter{manager, plugin}, _state{Containers::InPlaceInit} {} +AnyConverter::AnyConverter(PluginManager::AbstractManager& manager, const std::string& plugin): AbstractConverter{manager, plugin}, _state{InPlaceInit} {} AnyConverter::~AnyConverter() = default; diff --git a/src/MagnumPlugins/MagnumFontConverter/Test/MagnumFontConverterTest.cpp b/src/MagnumPlugins/MagnumFontConverter/Test/MagnumFontConverterTest.cpp index 9e92f6e67..d6daccd20 100644 --- a/src/MagnumPlugins/MagnumFontConverter/Test/MagnumFontConverterTest.cpp +++ b/src/MagnumPlugins/MagnumFontConverter/Test/MagnumFontConverterTest.cpp @@ -125,7 +125,7 @@ void MagnumFontConverterTest::exportFont() { GlyphCacheFeatures doFeatures() const override { return GlyphCacheFeature::ImageDownload; } void doSetImage(const Vector2i&, const ImageView2D&) override {} Image2D doImage() override { - return Image2D{PixelFormat::R8Unorm, Vector2i{256}, Containers::Array{Containers::ValueInit, 256*256}}; + return Image2D{PixelFormat::R8Unorm, Vector2i{256}, Containers::Array{ValueInit, 256*256}}; } } cache; cache.insert(font.glyphId(U'W'), {25, 34}, {{0, 8}, {16, 128}}); diff --git a/src/MagnumPlugins/ObjImporter/ObjImporter.cpp b/src/MagnumPlugins/ObjImporter/ObjImporter.cpp index f5f203876..0fc084ff1 100644 --- a/src/MagnumPlugins/ObjImporter/ObjImporter.cpp +++ b/src/MagnumPlugins/ObjImporter/ObjImporter.cpp @@ -429,7 +429,7 @@ Containers::Optional ObjImporter::doMesh(UnsignedInt id, UnsignedInt) /* Merge index arrays. If any of the attributes was not there, the whole index array has zeros, not affecting the uniqueness in any way. */ - Containers::Array indexData{Containers::NoInit, indices.size()*sizeof(UnsignedInt)}; + Containers::Array indexData{NoInit, indices.size()*sizeof(UnsignedInt)}; const auto indexDataI = Containers::arrayCast(indexData); const std::size_t vertexCount = MeshTools::removeDuplicatesInPlaceInto( Containers::arrayCast<2, char>(arrayView(indices)), indexDataI); @@ -446,7 +446,7 @@ Containers::Optional ObjImporter::doMesh(UnsignedInt id, UnsignedInt) stride += sizeof(Vector2); } Containers::Array attributeData{attributeCount}; - Containers::Array vertexData{Containers::NoInit, vertexCount*stride}; + Containers::Array vertexData{NoInit, vertexCount*stride}; /* Duplicate the vertices into the output */ const auto indicesPerAttribute = Containers::arrayCast<2, const UnsignedInt>(stridedArrayView(indices)).transposed<0, 1>(); diff --git a/src/MagnumPlugins/TgaImageConverter/TgaImageConverter.cpp b/src/MagnumPlugins/TgaImageConverter/TgaImageConverter.cpp index ca1a4e3c1..6ff0395b9 100644 --- a/src/MagnumPlugins/TgaImageConverter/TgaImageConverter.cpp +++ b/src/MagnumPlugins/TgaImageConverter/TgaImageConverter.cpp @@ -48,7 +48,7 @@ ImageConverterFeatures TgaImageConverter::doFeatures() const { return ImageConve Containers::Array TgaImageConverter::doConvertToData(const ImageView2D& image) { /* Initialize data buffer */ const auto pixelSize = UnsignedByte(image.pixelSize()); - Containers::Array data{Containers::ValueInit, sizeof(Implementation::TgaHeader) + pixelSize*image.size().product()}; + Containers::Array data{ValueInit, sizeof(Implementation::TgaHeader) + pixelSize*image.size().product()}; /* Fill header */ auto header = reinterpret_cast(data.begin());