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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
#pragma once
#include "compat/defs.hpp"
#include "src/rotation.hpp"
#include "src/pass-mode.hpp"
#include <array>
#include <bitset>
#include <vector>
#include <Corrade/Containers/String.h>
#include <Magnum/Math/Vector2.h>
#include <Magnum/Math/Color.h>
#include <Magnum/GL/Texture.h>
namespace floormat { class wall_atlas; }
namespace floormat::Wall {
struct Frame
{
Vector2ui offset = { (unsigned)-1, (unsigned)-1 };
bool operator==(const Frame&) const noexcept;
};
struct Group
{
uint32_t index = (uint32_t)-1, count = 0;
Vector2ui pixel_size;
Color4 tint_mult{1,1,1,1};
Color3 tint_add;
uint8_t from_rotation = (uint8_t)-1; // applies only to images
bool mirrored : 1 = false,
default_tint : 1 = true,
is_defined : 1 = false;
//bool is_empty() const noexcept { return count == 0; }
bool operator==(const Group&) const noexcept;
};
enum class Group_ : uint8_t { wall, overlay, side, top, corner_L, corner_R, COUNT };
enum class Direction_ : uint8_t { N, E, S, W, COUNT };
struct Direction
{
using memfn_ptr = Group Direction::*;
struct member_tuple { StringView name; memfn_ptr member; Group_ tag; };
Group wall{}, overlay{}, side{}, top{};
Group corner_L{}, corner_R{};
pass_mode passability = pass_mode::blocked;
const Group& group(Group_ i) const;
const Group& group(size_t i) const;
Group& group(Group_ i);
Group& group(size_t i);
static constexpr inline member_tuple groups[] = {
{ "wall"_s, &Direction::wall, Group_::wall },
{ "overlay"_s, &Direction::overlay, Group_::overlay },
{ "side"_s, &Direction::side, Group_::side },
{ "top"_s, &Direction::top, Group_::top },
{ "corner-L"_s, &Direction::corner_L, Group_::corner_L, },
{ "corner-R"_s, &Direction::corner_R, Group_::corner_R, },
};
static_assert(std::size(groups) == (size_t)Group_::COUNT);
bool operator==(const Direction&) const noexcept;
};
struct Info
{
String name;
unsigned depth = 0;
bool operator==(const Info&) const noexcept;
};
struct DirArrayIndex {
uint8_t val = (uint8_t)-1;
operator bool() const { return val != (uint8_t)-1; }
bool operator==(const DirArrayIndex&) const noexcept;
};
} // namespace floormat::Wall
namespace floormat {
constexpr inline auto Direction_COUNT = (size_t)Wall::Direction_::COUNT;
struct wall_atlas_def final
{
bool operator==(const wall_atlas_def&) const noexcept;
Wall::Info header;
std::vector<Wall::Frame> frames;
std::vector<Wall::Direction> direction_array;
std::array<Wall::DirArrayIndex, Direction_COUNT> direction_map;
std::bitset<Direction_COUNT> direction_mask{0};
static wall_atlas_def deserialize(StringView filename);
void serialize(StringView filename) const;
static void serialize(StringView filename, const Wall::Info& header, ArrayView<const Wall::Frame> frames,
ArrayView<const Wall::Direction> dir_array,
std::array<Wall::DirArrayIndex, Direction_COUNT> dir_map);
};
class wall_atlas final
{
using Frame = Wall::Frame;
using Group = Wall::Group;
using Direction_ = Wall::Direction_;
using Direction = Wall::Direction;
using Info = Wall::Info;
using Group_ = Wall::Group_;
using DirArrayIndex = Wall::DirArrayIndex;
std::vector<Direction> _dir_array;
std::vector<Frame> _frame_array;
Info _info;
String _path;
GL::Texture2D _texture{NoCreate};
std::array<DirArrayIndex, 4> _direction_map;
Direction* get_Direction(Direction_ num) const;
public:
fm_DECLARE_DELETED_MOVE_ASSIGNMENT(wall_atlas);
wall_atlas() noexcept;
~wall_atlas() noexcept;
wall_atlas(wall_atlas_def def, String path, const ImageView2D& img);
void serialize(StringView filename) const;
const Group* group(Direction_ dir, Group_ group) const;
const Group* group(size_t dir, size_t group) const;
const Group* group(size_t dir, Group_ tag) const;
const Group* group(const Direction& dir, Group_ group) const;
const Direction* direction(size_t dir) const;
uint8_t direction_count() const;
ArrayView<const Frame> frames(const Group& a) const;
ArrayView<const Frame> raw_frame_array() const;
const Info& info() const { return _info; }
StringView name() const { return _info.name; }
//StringView path() const { return _path; }
GL::Texture2D& texture();
static size_t enum_to_index(enum rotation x);
//static void validate(const wall_atlas& a, const ImageView2D& img) noexcept(false);
static Vector2ui expected_size(unsigned depth, Group_ group);
struct dir_tuple
{
StringView name;
Direction_ direction;
};
static constexpr dir_tuple directions[] = {
{ "n"_s, Direction_::N },
{ "e"_s, Direction_::E },
{ "s"_s, Direction_::S },
{ "w"_s, Direction_::W },
};
};
} // namespace floormat
|
