1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
#include "app.hpp"
#include "compat/assert.hpp"
#include "loader/loader.hpp"
#include "loader/wall-cell.hpp"
#include "loader/anim-cell.hpp"
#include "src/ground-atlas.hpp"
#include "src/wall-atlas.hpp"
#include "src/anim-atlas.hpp"
#include "src/scenery.hpp"
#include <mg/Texture.h>
namespace floormat {
namespace {
// copied from bench/loader.cpp
constexpr struct {
const char* name;
Vector2ub size;
pass_mode pass = pass_mode::pass;
} ground_atlases[] = {
{ "floor-tiles", {44,4} },
{ "tiles", {8, 5} },
{ "texel", {2, 2}, pass_mode::blocked },
{ "metal1", {2,2} },
};
constexpr const char* wall_atlases[] = {
"concrete1", "empty", "test1",
};
constexpr const char* anim_atlases[] = {
"anim/npc-walk",
"anim/test-8x8",
"scenery/door-close",
};
constexpr const char* sceneries[] = {
"bench1",
"shelf6",
"door1",
"control panel (wall) 1",
"table0",
};
} // namespace
void test_app::test_loader()
{
fm_assert(loader.invalid_ground_atlas().atlas);
fm_assert(&loader.invalid_ground_atlas().atlas == &loader.invalid_ground_atlas().atlas);
fm_assert(loader.invalid_ground_atlas().name == loader.INVALID);
fm_assert(loader.invalid_wall_atlas().atlas);
fm_assert(&loader.invalid_wall_atlas().atlas == &loader.invalid_wall_atlas().atlas);
fm_assert(loader.invalid_wall_atlas().name == loader.INVALID);
for (const auto& str : anim_atlases)
(void)loader.anim_atlas(str, {});
for (const auto& x : ground_atlases)
{
auto& A = *loader.ground_atlas(x.name);
fm_assert(A.num_tiles2() == x.size);
fm_assert(A.pass_mode() == x.pass);
fm_assert(A.texture().id());
}
for (const auto& name : wall_atlases)
{
auto& A = *loader.wall_atlas(name);
fm_assert(!A.raw_frame_array().isEmpty());
fm_assert(A.texture().id());
}
fm_assert(!loader.scenery_list().isEmpty());
for (const auto& name : sceneries)
{
const auto& S = loader.scenery(name);
fm_assert(S.atlas);
}
fm_assert(loader.ground_atlas("texel")->pass_mode() == pass_mode::blocked);
fm_assert(loader.ground_atlas("metal1")->pass_mode() == pass_mode::pass);
}
void test_app::test_loader2()
{
for (const auto& x : loader.ground_atlas_list())
{
fm_assert(x.name);
if (x.name == loader.INVALID)
continue;
if (!x.atlas)
{
auto atlas = loader.ground_atlas(x.name, loader_policy::error);
fm_assert(atlas->name() == x.name);
fm_assert(atlas->texture().id());
fm_assert(!atlas->pixel_size().isZero());
fm_assert(Vector2ui{atlas->num_tiles2()}.product());
}
}
for (const auto& x : loader.wall_atlas_list())
{
fm_assert(x.name);
if (x.name == loader.INVALID)
continue;
if (!x.atlas)
{
auto atlas = loader.wall_atlas(x.name, loader_policy::error);
fm_assert(atlas->name() == x.name);
fm_assert(atlas->texture().id());
fm_assert(!atlas->raw_frame_array().isEmpty());
fm_assert(atlas->calc_direction(Wall::Direction_::N).wall.count);
}
}
for (const auto& x : loader.anim_atlas_list())
{
fm_assert(x.name);
if (x.name == loader.INVALID)
continue;
auto atlas_ = loader.anim_atlas(x.name, {}, loader_policy::error);
fm_assert(atlas_);
auto& atlas = *atlas_;
fm_assert(atlas.name() == x.name);
fm_assert(atlas.texture().id());
fm_assert(atlas.info().nframes > 0);
}
// todo scenery_cell
}
} // namespace floormat
|
