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
|
#include "terrain.h"
#include <algorithm>
#include <gfx/gl/sceneShader.h>
#include <gfx/gl/shadowMapper.h>
#include <gfx/image.h>
#include <gfx/models/mesh.h>
#include <gfx/models/vertex.h>
#include <glMappedBufferWriter.h>
#include <glm/glm.hpp>
#include <location.h>
#include <maths.h>
#include <utility>
#include <vector>
static constexpr RGB OPEN_SURFACE {-1};
template<>
VertexArrayObject &
VertexArrayObject::addAttribsFor<Terrain::Vertex>(const GLuint arrayBuffer, const GLuint divisor)
{
return addAttribs<Terrain::Vertex, &Terrain::Vertex::pos, &Terrain::Vertex::normal>(arrayBuffer, divisor);
}
bool
Terrain::SurfaceKey::operator<(const SurfaceKey & other) const
{
return std::tie(surface, basePosition.x, basePosition.y)
< std::tie(other.surface, other.basePosition.x, other.basePosition.y);
}
void
Terrain::generateMeshes()
{
constexpr GlobalDistance TILE_SIZE = 1024 * 1024; // ~1km, power of 2, fast divide
std::ranges::transform(all_vertices(), glMappedBufferWriter<Vertex> {GL_ARRAY_BUFFER, verticesBuffer, n_vertices()},
[this](const auto & vertex) {
return Vertex {point(vertex), normal(vertex)};
});
std::map<SurfaceKey, std::vector<GLuint>> surfaceIndices;
const auto getTile = [this](FaceHandle face) {
return point(*fv_begin(face)).xy() / TILE_SIZE;
};
const auto indexBySurfaceAndTile = std::views::transform([this, &getTile](const auto & faceItr) {
return std::pair<SurfaceKey, FaceHandle> {{getSurface(*faceItr), getTile(*faceItr)}, *faceItr};
});
const auto chunkBySurfaceAndTile = std::views::chunk_by([](const auto & face1, const auto & face2) {
return face1.first.surface == face2.first.surface && face1.first.basePosition == face2.first.basePosition;
});
for (const auto & faceRange : faces() | indexBySurfaceAndTile | chunkBySurfaceAndTile) {
const SurfaceKey & surfaceKey = faceRange.front().first;
auto indexItr = surfaceIndices.find(surfaceKey);
if (indexItr == surfaceIndices.end()) {
indexItr = surfaceIndices.emplace(surfaceKey, std::vector<GLuint> {}).first;
if (auto existing = meshes.find(surfaceKey); existing != meshes.end()) {
indexItr->second.reserve(static_cast<size_t>(existing->second.count));
}
}
for (auto push = std::back_inserter(indexItr->second); const auto & [_, face] : faceRange) {
std::ranges::transform(fv_range(face), push, &OpenMesh::VertexHandle::idx);
}
}
for (const auto & [surfaceKey, indices] : surfaceIndices) {
auto meshItr = meshes.find(surfaceKey);
if (meshItr == meshes.end()) {
meshItr = meshes.emplace(surfaceKey, SurfaceArrayBuffer {}).first;
VertexArrayObject {meshItr->second.vertexArray}
.addAttribsFor<Vertex>(verticesBuffer)
.addIndices(meshItr->second.indicesBuffer, indices)
.data(verticesBuffer, GL_ARRAY_BUFFER);
}
else {
VertexArrayObject {meshItr->second.vertexArray}
.addIndices(meshItr->second.indicesBuffer, indices)
.data(verticesBuffer, GL_ARRAY_BUFFER);
}
meshItr->second.count = static_cast<GLsizei>(indices.size());
}
if (meshes.size() > surfaceIndices.size()) {
std::erase_if(meshes, [&surfaceIndices](const auto & mesh) {
return !surfaceIndices.contains(mesh.first);
});
}
}
void
Terrain::tick(TickDuration)
{
}
void
Terrain::afterChange()
{
generateMeshes();
}
void
Terrain::render(const SceneShader & shader) const
{
grass->bind();
const auto chunkBySurface = std::views::chunk_by([](const auto & itr1, const auto & itr2) {
return itr1.first.surface == itr2.first.surface;
});
for (const auto & surfaceRange : meshes | chunkBySurface) {
const auto surface = surfaceRange.front().first.surface;
shader.landmass.use(surface ? surface->colorBias : OPEN_SURFACE);
for (const auto & sab : surfaceRange) {
glBindVertexArray(sab.second.vertexArray);
glDrawElements(GL_TRIANGLES, sab.second.count, GL_UNSIGNED_INT, nullptr);
}
}
glBindVertexArray(0);
}
void
Terrain::shadows(const ShadowMapper & shadowMapper) const
{
shadowMapper.landmess.use();
for (const auto & [surface, sab] : meshes) {
glBindVertexArray(sab.vertexArray);
glDrawElements(GL_TRIANGLES, sab.count, GL_UNSIGNED_INT, nullptr);
}
glBindVertexArray(0);
}
|
