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
|
#include "Clouds.hpp"
#include "../Time.hpp"
#include "../Math/MVP.hpp"
#include "../Math/Perlin.hpp"
#include "../Math/AABB.hpp"
#include "../GFX/Util/Primitives.hpp"
#include "../GFX/Util/MeshBuilder.hpp"
#include <array>
namespace MC::World {
void Clouds::update(Time const& time) {
m_x_offset += 5.0 * time.delta();
}
void Clouds::render(GFX::Actions& actions, Position::World player_position) {
I32 center_x = std::round((player_position.x() - m_x_offset) / TileSize);
I32 center_y = std::round(player_position.z() / TileSize);
for (Int x = -1; x <= 1; x++) {
for (Int y = -1; y <= 1; y++) {
render_single_instance(actions, center_x + x, center_y + y);
}
}
}
void Clouds::render_single_instance(GFX::Actions& actions, Int x, Int y) {
Vector<3> position{TileSize * x + m_x_offset, Height, TileSize * y};
// m_program.bind();
//
// m_view_uniform.set(Math::MVP::view<F32>(camera.position(), camera.angles()));
// m_model_uniform.set(Math::MVP::model<F32>(position, Vector<3>{Scale}, {}));
//
// m_mesh.bind();
// glDrawElements(GL_TRIANGLES, m_mesh.size(), GL_UNSIGNED_INT, nullptr);
// m_mesh.unbind();
//
// m_program.unbind();
actions.add({
.mesh = &m_mesh,
.program = GFX::Resources::Program::Clouds,
.transform = Transform(
position,
Rotation::zero(),
Vec3(Scale)
),
});
}
Clouds::CloudMatrix Clouds::create_cloud_matrix() {
Math::Perlin::Noise<2> noise{};
CloudMatrix clouds{false};
for (Int x = 1; x < CloudMatrixSize; x++) {
for (Int y = 1; y < CloudMatrixSize; y++) {
if (noise.at({x, y * 2}) > 0.55) {
clouds(x, y) = true;
}
}
}
return clouds;
}
GFX::Mesh Clouds::create_mesh(CloudMatrix const& cloud_matrix) {
GFX::Util::MeshBuilder<Vector<3, F32>> builder{};
for (Int x = 0; x < CloudMatrixSize; x++) {
for (Int y = 0; y < CloudMatrixSize; y++) {
if (!cloud_matrix(x, y)) continue;
auto is_occupied = [&](Int xn, Int yn) {
if (xn < 0 || xn >= CloudMatrixSize || yn < 0 || yn >= CloudMatrixSize) return false;
return cloud_matrix(xn, yn);
};
std::array<bool, 4> neighbors = {
is_occupied(x - 1, y), is_occupied(x + 1, y),
is_occupied(x, y - 1), is_occupied(x, y + 1),
};
using FaceSet = GFX::Util::Primitives::FaceSet;
U8 faces = FaceSet::Top | FaceSet::Bottom;
if (!neighbors[0]) faces |= FaceSet::Left;
if (!neighbors[1]) faces |= FaceSet::Right;
if (!neighbors[2]) faces |= FaceSet::Front;
if (!neighbors[3]) faces |= FaceSet::Back;
auto aabb = AABB{{x, 0, y}, {x + 1, 1, y + 1}};
auto box = GFX::Util::Primitives::box(aabb, (FaceSet::Value)faces);
builder.primitive(box);
}
}
return builder.mesh();
}
}
|
