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
|
#include "Clouds.hpp"
#include "../Math/MVP.hpp"
#include "../Math/Perlin.hpp"
#include "../GFX/Util/MeshBuilder.hpp"
#include <GL/glew.h>
#include <array>
namespace MC::World {
Clouds::Clouds(Real ascept, Real fov, Real near, Real far, Vector<3, F32> sky_color)
: m_position(-1000, 120, -1000),
m_program(
{GFX::Shading::Shader::Type::Vertex, vertex},
{GFX::Shading::Shader::Type::Fragment, fragment}
),
m_mesh(GFX::Binder::load(create_mesh(create_cloud_matrix()))),
m_model_uniform(), m_view_uniform(), m_projection_uniform() {
m_program.bind();
m_model_uniform = m_program.uniform("model_matrix");
m_view_uniform = m_program.uniform("view_matrix");
m_projection_uniform = m_program.uniform("projection_matrix");
auto sky_color_uniform = m_program.uniform("sky_color");
m_model_uniform.set(Math::MVP::model<F32>({}, {}, {}));
m_view_uniform.set(Math::MVP::view<F32>({}, {}));
m_projection_uniform.set(Math::MVP::perspective_projection<F32>(ascept, fov, near, far));
sky_color_uniform.set(sky_color);
m_program.unbind();
}
void Clouds::update(U64 time) {
m_position.x() += time / 5000.0;
}
void Clouds::render(const GFX::Camera& camera) const {
m_program.bind();
m_view_uniform.set(Math::MVP::view<F32>(camera.position(), camera.angles()));
m_model_uniform.set(Math::MVP::model<F32>(m_position, Vector<3>{10.0}, {}));
m_mesh.bind();
glDrawElements(GL_TRIANGLES, m_mesh.size(), GL_UNSIGNED_INT, nullptr);
m_mesh.unbind();
m_program.unbind();
}
Clouds::CloudMatrix Clouds::create_cloud_matrix() {
Math::Perlin::Noise<2> noise{};
CloudMatrix clouds{false};
for (Int x = 0; x < CloudMatrixSize; x++) {
for (Int y = 0; y < CloudMatrixSize; y++) {
if (noise.at({x, y * 2}) > 0.55) {
clouds(x, y) = true;
}
}
}
return clouds;
}
GFX::Mesh Clouds::create_mesh(const CloudMatrix& cloud_matrix) {
GFX::Util::MeshBuilder builder{};
for (Int x = 0; x < CloudMatrixSize; x++) {
for (Int y = 0; y < CloudMatrixSize; y++) {
if (!cloud_matrix(x, y)) continue;
U32 s = builder.vertex_count();
std::array<Vector<3, F32>, 4> positions = {{{0, 0, 0}, {1, 0, 0}, {0, 0, 1}, {1, 0, 1}}};
std::array<U32, 6> indices = { s + 0, s + 1, s + 2, s + 1, s + 3, s + 2 };
for (auto& p : positions) p += {x, 0, y};
builder.positions(positions);
builder.indices(indices);
}
}
return builder.mesh();
}
const Char* Clouds::vertex = R"v(
#version 330 core
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;
layout (location = 0) in vec3 position;
out float depth;
void main() {
vec4 world_position = model_matrix * vec4(position, 1.0);
vec4 view_position = view_matrix * world_position;
vec4 clip_position = projection_matrix * view_position;
gl_Position = clip_position;
depth = clamp((length(view_position) - 75) / 125, 0.0, 1.0);
}
)v";
const Char* Clouds::fragment = R"f(
#version 330 core
uniform vec3 sky_color;
in float depth;
out vec4 color;
void main() {
vec3 white = vec3(1.0, 1.0, 1.0);
color = vec4(mix(sky_color, white, 1 - depth), 0.5);
}
)f";
}
|
