ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10694 Commits
21 Branches
19 Tags
70 MiB
Tree: 8f8dcd0076
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8f8dcd0076'
${ noResults }
magnum/src/Magnum/TextureTools/Test/AtlasTest.cpp

1230 lines
42 KiB
Raw Normal View History Unescape

New TextureTools library with joke implementation of atlas packer.
14 years ago
/*
This file is part of Magnum.
Updated copyright year.
6 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
It's 2023 already!
3 years ago
2020, 2021, 2022, 2023 Vladimír Vondruš <mosra@centrum.cz>
Relicensing to MIT/Expat license, part 3: source files. Added license header also to shader sources. Hopefully it won't harm compilation times too much.
13 years ago
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
New TextureTools library with joke implementation of atlas packer.
14 years ago
Relicensing to MIT/Expat license, part 3: source files. Added license header also to shader sources. Hopefully it won't harm compilation times too much.
13 years ago
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
New TextureTools library with joke implementation of atlas packer.
14 years ago
*/
#include <sstream>
TextureTools: forward-declare std::vector for this awful old function. Needs to be eventually reworked/deleted anyway, but that's not the goal now.
4 years ago
#include <vector>
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
#include <Corrade/Containers/Array.h>
TextureTools: new landfill atlas packer. Just the dumbest possible idea I had, and it compares surprisingly well in both efficiency (~comparable to stb_rect_pack) and speed (significantly faster than stb_rect_pack with tons of tiny images, slower with larger ones -- would probably need to SIMD Math::max() and such, haha). It's the very first implementation without any additional improvements I have in mind, so it'll likely improve further. Includes a benchmark with a bunch of "datasets" extracted from both fonts and large glTF models. The stb_rect_pack file isn't commited as it's not useful apart from this single benchmark, put it to AtlasTestFiles/ and recompile.
3 years ago
#include <Corrade/Containers/StridedBitArrayView.h>
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
#include <Corrade/Containers/Pair.h>
TextureTools: take a strided view in atlasArrayPowerOfTwo(). Together with the parent commit, it's now possible to do THE UNTHINKABLE: Containers::Array<Trade::ImageData2D> inputImages = ...; auto out = TextureTools::atlasArrayPowerOfTwo({2048, 2048}, stridedArrayView(inputImages).slice(&Trade::ImageData2D::size)); An actual use case, in fact. Because why not.
4 years ago
#include <Corrade/Containers/StridedArrayView.h>
TextureTools: new landfill atlas packer. Just the dumbest possible idea I had, and it compares surprisingly well in both efficiency (~comparable to stb_rect_pack) and speed (significantly faster than stb_rect_pack with tons of tiny images, slower with larger ones -- would probably need to SIMD Math::max() and such, haha). It's the very first implementation without any additional improvements I have in mind, so it'll likely improve further. Includes a benchmark with a bunch of "datasets" extracted from both fonts and large glTF models. The stb_rect_pack file isn't commited as it's not useful apart from this single benchmark, put it to AtlasTestFiles/ and recompile.
3 years ago
#include <Corrade/Containers/StringStl.h> /** @todo remove once Debug is stream-free */
Making includes absolute, part 4: using absolute includes for Corrade. Also adapted to some Corrade renames.
12 years ago
#include <Corrade/TestSuite/Tester.h>
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
#include <Corrade/TestSuite/Compare/Container.h>
TextureTools: new landfill atlas packer. Just the dumbest possible idea I had, and it compares surprisingly well in both efficiency (~comparable to stb_rect_pack) and speed (significantly faster than stb_rect_pack with tons of tiny images, slower with larger ones -- would probably need to SIMD Math::max() and such, haha). It's the very first implementation without any additional improvements I have in mind, so it'll likely improve further. Includes a benchmark with a bunch of "datasets" extracted from both fonts and large glTF models. The stb_rect_pack file isn't commited as it's not useful apart from this single benchmark, put it to AtlasTestFiles/ and recompile.
3 years ago
#include <Corrade/TestSuite/Compare/String.h>
Adapted to Corrade changes. Mostly missing includes now.
7 years ago
#include <Corrade/Utility/DebugStl.h>
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
#include <Corrade/Utility/FormatStl.h>
New TextureTools library with joke implementation of atlas packer.
14 years ago
Making includes absolute, part 5: absolute includes everywhere. The only places where they aren't absolute are: - when header is included from corresponding source file - when including headers which are not part of final installation (e.g. test-specific configuration, headers from Implementation/)
12 years ago
#include "Magnum/Math/Range.h"
#include "Magnum/TextureTools/Atlas.h"
New TextureTools library with joke implementation of atlas packer.
14 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
namespace Magnum { namespace TextureTools { namespace Test { namespace {
New TextureTools library with joke implementation of atlas packer.
14 years ago
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
struct AtlasTest: TestSuite::Tester {
explicit AtlasTest();
Got rid of header files in tests. They have no practical use and they only bloat codebase size and add maintenance burden.
14 years ago
TextureTools: new landfill atlas packer. Just the dumbest possible idea I had, and it compares surprisingly well in both efficiency (~comparable to stb_rect_pack) and speed (significantly faster than stb_rect_pack with tons of tiny images, slower with larger ones -- would probably need to SIMD Math::max() and such, haha). It's the very first implementation without any additional improvements I have in mind, so it'll likely improve further. Includes a benchmark with a bunch of "datasets" extracted from both fonts and large glTF models. The stb_rect_pack file isn't commited as it's not useful apart from this single benchmark, put it to AtlasTestFiles/ and recompile.
3 years ago
void debugLandfillFlag();
void debugLandfillFlags();
void landfillFullFit();
void landfill();
void landfillIncremental();
void landfillNoFit();
void landfillCopy();
void landfillMove();
void landfillArrayFullFit();
void landfillArray();
void landfillArrayIncremental();
void landfillArrayNoFit();
void landfillArrayCopy();
void landfillArrayMove();
void landfillInvalidSize();
void landfillSetFlagsInvalid();
void landfillAddMissingRotations();
void landfillAddInvalidViewSizes();
void landfillAddTooLargeElement();
TextureTools: forward-declare std::vector for this awful old function. Needs to be eventually reworked/deleted anyway, but that's not the goal now.
4 years ago
void basic();
void padding();
void empty();
void tooSmall();
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
void arrayPowerOfTwoEmpty();
void arrayPowerOfTwoSingleElement();
void arrayPowerOfTwoAllSameElements();
void arrayPowerOfTwoOneLayer();
void arrayPowerOfTwoMoreLayers();
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
void arrayPowerOfTwoInvalidViewSizes();
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
void arrayPowerOfTwoWrongLayerSize();
void arrayPowerOfTwoWrongSize();
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
void arrayPowerOfTwoDeprecated();
#endif
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
};
TextureTools: new landfill atlas packer. Just the dumbest possible idea I had, and it compares surprisingly well in both efficiency (~comparable to stb_rect_pack) and speed (significantly faster than stb_rect_pack with tons of tiny images, slower with larger ones -- would probably need to SIMD Math::max() and such, haha). It's the very first implementation without any additional improvements I have in mind, so it'll likely improve further. Includes a benchmark with a bunch of "datasets" extracted from both fonts and large glTF models. The stb_rect_pack file isn't commited as it's not useful apart from this single benchmark, put it to AtlasTestFiles/ and recompile.
3 years ago
const Vector2i LandfillSizes[]{
{3, 6}, /* 0 */
{2, 5}, /* 1 */
{4, 2}, /* 2 */
{3, 3}, /* 3 */
{2, 3}, /* 4 */
{3, 3}, /* 5 */
{2, 2}, /* 6 */
{2, 1}, /* 7 */
{2, 2}, /* 8 */
{2, 2}, /* 9 */
{2, 1}, /* a */
{1, 2}, /* b */
{1, 1}, /* c */
};
const struct {
const char* name;
AtlasLandfillFlags flags;
Vector2i size;
Vector2i filledSize;
Containers::Pair<Vector2i, bool> offsetsFlips[Containers::arraySize(LandfillSizes)];
} LandfillData[]{
/* In all of these, rectangles with the same size should keep their order.
5 after 3, 9 after 8 after 6 (and b after a after 7 if they're rotated
to the same orientation) */
{"no rotation, no width sorting", {}, {11, 12}, {11, 10}, {
/* 99b
99b77
8866 aac
88662222
000 2222555
00011 555
00011 555
0001133344
0001133344
0001133344 */
{{0, 0}, false}, /* 0 */
{{3, 0}, false}, /* 1 */
{{4, 5}, false}, /* 2 */
{{5, 0}, false}, /* 3 */
{{8, 0}, false}, /* 4 */
{{8, 3}, false}, /* 5 */
{{2, 6}, false}, /* 6 */
{{3, 8}, false}, /* 7 */
{{0, 6}, false}, /* 8 */
{{0, 8}, false}, /* 9 */
{{5, 7}, false}, /* a */
{{2, 8}, false}, /* b */
{{7, 7}, false}}}, /* c */
/* No rotation with width sorting omitted, not interesting */
{"portrait, no width sorting", AtlasLandfillFlag::RotatePortrait, {11, 12}, {11, 10}, {
/* 99a
99ab
88bc
88766555
00076655544
00011 55544
0001122 44
0001122333
0001122333
0001122333 */
{{0, 0}, false}, /* 0 */
{{3, 0}, false}, /* 1 */
{{5, 0}, true}, /* 2 */
{{7, 0}, false}, /* 3 */
{{9, 3}, false}, /* 4 */
{{6, 4}, false}, /* 5 */
{{4, 5}, false}, /* 6 */
{{3, 5}, true}, /* 7 */
{{1, 6}, false}, /* 8 */
{{0, 8}, false}, /* 9 */
{{2, 8}, true}, /* a */
{{3, 7}, false}, /* b */
{{4, 7}, false}}}, /* c */
{"portrait, widest first", AtlasLandfillFlag::RotatePortrait|AtlasLandfillFlag::WidestFirst, {11, 12}, {11, 10}, {
/* 7ab
7abc
9988
99886644
000 6644555
00011 44555
0001122 555
0001122333
0001122333
0001122333 */
{{0, 0}, false}, /* 0 */
{{3, 0}, false}, /* 1 */
{{5, 0}, true}, /* 2 */
{{7, 0}, false}, /* 3 */
{{6, 4}, false}, /* 4 */
{{8, 3}, false}, /* 5 */
{{4, 5}, false}, /* 6 */
{{0, 8}, true}, /* 7 */
{{2, 6}, false}, /* 8 */
{{0, 6}, false}, /* 9 */
{{1, 8}, true}, /* a */
{{2, 8}, false}, /* b */
{{3, 8}, false}}}, /* c */
{"portrait, widest first, unbounded height", AtlasLandfillFlag::RotatePortrait|AtlasLandfillFlag::WidestFirst, {11, 0}, {11, 10}, {
/* Should have the same result as above
7ab
7abc
9988
99886644
000 6644555
00011 44555
0001122 555
0001122333
0001122333
0001122333 */
{{0, 0}, false}, /* 0 */
{{3, 0}, false}, /* 1 */
{{5, 0}, true}, /* 2 */
{{7, 0}, false}, /* 3 */
{{6, 4}, false}, /* 4 */
{{8, 3}, false}, /* 5 */
{{4, 5}, false}, /* 6 */
{{0, 8}, true}, /* 7 */
{{2, 6}, false}, /* 8 */
{{0, 6}, false}, /* 9 */
{{1, 8}, true}, /* a */
{{2, 8}, false}, /* b */
{{3, 8}, false}}}, /* c */
{"portrait, narrowest first", AtlasLandfillFlag::RotatePortrait|AtlasLandfillFlag::NarrowestFirst, {11, 12}, {11, 10}, {
/* 8899
8899
66b c
66ba7555
000a7555333
00011555333
0001122 333
000112244
000112244
000112244 */
{{0, 0}, false}, /* 0 */
{{3, 0}, false}, /* 1 */
{{5, 0}, true}, /* 2 */
{{8, 3}, false}, /* 3 */
{{7, 0}, false}, /* 4 */
{{5, 4}, false}, /* 5 */
{{0, 6}, false}, /* 6 */
{{4, 5}, true}, /* 7 */
{{0, 8}, false}, /* 8 */
{{2, 8}, false}, /* 9 */
{{3, 5}, true}, /* a */
{{2, 6}, false}, /* b */
{{4, 7}, false}}}, /* c */
{"landscape, no width sorting", AtlasLandfillFlag::RotateLandscape, {11, 12}, {11, 10}, {
/* 99
7799
cbbaa6688
22224446688
2222444 555
11111555
11111555
000000333
000000333
000000333 */
{{0, 0}, true}, /* 0 */
{{3, 3}, true}, /* 1 */
{{0, 5}, false}, /* 2 */
{{6, 0}, false}, /* 3 */
{{4, 5}, true}, /* 4 */
{{8, 3}, false}, /* 5 */
{{7, 6}, false}, /* 6 */
{{7, 8}, false}, /* 7 */
{{9, 6}, false}, /* 8 */
{{9, 8}, false}, /* 9 */
{{5, 7}, false}, /* a */
{{3, 7}, true}, /* b */
{{2, 7}, false}}}, /* c */
{"landscape, widest first", AtlasLandfillFlag::RotateLandscape|AtlasLandfillFlag::WidestFirst, {11, 12}, {11, 10}, {
/* No change compared to "no width sorting" in this case
99
7799
cbbaa6688
22224446688
2222444 555
11111555
11111555
000000333
000000333
000000333 */
{{0, 0}, true}, /* 0 */
{{3, 3}, true}, /* 1 */
{{0, 5}, false}, /* 2 */
{{6, 0}, false}, /* 3 */
{{4, 5}, true}, /* 4 */
{{8, 3}, false}, /* 5 */
{{7, 6}, false}, /* 6 */
{{7, 8}, false}, /* 7 */
{{9, 6}, false}, /* 8 */
{{9, 8}, false}, /* 9 */
{{5, 7}, false}, /* a */
{{3, 7}, true}, /* b */
{{2, 7}, false}}}, /* c */
{"landscape, narrowest first", AtlasLandfillFlag::RotateLandscape|AtlasLandfillFlag::NarrowestFirst, {11, 12}, {11, 10}, {
/* 11111
bb c11111
aa772222
994442222
99444000000
8866000000
8866000000
333555
333555
333555 */
{{5, 3}, true}, /* 0 */
{{6, 8}, true}, /* 1 */
{{5, 6}, false}, /* 2 */
{{0, 0}, false}, /* 3 */
{{2, 5}, true}, /* 4 */
{{3, 0}, false}, /* 5 */
{{3, 3}, false}, /* 6 */
{{3, 7}, false}, /* 7 */
{{1, 3}, false}, /* 8 */
{{0, 5}, false}, /* 9 */
{{1, 7}, false}, /* a */
{{0, 8}, true}, /* b */
{{5, 8}, false}}}, /* c */
};
const Vector2i LandfillArraySizes[]{
{3, 6}, /* 0 */
{2, 5}, /* 1 */
{4, 2}, /* 2 */
{3, 3}, /* 3 */
{3, 3}, /* 4 */
{2, 2}, /* 5 */
{2, 2}, /* 6 */
{2, 1}, /* 7 */
{2, 2}, /* 8 */
{2, 2}, /* 9 */
};
const struct {
const char* name;
AtlasLandfillFlags flags;
Vector3i size;
Vector3i filledSize;
Containers::Pair<Vector3i, bool> offsetsFlips[Containers::arraySize(LandfillArraySizes)];
} LandfillArrayData[]{
/* Various sorting aspects are tested in landfill() already, this just
checks the array-specific behaviors and the rotation-less overload */
{"no rotation", {}, {11, 6, 3}, {11, 6, 2}, {
/* 000
00011552222
00011552222
00011333444
00011333444 668899
00011333444 66889977 */
{{0, 0, 0}, false}, /* 0 */
{{3, 0, 0}, false}, /* 1 */
{{7, 3, 0}, false}, /* 2 */
{{5, 0, 0}, false}, /* 3 */
{{8, 0, 0}, false}, /* 4 */
{{5, 3, 0}, false}, /* 5 */
{{0, 0, 1}, false}, /* 6 */
{{6, 0, 1}, false}, /* 7 */
{{2, 0, 1}, false}, /* 8 */
{{4, 0, 1}, false}}}, /* 9 */
{"portrait, widest first", AtlasLandfillFlag::RotatePortrait|AtlasLandfillFlag::WidestFirst, {11, 6, 3}, {11, 6, 2}, {
/* 000 55444
00011 55444
0001122 444
0001122333
0001122333 6688997
0001122333 6688997 */
{{0, 0, 0}, false}, /* 0 */
{{3, 0, 0}, false}, /* 1 */
{{5, 0, 0}, true}, /* 2 */
{{7, 0, 0}, false}, /* 3 */
{{8, 3, 0}, false}, /* 4 */
{{6, 4, 0}, false}, /* 5 */
{{0, 0, 1}, false}, /* 6 */
{{6, 0, 1}, true}, /* 7 */
{{2, 0, 1}, false}, /* 8 */
{{4, 0, 1}, false}}}, /* 9 */
{"portrait, widest first, unbounded", AtlasLandfillFlag::RotatePortrait|AtlasLandfillFlag::WidestFirst, {11, 6, 3}, {11, 6, 2}, {
/* Should have the same result as above
000 55444
00011 55444
0001122 444
0001122333
0001122333 6688997
0001122333 6688997 */
{{0, 0, 0}, false}, /* 0 */
{{3, 0, 0}, false}, /* 1 */
{{5, 0, 0}, true}, /* 2 */
{{7, 0, 0}, false}, /* 3 */
{{8, 3, 0}, false}, /* 4 */
{{6, 4, 0}, false}, /* 5 */
{{0, 0, 1}, false}, /* 6 */
{{6, 0, 1}, true}, /* 7 */
{{2, 0, 1}, false}, /* 8 */
{{4, 0, 1}, false}}}, /* 9 */
};
TextureTools: choose a different approach to fix the test for MSVC 2015.
4 years ago
/* Could make order[15] and then Containers::arraySize(), but then it won't
work on MSVC2015 and cause overly complicated code elsewhere */
constexpr std::size_t ArrayPowerOfTwoOneLayerImageCount = 15;
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
const struct {
const char* name;
TextureTools: choose a different approach to fix the test for MSVC 2015.
4 years ago
std::size_t order[ArrayPowerOfTwoOneLayerImageCount];
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
} ArrayPowerOfTwoOneLayerData[]{
{"sorted",
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}},
{"",
/* Because there are duplicate sizes, the shuffling needs to preserve
the original order of duplicates to match the output */
{0, 2, 7, 13, 11, 3, 4, 5, 8, 14, 1, 9, 6, 12, 10}},
};
TextureTools: check that atlasArrayPowerOfTwo() sizes are in bounds. What, such an essential check was missing there?
3 years ago
const struct {
const char* name;
Vector2i size;
const char* message;
} ArrayPowerOfTwoWrongLayerSizeData[]{
{"non-power-of-two", {128, 127}, "{128, 127}"},
{"non-square", {128, 256}, "{128, 256}"},
{"zero", {1024, 0}, "{1024, 0}"},
};
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
const struct {
const char* name;
Vector2i size;
const char* message;
} ArrayPowerOfTwoWrongSizeData[]{
TextureTools: check that atlasArrayPowerOfTwo() sizes are in bounds. What, such an essential check was missing there?
3 years ago
{"larger than size", {512, 512}, "{512, 512}"},
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
{"non-power-of-two", {128, 127}, "{128, 127}"},
{"non-square", {128, 256}, "{128, 256}"},
TextureTools: check that atlasArrayPowerOfTwo() sizes are in bounds. What, such an essential check was missing there?
3 years ago
{"zero", {1024, 0}, "{1024, 0}"},
Got rid of header files in tests. They have no practical use and they only bloat codebase size and add maintenance burden.
14 years ago
};
New TextureTools library with joke implementation of atlas packer.
14 years ago
AtlasTest::AtlasTest() {
TextureTools: new landfill atlas packer. Just the dumbest possible idea I had, and it compares surprisingly well in both efficiency (~comparable to stb_rect_pack) and speed (significantly faster than stb_rect_pack with tons of tiny images, slower with larger ones -- would probably need to SIMD Math::max() and such, haha). It's the very first implementation without any additional improvements I have in mind, so it'll likely improve further. Includes a benchmark with a bunch of "datasets" extracted from both fonts and large glTF models. The stb_rect_pack file isn't commited as it's not useful apart from this single benchmark, put it to AtlasTestFiles/ and recompile.
3 years ago
addTests({&AtlasTest::debugLandfillFlag,
&AtlasTest::debugLandfillFlags,
&AtlasTest::landfillFullFit});
addInstancedTests({&AtlasTest::landfill},
Containers::arraySize(LandfillData));
addTests({&AtlasTest::landfillIncremental,
&AtlasTest::landfillNoFit,
&AtlasTest::landfillCopy,
&AtlasTest::landfillMove,
&AtlasTest::landfillArrayFullFit});
addInstancedTests({&AtlasTest::landfillArray},
Containers::arraySize(LandfillArrayData));
addTests({&AtlasTest::landfillArrayIncremental,
&AtlasTest::landfillArrayNoFit,
&AtlasTest::landfillArrayCopy,
&AtlasTest::landfillArrayMove,
&AtlasTest::landfillInvalidSize,
&AtlasTest::landfillSetFlagsInvalid,
&AtlasTest::landfillAddMissingRotations,
&AtlasTest::landfillAddInvalidViewSizes,
&AtlasTest::landfillAddTooLargeElement,
&AtlasTest::basic,
TextureTools: forward-declare std::vector for this awful old function. Needs to be eventually reworked/deleted anyway, but that's not the goal now.
4 years ago
&AtlasTest::padding,
&AtlasTest::empty,
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
&AtlasTest::tooSmall,
&AtlasTest::arrayPowerOfTwoEmpty,
&AtlasTest::arrayPowerOfTwoSingleElement,
&AtlasTest::arrayPowerOfTwoAllSameElements});
addInstancedTests({&AtlasTest::arrayPowerOfTwoOneLayer},
Containers::arraySize(ArrayPowerOfTwoOneLayerData));
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
addTests({&AtlasTest::arrayPowerOfTwoMoreLayers,
&AtlasTest::arrayPowerOfTwoInvalidViewSizes});
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
TextureTools: check that atlasArrayPowerOfTwo() sizes are in bounds. What, such an essential check was missing there?
3 years ago
addInstancedTests({&AtlasTest::arrayPowerOfTwoWrongLayerSize},
Containers::arraySize(ArrayPowerOfTwoWrongLayerSizeData));
addInstancedTests({&AtlasTest::arrayPowerOfTwoWrongSize},
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
Containers::arraySize(ArrayPowerOfTwoWrongSizeData));
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
addTests({&AtlasTest::arrayPowerOfTwoDeprecated});
#endif
New TextureTools library with joke implementation of atlas packer.
14 years ago
}
TextureTools: new landfill atlas packer. Just the dumbest possible idea I had, and it compares surprisingly well in both efficiency (~comparable to stb_rect_pack) and speed (significantly faster than stb_rect_pack with tons of tiny images, slower with larger ones -- would probably need to SIMD Math::max() and such, haha). It's the very first implementation without any additional improvements I have in mind, so it'll likely improve further. Includes a benchmark with a bunch of "datasets" extracted from both fonts and large glTF models. The stb_rect_pack file isn't commited as it's not useful apart from this single benchmark, put it to AtlasTestFiles/ and recompile.
3 years ago
void AtlasTest::debugLandfillFlag() {
std::ostringstream out;
Debug{&out} << AtlasLandfillFlag::RotatePortrait << AtlasLandfillFlag(0xcafedead);
CORRADE_COMPARE(out.str(), "TextureTools::AtlasLandfillFlag::RotatePortrait TextureTools::AtlasLandfillFlag(0xcafedead)\n");
}
void AtlasTest::debugLandfillFlags() {
std::ostringstream out;
Debug{&out} << (AtlasLandfillFlag::RotateLandscape|AtlasLandfillFlag::NarrowestFirst|AtlasLandfillFlag(0xdead0000)) << AtlasLandfillFlags{};
CORRADE_COMPARE(out.str(), "TextureTools::AtlasLandfillFlag::RotateLandscape|TextureTools::AtlasLandfillFlag::NarrowestFirst|TextureTools::AtlasLandfillFlag(0xdead0000) TextureTools::AtlasLandfillFlags{}\n");
}
void AtlasTest::landfillFullFit() {
/* Trivial case to verify there are no off-by-one errors that would prevent
a tight fit */
AtlasLandfill atlas{{4, 6}};
CORRADE_COMPARE(atlas.size(), (Vector2i{4, 6}));
CORRADE_COMPARE(atlas.filledSize(), (Vector2i{4, 0}));
CORRADE_COMPARE(atlas.flags(), AtlasLandfillFlag::RotatePortrait|AtlasLandfillFlag::WidestFirst);
Vector2i offsets[4];
UnsignedByte rotationData[1];
Containers::MutableBitArrayView rotations{rotationData, 0, 4};
/* Testing the init list overload here as all others test the view */
CORRADE_VERIFY(atlas.add({
{2, 4}, /* 0 */
{2, 3}, /* 1 */
{2, 3}, /* 2 */
{2, 2}, /* 3 */
}, offsets, rotations));
CORRADE_COMPARE(atlas.filledSize(), (Vector2i{4, 6}));
CORRADE_COMPARE_AS(rotations, Containers::stridedArrayView({
false, false, false, false
}).sliceBit(0), TestSuite::Compare::Container);
/* 3322
3322
0022
0011
0011
0011 */
CORRADE_COMPARE_AS(Containers::arrayView(offsets), Containers::arrayView<Vector2i>({
{0, 0}, /* 0 */
{2, 0}, /* 1 */
{2, 3}, /* 2 */
{0, 4}, /* 3 */
}), TestSuite::Compare::Container);
}
void AtlasTest::landfill() {
auto&& data = LandfillData[testCaseInstanceId()];
setTestCaseDescription(data.name);
AtlasLandfill atlas{data.size};
/* For unbounded sizes it should return 0 again */
CORRADE_COMPARE(atlas.size(), data.size);
Vector2i offsets[Containers::arraySize(LandfillSizes)];
/* In case rotations aren't enabled, this isn't zero-initialized by
add() */
UnsignedByte rotationData[2]{};
Containers::MutableBitArrayView rotations{rotationData, 0, Containers::arraySize(LandfillSizes)};
atlas.setFlags(data.flags);
/* Test the rotations-less overload if no rotations are enabled */
if(!(data.flags & (AtlasLandfillFlag::RotatePortrait|AtlasLandfillFlag::RotateLandscape)))
CORRADE_VERIFY(atlas.add(LandfillSizes, offsets));
else
CORRADE_VERIFY(atlas.add(LandfillSizes, offsets, rotations));
CORRADE_COMPARE(atlas.filledSize(), data.filledSize);
CORRADE_COMPARE_AS(rotations,
Containers::stridedArrayView(data.offsetsFlips)
.slice(&Containers::Pair<Vector2i, bool>::second)
.sliceBit(0),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(Containers::arrayView(offsets),
Containers::stridedArrayView(data.offsetsFlips)
.slice(&Containers::Pair<Vector2i, bool>::first),
TestSuite::Compare::Container);
}
void AtlasTest::landfillIncremental() {
/* Same as landfill(portrait, widest first) (which is the default flags)
but with the data split into three parts (0 to 4, 5 to 8, 9 to c), and
shuffled to verify the sort works as it should */
Vector2i sizeData[]{
{4, 2}, /* 0, rotated */
{3, 6}, /* 1 */
{3, 3}, /* 2 */
{5, 2}, /* 3, rotated */
{3, 3}, /* 4 */
{2, 2}, /* 5 */
{2, 2}, /* 6 */
{2, 2}, /* 7 */
{3, 2}, /* 8, rotated */
{1, 1}, /* 9 */
{1, 2}, /* a */
{2, 1}, /* b, rotated */
{1, 2}, /* c */
};
auto sizes = Containers::arrayView(sizeData);
Vector2i offsetData[Containers::arraySize(sizeData)];
auto offsets = Containers::arrayView(offsetData);
UnsignedByte rotationData[2];
Containers::MutableBitArrayView rotations{rotationData, 0, Containers::arraySize(sizeData)};
AtlasLandfill atlas{{11, 10}};
CORRADE_COMPARE(atlas.filledSize(), (Vector2i{11, 0}));
CORRADE_VERIFY(atlas.add(
sizes.prefix(5),
offsets.prefix(5),
rotations.prefix(5)));
CORRADE_COMPARE(atlas.filledSize(), (Vector2i{11, 6}));
CORRADE_VERIFY(atlas.add(
sizes.slice(5, 9),
offsets.slice(5, 9),
rotations.slice(5, 9)));
CORRADE_COMPARE(atlas.filledSize(), (Vector2i{11, 8}));
CORRADE_VERIFY(atlas.add(
sizes.exceptPrefix(9),
offsets.exceptPrefix(9),
rotations.exceptPrefix(9)));
CORRADE_COMPARE(atlas.filledSize(), (Vector2i{11, 10}));
CORRADE_COMPARE_AS(rotations, Containers::stridedArrayView({
true, false, false, true, false, false, false, false, true, false,
false, true, false
}).sliceBit(0), TestSuite::Compare::Container);
/* abc
abc9
7766
77665588
111 5588444
11133 88444
1113300 444
1113300222
1113300222
1113300222 */
CORRADE_COMPARE_AS(offsets, Containers::arrayView<Vector2i>({
{5, 0}, /* 0 */
{0, 0}, /* 1 */
{7, 0}, /* 2 */
{3, 0}, /* 3 */
{8, 3}, /* 4 */
{4, 5}, /* 5 */
{2, 6}, /* 6 */
{0, 6}, /* 7 */
{6, 4}, /* 8 */
{3, 8}, /* 9 */
{0, 8}, /* a */
{1, 8}, /* b */
{2, 8}, /* c */
}), TestSuite::Compare::Container);
}
void AtlasTest::landfillNoFit() {
/* Same as landfill(portrait, widest first) (which is the default flags)
which fits into {11, 10} but limiting height to 9 */
AtlasLandfill atlas{{11, 9}};
Vector2i offsets[Containers::arraySize(LandfillSizes)];
UnsignedByte rotationData[2];
Containers::MutableBitArrayView rotations{rotationData, 0, Containers::arraySize(LandfillSizes)};
CORRADE_VERIFY(!atlas.add(LandfillSizes, offsets, rotations));
}
void AtlasTest::landfillCopy() {
CORRADE_VERIFY(!std::is_copy_constructible<AtlasLandfill>{});
CORRADE_VERIFY(!std::is_copy_assignable<AtlasLandfill>{});
}
void AtlasTest::landfillMove() {
AtlasLandfill a{{16, 24}};
Vector2i offsets[2];
UnsignedByte rotations[1];
CORRADE_VERIFY(a.add({{15, 17}, {2, 3}}, offsets, Containers::MutableBitArrayView{rotations, 0, 2}));
AtlasLandfill b = Utility::move(a);
CORRADE_COMPARE(b.size(), (Vector2i{16, 24}));
CORRADE_COMPARE(b.filledSize(), (Vector2i{16, 20}));
AtlasLandfill c{{16, 12}};
c = Utility::move(b);
CORRADE_COMPARE(c.size(), (Vector2i{16, 24}));
CORRADE_COMPARE(c.filledSize(), (Vector2i{16, 20}));
CORRADE_VERIFY(std::is_nothrow_move_constructible<AtlasLandfill>::value);
CORRADE_VERIFY(std::is_nothrow_move_assignable<AtlasLandfill>::value);
}
void AtlasTest::landfillArrayFullFit() {
/* Trivial case to verify there are no off-by-one errors that would prevent
a tight fit */
AtlasLandfillArray atlas{{4, 5, 2}};
CORRADE_COMPARE(atlas.size(), (Vector3i{4, 5, 2}));
CORRADE_COMPARE(atlas.filledSize(), (Vector3i{4, 5, 0}));
CORRADE_COMPARE(atlas.flags(), AtlasLandfillFlag::RotatePortrait|AtlasLandfillFlag::WidestFirst);
Vector3i offsets[6];
UnsignedByte rotationData[1];
Containers::MutableBitArrayView rotations{rotationData, 0, 6};
/* Testing the init list overload as all others test the view */
CORRADE_VERIFY(atlas.add({
{3, 5}, /* 0 */
{1, 5}, /* 1 */
{3, 3}, /* 2 */
{1, 3}, /* 3 */
{2, 2}, /* 4 */
{2, 2}, /* 5 */
}, offsets, rotations));
CORRADE_COMPARE(atlas.filledSize(), (Vector3i{4, 5, 2}));
CORRADE_COMPARE_AS(rotations, Containers::stridedArrayView({
false, false, false, false, false, false
}).sliceBit(0), TestSuite::Compare::Container);
/* 0001 5544
0001 5544
0001 2223
0001 2223
0001 2223 */
CORRADE_COMPARE_AS(Containers::arrayView(offsets), Containers::arrayView<Vector3i>({
{0, 0, 0}, /* 0 */
{3, 0, 0}, /* 1 */
{0, 0, 1}, /* 2 */
{3, 0, 1}, /* 3 */
{2, 3, 1}, /* 4 */
{0, 3, 1}, /* 5 */
}), TestSuite::Compare::Container);
}
void AtlasTest::landfillArray() {
auto&& data = LandfillArrayData[testCaseInstanceId()];
setTestCaseDescription(data.name);
AtlasLandfillArray atlas{data.size};
/* For unbounded sizes it should return 0 again */
CORRADE_COMPARE(atlas.size(), data.size);
Vector3i offsets[Containers::arraySize(LandfillArraySizes)];
/* In case rotations aren't enabled, this isn't zero-initialized by
add() */
UnsignedByte rotationData[2]{};
Containers::MutableBitArrayView rotations{rotationData, 0, Containers::arraySize(LandfillArraySizes)};
atlas.setFlags(data.flags);
/* Test the rotations-less overload if no rotations are enabled */
if(!(data.flags & (AtlasLandfillFlag::RotatePortrait|AtlasLandfillFlag::RotateLandscape)))
CORRADE_VERIFY(atlas.add(LandfillArraySizes, offsets));
else
CORRADE_VERIFY(atlas.add(LandfillArraySizes, offsets, rotations));
CORRADE_COMPARE(atlas.filledSize(), data.filledSize);
CORRADE_COMPARE_AS(rotations,
Containers::stridedArrayView(data.offsetsFlips)
.slice(&Containers::Pair<Vector3i, bool>::second)
.sliceBit(0),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(Containers::arrayView(offsets),
Containers::stridedArrayView(data.offsetsFlips)
.slice(&Containers::Pair<Vector3i, bool>::first),
TestSuite::Compare::Container);
}
void AtlasTest::landfillArrayIncremental() {
/* 000 55444
00011 55444
0001122 444
0001122333
0001122333 6688997
0001122333 6688997 */
Vector2i sizeData[]{
{4, 2}, /* 0, rotated */
{3, 6}, /* 1 */
{3, 3}, /* 2 */
{5, 2}, /* 3, rotated */
{2, 2}, /* 4 */
{2, 2}, /* 5 */
{3, 3}, /* 6 */
{2, 2}, /* 7 */
{2, 1}, /* 8, rotated */
{2, 2}, /* 9 */
};
auto sizes = Containers::arrayView(sizeData);
Vector3i offsetData[Containers::arraySize(sizeData)];
auto offsets = Containers::arrayView(offsetData);
UnsignedByte rotationData[2];
Containers::MutableBitArrayView rotations{rotationData, 0, Containers::arraySize(sizeData)};
AtlasLandfillArray atlas{{11, 6, 2}};
CORRADE_COMPARE(atlas.filledSize(), (Vector3i{11, 6, 0}));
CORRADE_VERIFY(atlas.add(
sizes.prefix(4),
offsets.prefix(4),
rotations.prefix(4)));
CORRADE_COMPARE(atlas.filledSize(), (Vector3i{11, 6, 1}));
CORRADE_VERIFY(atlas.add(
sizes.slice(4, 7),
offsets.slice(4, 7),
rotations.slice(4, 7)));
CORRADE_COMPARE(atlas.filledSize(), (Vector3i{11, 6, 2}));
CORRADE_VERIFY(atlas.add(
sizes.exceptPrefix(7),
offsets.exceptPrefix(7),
rotations.exceptPrefix(7)));
CORRADE_COMPARE(atlas.filledSize(), (Vector3i{11, 6, 2}));
CORRADE_COMPARE_AS(rotations, Containers::stridedArrayView({
true, false, false, true, false, false, false, false, true, false
}).sliceBit(0), TestSuite::Compare::Container);
/* 111 44666
11133 44666
1113300 666
1113300222
1113300222 5577998
1113300222 5577998 */
CORRADE_COMPARE_AS(offsets, Containers::arrayView<Vector3i>({
{5, 0, 0}, /* 0 */
{0, 0, 0}, /* 1 */
{7, 0, 0}, /* 2 */
{3, 0, 0}, /* 3 */
{6, 4, 0}, /* 4 */
{0, 0, 1}, /* 5 */
{8, 3, 0}, /* 6 */
{2, 0, 1}, /* 7 */
{6, 0, 1}, /* 8 */
{4, 0, 1}, /* 9 */
}), TestSuite::Compare::Container);
}
void AtlasTest::landfillArrayNoFit() {
/* Same as landfillArray(portrait, widest first) (which is the default
flags) which fits into {11, 6, 2} but limiting depth to 1 */
AtlasLandfillArray atlas{{11, 6, 1}};
Vector3i offsets[Containers::arraySize(LandfillArraySizes)];
UnsignedByte rotationData[2];
Containers::MutableBitArrayView rotations{rotationData, 0, Containers::arraySize(LandfillArraySizes)};
CORRADE_VERIFY(!atlas.add(LandfillArraySizes, offsets, rotations));
}
void AtlasTest::landfillArrayCopy() {
CORRADE_VERIFY(!std::is_copy_constructible<AtlasLandfillArray>{});
CORRADE_VERIFY(!std::is_copy_assignable<AtlasLandfillArray>{});
}
void AtlasTest::landfillArrayMove() {
AtlasLandfillArray a{{16, 24, 8}};
Vector3i offsets[2];
UnsignedByte rotations[1];
CORRADE_VERIFY(a.add({{12, 17}, {5, 12}}, offsets, Containers::MutableBitArrayView{rotations, 0, 2}));
AtlasLandfillArray b = Utility::move(a);
CORRADE_COMPARE(b.size(), (Vector3i{16, 24, 8}));
CORRADE_COMPARE(b.filledSize(), (Vector3i{16, 24, 2}));
AtlasLandfillArray c{{16, 12, 1}};
c = Utility::move(b);
CORRADE_COMPARE(c.size(), (Vector3i{16, 24, 8}));
CORRADE_COMPARE(c.filledSize(), (Vector3i{16, 24, 2}));
CORRADE_VERIFY(std::is_nothrow_move_constructible<AtlasLandfillArray>::value);
CORRADE_VERIFY(std::is_nothrow_move_assignable<AtlasLandfillArray>::value);
}
void AtlasTest::landfillInvalidSize() {
CORRADE_SKIP_IF_NO_ASSERT();
/* These are fine */
AtlasLandfill{{16, 0}};
AtlasLandfill{{65536, 16}};
AtlasLandfillArray{{16, 16, 0}};
AtlasLandfillArray{{65536, 16, 16}};
std::ostringstream out;
Error redirectError{&out};
AtlasLandfill{{0, 16}};
AtlasLandfill{{65537, 16}};
AtlasLandfillArray{{0, 16, 16}};
AtlasLandfillArray{{16, 0, 16}};
AtlasLandfillArray{{65537, 16, 16}};
CORRADE_COMPARE_AS(out.str(),
"TextureTools::AtlasLandfill: expected non-zero width, got {0, 16}\n"
"TextureTools::AtlasLandfill: expected width to fit into 16 bits, got {65537, 16}\n"
"TextureTools::AtlasLandfillArray: expected non-zero width and height, got {0, 16, 16}\n"
"TextureTools::AtlasLandfillArray: expected non-zero width and height, got {16, 0, 16}\n"
"TextureTools::AtlasLandfillArray: expected width to fit into 16 bits, got {65537, 16, 16}\n",
TestSuite::Compare::String);
}
void AtlasTest::landfillSetFlagsInvalid() {
CORRADE_SKIP_IF_NO_ASSERT();
AtlasLandfill atlas{{16, 16}};
AtlasLandfillArray array{{16, 16, 1}};
std::ostringstream out;
Error redirectError{&out};
atlas.setFlags(AtlasLandfillFlag::RotatePortrait|AtlasLandfillFlag::RotateLandscape);
array.setFlags(AtlasLandfillFlag::RotatePortrait|AtlasLandfillFlag::RotateLandscape);
atlas.setFlags(AtlasLandfillFlag::WidestFirst|AtlasLandfillFlag::NarrowestFirst);
array.setFlags(AtlasLandfillFlag::WidestFirst|AtlasLandfillFlag::NarrowestFirst);
CORRADE_COMPARE_AS(out.str(),
"TextureTools::AtlasLandfill::setFlags(): only one of RotatePortrait and RotateLandscape can be set\n"
"TextureTools::AtlasLandfillArray::setFlags(): only one of RotatePortrait and RotateLandscape can be set\n"
"TextureTools::AtlasLandfill::setFlags(): only one of WidestFirst and NarrowestFirst can be set\n"
"TextureTools::AtlasLandfillArray::setFlags(): only one of WidestFirst and NarrowestFirst can be set\n",
TestSuite::Compare::String);
}
void AtlasTest::landfillAddMissingRotations() {
CORRADE_SKIP_IF_NO_ASSERT();
AtlasLandfill atlasPortrait{{16, 23}};
AtlasLandfill atlasLandscape{{16, 23}};
AtlasLandfillArray arrayPortrait{{16, 23, 2}};
AtlasLandfillArray arrayLandscape{{16, 23, 2}};
atlasPortrait.setFlags(AtlasLandfillFlag::RotatePortrait);
arrayPortrait.setFlags(AtlasLandfillFlag::RotatePortrait);
atlasLandscape.setFlags(AtlasLandfillFlag::RotateLandscape);
arrayLandscape.setFlags(AtlasLandfillFlag::RotateLandscape);
Vector2i sizes[2];
Vector2i offsets[2];
Vector3i offsets3[2];
std::ostringstream out;
Error redirectError{&out};
atlasPortrait.add(sizes, offsets);
arrayPortrait.add(sizes, offsets3);
/* "Testing" the rotation-less init list variants too */
atlasLandscape.add({{}, {}}, offsets);
arrayLandscape.add({{}, {}}, offsets3);
CORRADE_COMPARE(out.str(),
"TextureTools::AtlasLandfill::add(): TextureTools::AtlasLandfillFlag::RotatePortrait set, expected a rotations view\n"
"TextureTools::AtlasLandfillArray::add(): TextureTools::AtlasLandfillFlag::RotatePortrait set, expected a rotations view\n"
"TextureTools::AtlasLandfill::add(): TextureTools::AtlasLandfillFlag::RotateLandscape set, expected a rotations view\n"
"TextureTools::AtlasLandfillArray::add(): TextureTools::AtlasLandfillFlag::RotateLandscape set, expected a rotations view\n");
}
void AtlasTest::landfillAddInvalidViewSizes() {
CORRADE_SKIP_IF_NO_ASSERT();
AtlasLandfill atlas{{16, 23}};
Vector2i sizes[2];
Vector2i offsets[2];
Vector2i offsetsInvalid[3];
UnsignedByte rotationsData[1];
Containers::MutableBitArrayView rotations{rotationsData, 0, 2};
Containers::MutableBitArrayView rotationsInvalid{rotationsData, 0, 3};
std::ostringstream out;
Error redirectError{&out};
atlas.add(sizes, offsetsInvalid, rotations);
atlas.add(sizes, offsets, rotationsInvalid);
CORRADE_COMPARE(out.str(),
"TextureTools::AtlasLandfill::add(): expected sizes and offsets views to have the same size, got 2 and 3\n"
"TextureTools::AtlasLandfill::add(): expected sizes and rotations views to have the same size, got 2 and 3\n");
}
void AtlasTest::landfillAddTooLargeElement() {
CORRADE_SKIP_IF_NO_ASSERT();
/* The atlas makes the sizes portrait first, the array landscape instead */
AtlasLandfill atlas{{16, 23}};
AtlasLandfill atlas2{{16, 13}};
AtlasLandfillArray array{{23, 16, 3}};
AtlasLandfillArray array2{{13, 16, 3}};
array.setFlags(AtlasLandfillFlag::RotateLandscape);
array2.setFlags(AtlasLandfillFlag::RotateLandscape);
Vector2i offsets[2];
Vector3i offsets3[2];
UnsignedByte rotationsData[1];
Containers::MutableBitArrayView rotations{rotationsData, 0, 2};
std::ostringstream out;
Error redirectError{&out};
atlas.add({{16, 23}, {0, 23}}, offsets, rotations);
array.add({{23, 16}, {23, 0}}, offsets3, rotations);
atlas.add({{16, 23}, {17, 23}}, offsets, rotations);
array.add({{23, 16}, {23, 17}}, offsets3, rotations);
/* Sizes that fit but don't after a flip */
atlas2.add({{13, 13}, {15, 13}}, offsets, rotations);
array2.add({{13, 13}, {13, 15}}, offsets3, rotations);
CORRADE_COMPARE_AS(out.str(),
"TextureTools::AtlasLandfill::add(): expected size 1 to be non-zero and not larger than {16, 23} but got {0, 23}\n"
"TextureTools::AtlasLandfillArray::add(): expected size 1 to be non-zero and not larger than {23, 16} but got {23, 0}\n"
"TextureTools::AtlasLandfill::add(): expected size 1 to be non-zero and not larger than {16, 23} but got {17, 23}\n"
"TextureTools::AtlasLandfillArray::add(): expected size 1 to be non-zero and not larger than {23, 16} but got {23, 17}\n"
"TextureTools::AtlasLandfill::add(): expected size 1 to be non-zero and not larger than {16, 13} but got {13, 15}\n"
"TextureTools::AtlasLandfillArray::add(): expected size 1 to be non-zero and not larger than {13, 16} but got {15, 13}\n",
TestSuite::Compare::String);
}
TextureTools: forward-declare std::vector for this awful old function. Needs to be eventually reworked/deleted anyway, but that's not the goal now.
4 years ago
void AtlasTest::basic() {
Using Range2D instead of Rectangle everywhere. Encourages vectorization and generic usage even more. Some functions were rewritten to make use of the new features, resulting in shorter and more readable code. This also fixes the annoying naming collision with WINAPI Rectangle() function. The old Rectangle is now subclass of Range2D, is marked as deprecated and will be removed in future release.
13 years ago
std::vector<Range2Di> atlas = TextureTools::atlas({64, 64}, {
New TextureTools library with joke implementation of atlas packer.
14 years ago
{12, 18},
{32, 15},
{23, 25}
});
CORRADE_COMPARE(atlas.size(), 3);
Using Range2D instead of Rectangle everywhere. Encourages vectorization and generic usage even more. Some functions were rewritten to make use of the new features, resulting in shorter and more readable code. This also fixes the annoying naming collision with WINAPI Rectangle() function. The old Rectangle is now subclass of Range2D, is marked as deprecated and will be removed in future release.
13 years ago
CORRADE_COMPARE(atlas, (std::vector<Range2Di>{
Range2Di::fromSize({0, 0}, {12, 18}),
Range2Di::fromSize({32, 0}, {32, 15}),
Range2Di::fromSize({0, 25}, {23, 25})}));
New TextureTools library with joke implementation of atlas packer.
14 years ago
}
TextureTools: forward-declare std::vector for this awful old function. Needs to be eventually reworked/deleted anyway, but that's not the goal now.
4 years ago
void AtlasTest::padding() {
Using Range2D instead of Rectangle everywhere. Encourages vectorization and generic usage even more. Some functions were rewritten to make use of the new features, resulting in shorter and more readable code. This also fixes the annoying naming collision with WINAPI Rectangle() function. The old Rectangle is now subclass of Range2D, is marked as deprecated and will be removed in future release.
13 years ago
std::vector<Range2Di> atlas = TextureTools::atlas({64, 64}, {
TextureTools: support padding in atlas().
13 years ago
{8, 16},
{28, 13},
{19, 23}
}, {2, 1});
CORRADE_COMPARE(atlas.size(), 3);
Using Range2D instead of Rectangle everywhere. Encourages vectorization and generic usage even more. Some functions were rewritten to make use of the new features, resulting in shorter and more readable code. This also fixes the annoying naming collision with WINAPI Rectangle() function. The old Rectangle is now subclass of Range2D, is marked as deprecated and will be removed in future release.
13 years ago
CORRADE_COMPARE(atlas, (std::vector<Range2Di>{
Range2Di::fromSize({2, 1}, {8, 16}),
Range2Di::fromSize({34, 1}, {28, 13}),
Range2Di::fromSize({2, 26}, {19, 23})}));
TextureTools: support padding in atlas().
13 years ago
}
TextureTools: forward-declare std::vector for this awful old function. Needs to be eventually reworked/deleted anyway, but that's not the goal now.
4 years ago
void AtlasTest::empty() {
Revert "Fixed compilation with GCC 4.9." The final release doesn't have the issue with non-explicit default std::vector constructor. Most of the conflicts resulted from Mesh::Primitve -> MeshPrimitive refactoring. This reverts commit c2ad09706e2bae00581b9942041e0e8c91c4bb03. Conflicts: src/Magnum/Primitives/Capsule.cpp src/Magnum/Primitives/Circle.cpp src/Magnum/Primitives/Crosshair.cpp src/Magnum/Primitives/Cylinder.cpp src/Magnum/Primitives/Icosphere.cpp src/Magnum/Primitives/Implementation/WireframeSpheroid.cpp src/Magnum/Primitives/Line.cpp src/Magnum/Primitives/Plane.cpp src/Magnum/Primitives/Square.cpp src/Magnum/Primitives/UVSphere.cpp src/Magnum/SceneGraph/Object.hpp src/Magnum/Text/GlyphCache.cpp src/Magnum/TextureTools/Atlas.cpp src/Magnum/TextureTools/Test/AtlasTest.cpp
12 years ago
std::vector<Range2Di> atlas = TextureTools::atlas({}, {});
New TextureTools library with joke implementation of atlas packer.
14 years ago
CORRADE_VERIFY(atlas.empty());
}
TextureTools: forward-declare std::vector for this awful old function. Needs to be eventually reworked/deleted anyway, but that's not the goal now.
4 years ago
void AtlasTest::tooSmall() {
New TextureTools library with joke implementation of atlas packer.
14 years ago
std::ostringstream o;
Adapted to Corrade changes.
10 years ago
Error redirectError{&o};
New TextureTools library with joke implementation of atlas packer.
14 years ago
Using Range2D instead of Rectangle everywhere. Encourages vectorization and generic usage even more. Some functions were rewritten to make use of the new features, resulting in shorter and more readable code. This also fixes the annoying naming collision with WINAPI Rectangle() function. The old Rectangle is now subclass of Range2D, is marked as deprecated and will be removed in future release.
13 years ago
std::vector<Range2Di> atlas = TextureTools::atlas({64, 32}, {
TextureTools: support padding in atlas().
13 years ago
{8, 16},
{21, 13},
{19, 29}
}, {2, 1});
New TextureTools library with joke implementation of atlas packer.
14 years ago
CORRADE_VERIFY(atlas.empty());
TextureTools: proper function name in assert.
13 years ago
CORRADE_COMPARE(o.str(), "TextureTools::atlas(): requested atlas size Vector(64, 32) is too small to fit 3 Vector(25, 31) textures. Generated atlas will be empty.\n");
New TextureTools library with joke implementation of atlas packer.
14 years ago
}
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
void AtlasTest::arrayPowerOfTwoEmpty() {
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
Containers::ArrayView<Vector3i> offsets;
CORRADE_COMPARE(atlasArrayPowerOfTwo({128, 128}, {}, offsets), 0);
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
}
void AtlasTest::arrayPowerOfTwoSingleElement() {
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
Vector3i offsets[1];
CORRADE_COMPARE(atlasArrayPowerOfTwo({128, 128}, {{128, 128}}, offsets), 1);
CORRADE_COMPARE_AS(Containers::arrayView(offsets), Containers::arrayView<Vector3i>({
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
{0, 0, 0}
}), TestSuite::Compare::Container);
}
void AtlasTest::arrayPowerOfTwoAllSameElements() {
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
Vector3i offsets[4];
CORRADE_COMPARE(atlasArrayPowerOfTwo({128, 128}, {
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
{64, 64},
{64, 64},
{64, 64},
{64, 64},
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
}, offsets), 1);
CORRADE_COMPARE_AS(Containers::arrayView(offsets), Containers::arrayView<Vector3i>({
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
{0, 0, 0},
{64, 0, 0},
{0, 64, 0},
{64, 64, 0}
}), TestSuite::Compare::Container);
}
void AtlasTest::arrayPowerOfTwoOneLayer() {
auto&& data = ArrayPowerOfTwoOneLayerData[testCaseInstanceId()];
setTestCaseDescription(data.name);
TextureTools: choose a different approach to fix the test for MSVC 2015.
4 years ago
const Vector2i inputSorted[ArrayPowerOfTwoOneLayerImageCount]{
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
{1024, 1024}, /* 0 */
{1024, 1024}, /* 1 */
{512, 512}, /* 2 */
{512, 512}, /* 3 */
{512, 512}, /* 4 */
{512, 512}, /* 5 */
{512, 512}, /* 6 */
{256, 256}, /* 7 */
{256, 256}, /* 8 */
{256, 256}, /* 9 */
{256, 256}, /* 10 */
{128, 128}, /* 11 */
{128, 128}, /* 12 */
{32, 32}, /* 13 */
{32, 32} /* 14 */
};
TextureTools: choose a different approach to fix the test for MSVC 2015.
4 years ago
const Vector3i expectedSorted[ArrayPowerOfTwoOneLayerImageCount]{
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
{0, 0, 0},
{1024, 0, 0},
{0, 1024, 0},
{512, 1024, 0},
{0, 1536, 0},
{512, 1536, 0},
{1024, 1024, 0},
{1536, 1024, 0},
{1792, 1024, 0},
{1536, 1280, 0},
{1792, 1280, 0},
{1024, 1536, 0},
{1152, 1536, 0},
{1024, 1664, 0},
{1056, 1664, 0}
};
TextureTools: choose a different approach to fix the test for MSVC 2015.
4 years ago
Vector2i input[ArrayPowerOfTwoOneLayerImageCount];
Vector3i expected[ArrayPowerOfTwoOneLayerImageCount];
for(std::size_t i = 0; i != ArrayPowerOfTwoOneLayerImageCount; ++i) {
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
input[i] = inputSorted[data.order[i]];
expected[i] = expectedSorted[data.order[i]];
}
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
Vector3i offsets[ArrayPowerOfTwoOneLayerImageCount];
CORRADE_COMPARE(atlasArrayPowerOfTwo({2048, 2048}, input, offsets), 1);
CORRADE_COMPARE_AS(Containers::arrayView(offsets),
Containers::arrayView(expected),
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
TestSuite::Compare::Container);
}
void AtlasTest::arrayPowerOfTwoMoreLayers() {
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
Vector3i offsets[11];
CORRADE_COMPARE(atlasArrayPowerOfTwo({2048, 2048}, {
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
{2048, 2048},
{1024, 1024},
{1024, 1024},
{1024, 1024},
{512, 512},
{512, 512},
{512, 512},
{512, 512},
{512, 512},
{256, 256},
{256, 256}
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
}, offsets), 3);
CORRADE_COMPARE_AS(Containers::arrayView(offsets), Containers::arrayView<Vector3i>({
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
{0, 0, 0},
{0, 0, 1},
{1024, 0, 1},
{0, 1024, 1},
{1024, 1024, 1},
{1536, 1024, 1},
{1024, 1536, 1},
{1536, 1536, 1},
{0, 0, 2},
{512, 0, 2},
{768, 0, 2}
}), TestSuite::Compare::Container);
}
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
void AtlasTest::arrayPowerOfTwoInvalidViewSizes() {
CORRADE_SKIP_IF_NO_ASSERT();
Vector2i sizes[2];
Vector3i offsetsInvalid[3];
std::ostringstream out;
Error redirectError{&out};
atlasArrayPowerOfTwo({}, sizes, offsetsInvalid);
CORRADE_COMPARE(out.str(),
"TextureTools::atlasArrayPowerOfTwo(): expected sizes and offsets views to have the same size, got 2 and 3\n");
}
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
void AtlasTest::arrayPowerOfTwoWrongLayerSize() {
TextureTools: check that atlasArrayPowerOfTwo() sizes are in bounds. What, such an essential check was missing there?
3 years ago
auto&& data = ArrayPowerOfTwoWrongLayerSizeData[testCaseInstanceId()];
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
setTestCaseDescription(data.name);
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
std::ostringstream out;
Error redirectError{&out};
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
atlasArrayPowerOfTwo(data.size, {}, {});
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
CORRADE_COMPARE(out.str(), Utility::formatString("TextureTools::atlasArrayPowerOfTwo(): expected layer size to be a non-zero power-of-two square, got {}\n", data.message));
}
void AtlasTest::arrayPowerOfTwoWrongSize() {
auto&& data = ArrayPowerOfTwoWrongSizeData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
Vector3i offsets[3];
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
std::ostringstream out;
Error redirectError{&out};
atlasArrayPowerOfTwo({256, 256}, {
{64, 64},
{128, 128},
data.size
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
}, offsets);
TextureTools: check that atlasArrayPowerOfTwo() sizes are in bounds. What, such an essential check was missing there?
3 years ago
CORRADE_COMPARE(out.str(), Utility::formatString("TextureTools::atlasArrayPowerOfTwo(): expected size 2 to be a non-zero power-of-two square not larger than {{256, 256}} but got {}\n", data.message));
TextureTools: new, optimal, atlasArrayPowerOfTwo() algorithm.
4 years ago
}
TextureTools: don't allocate the output in atlasArrayPowerOfTwo(). I mean, yes, it was already SIGNIFICANTLY better than the atlas() that took a vector and returned one as well, but still. One of the usual use cases is that there's an array of structs containing both sizes offsets and the offsets get written back. The original versions are deprecated as I really don't see any convenient use case for these, especially given they return a pair and not just an array.
3 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
void AtlasTest::arrayPowerOfTwoDeprecated() {
/* Same as arrayPowerOfTwoAllSameElements(), but with the deprecated API */
CORRADE_IGNORE_DEPRECATED_PUSH
Containers::Pair<Int, Containers::Array<Vector3i>> out = atlasArrayPowerOfTwo({128, 128}, {
{64, 64},
{64, 64},
{64, 64},
{64, 64},
});
CORRADE_IGNORE_DEPRECATED_POP
CORRADE_COMPARE(out.first(), 1);
CORRADE_COMPARE_AS(out.second(), Containers::arrayView<Vector3i>({
{0, 0, 0},
{64, 0, 0},
{0, 64, 0},
{64, 64, 0}
}), TestSuite::Compare::Container);
}
#endif
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
}}}}
Got rid of header files in tests. They have no practical use and they only bloat codebase size and add maintenance burden.
14 years ago
CORRADE_TEST_MAIN(Magnum::TextureTools::Test::AtlasTest)