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
|
#include "chunk.hpp"
#include "tile-bbox.hpp"
#include "quads.hpp"
#include "wall-atlas.hpp"
#include "shaders/shader.hpp"
#include <Corrade/Containers/ArrayView.h>
#include <Corrade/Containers/PairStl.h>
#include <algorithm>
// +x +y +z
// +x +y -z
// -x -y +z
// -x +y -z
namespace floormat {
using namespace floormat::Quads;
using Wall::Group_;
namespace {
constexpr Vector2 half_tile = TILE_SIZE2*.5f;
constexpr float hx = half_tile.x(), hy = half_tile.y();
constexpr float tile_height = TILE_SIZE.z();
} // namespace
void chunk::ensure_alloc_walls()
{
if (!_walls) [[unlikely]]
_walls = Pointer<wall_stuff>{InPlaceInit};
}
// -----------------------
// wall north
template<> std::array<Vector3, 4> chunk::make_wall_vertex_data<Group_::wall, false>(Vector2 center, float depth)
{
auto quad = wall_quad_N(Vector3(center, tile_height), TILE_SIZE);
}
// wall west
template<> std::array<Vector3, 4> chunk::make_wall_vertex_data<Group_::wall, true>(Vector2 center, float depth)
{
}
// -----------------------
fm_noinline
GL::Mesh chunk::make_wall_mesh(size_t count)
{
fm_debug_assert(_walls);
//std::array<std::array<vertex, 4>, TILE_COUNT*2> vertexes;
vertex vertexes[TILE_COUNT*2][4];
for (auto k = 0uz; k < count; k++)
{
const uint16_t i = _walls->indexes[k];
const auto& atlas = _walls->atlases[i];
const auto& variant = _walls->variants[i];
const local_coords pos{i / 2u};
const auto center = Vector3(pos) * TILE_SIZE;
const auto quad = i & 1 ? wall_quad_W(center, TILE_SIZE) : wall_quad_N(center, TILE_SIZE);
const float depth = tile_shader::depth_value(pos, tile_shader::wall_depth_offset);
const auto texcoords = atlas->texcoords_for_id(variant);
auto& v = vertexes[k];
for (auto j = 0uz; j < 4; j++)
v[j] = { quad[j], texcoords[j], depth, };
}
auto indexes = make_index_array<2>(count);
const auto vertex_view = ArrayView{&vertexes[0], count};
const auto vert_index_view = ArrayView{indexes.data(), count};
GL::Mesh mesh{GL::MeshPrimitive::Triangles};
mesh.addVertexBuffer(GL::Buffer{vertex_view}, 0, tile_shader::Position{}, tile_shader::TextureCoordinates{}, tile_shader::Depth{})
.setIndexBuffer(GL::Buffer{vert_index_view}, 0, GL::MeshIndexType::UnsignedShort)
.setCount(int32_t(6 * count));
return mesh;
}
auto chunk::ensure_wall_mesh() noexcept -> wall_mesh_tuple
{
if (!_walls)
return {wall_mesh, {}, 0};
if (!_walls_modified)
return { wall_mesh, _walls->wall_indexes, size_t(wall_mesh.count()/6) };
_walls_modified = false;
size_t count = 0;
for (auto i = 0uz; i < TILE_COUNT*2; i++)
if (_walls->_wall_atlases[i])
_walls->wall_indexes[count++] = uint16_t(i);
std::sort(_walls->wall_indexes.data(), _walls->wall_indexes.data() + (ptrdiff_t)count,
[this](uint16_t a, uint16_t b) {
return _walls->_wall_atlases[a] < _walls->_wall_atlases[b];
});
wall_mesh = make_wall_mesh(count);
return { wall_mesh, _walls->wall_indexes, count };
}
} // namespace floormat
|
