voxelcoreprojects/voxelcore
1
0
Fork 0
mirror of https://github.com/MihailRis/voxelcore.git synced 2026-10-04 18:41:51 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

test looped clouds

Browse source
This commit is contained in:
MihailRis 2026-02-11 13:56:56 +03:00
parent ef16b01159
commit a1cb939b9e
1 changed files with 40 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

66
src/graphics/render/CloudsRenderer.cpp
View file

@ -173,25 +173,43 @@ CloudsRenderer::CloudsRenderer(const Assets& assets) : assets(assets) {
const int w = WIDTH;
const int h = 8;
const int d = DEPTH;
const int dd = d * 1.5;
state.seed = 52365 + layer * 3521;
state.seed = 5265 + layer * 3521;
float pi2 = glm::two_pi<float>();
float heightmap[w * dd];
for (int lz = 0; lz < dd; lz++) {
for (int lx = 0; lx < w; lx++) {
float x = glm::sin(lx / static_cast<float>(w) * pi2) * w / pi2;
float y = -glm::cos(lx / static_cast<float>(w) * pi2) * w / pi2;
float z = lz;
float s = 2.0f;
auto n = fnlGetNoise3D(&state, x * s, y * s, z * s);
n += fnlGetNoise3D(&state, x * s + fnlGetNoise2D(&state, x * s * 4 + 2, z * s * 4) * 0.25f, y * s, z * 3.0f) * 0.5f;
n += fnlGetNoise3D(&state, x * s * 2, y * s * 2, z * s * 2) * 0.25f;
n += fnlGetNoise3D(&state, x * s * 4, y * s * 4, z * s * 4) * 0.125f * 2;
n += fnlGetNoise3D(&state, x * s * 8, y * s * 8, z * s * 8) * 0.125f * 0.5f * 2;
n += fnlGetNoise3D(&state, x * s * 16, y * s * 16, z * s * 16) * 0.125f * 0.25f * 3;
n = glm::max(0.0f, n);
// n = n * n * 2.0f;
n -= 0.2f + layer * 0.5f;
// n -= 0.5f;
heightmap[lz * w + lx] = n;
}
}
bool voxels[w * h * d];
for (int y = 0; y < h; y++) {
for (int z = 0; z < d; z++) {
for (int x = 0; x < w; x++) {
float s = 2.0f;
auto n = fnlGetNoise2D(&state, x * s, z * s);
n += fnlGetNoise2D(&state, x * s + fnlGetNoise2D(&state, x * s * 4 + 2, z * s * 4) * 0.25f, z * 3.0f) * 0.5f;
n += fnlGetNoise2D(&state, x * s * 2, z * s * 2) * 0.25f;
n += fnlGetNoise2D(&state, x * s * 4, z * s * 4) * 0.125f * 2;
n += fnlGetNoise2D(&state, x * s * 8, z * s * 8) * 0.125f * 0.5f * 2;
n += fnlGetNoise2D(&state, x * s * 16, z * s * 16) * 0.125f * 0.25f * 3;
n = glm::max(0.0f, n);
// n = n * n * 2.0f;
n -= 0.2f + layer * 0.5f;
// n -= 0.5f;
float n = heightmap[z * w + x];
if (z < d / 2) {
float t = z / static_cast<float>(d / 2);
n = n * t + heightmap[(d + z) * w + x] * (1.0f - t);
}
bool solid = y <= n * h && y >= (0.5f - n * 0.5f) * h;
voxels[vox_index(x, y, z, w, d)] = solid;
}
@ -208,8 +226,6 @@ CloudsRenderer::CloudsRenderer(const Assets& assets) : assets(assets) {
CloudsRenderer::~CloudsRenderer() = default;
#include "util/timeutil.hpp"
void CloudsRenderer::draw(float timer, float fogFactor, const Camera& camera) {
auto& shader = assets.require<Shader>("main");
assets.require<Texture>("misc/blank").bind();
@ -218,26 +234,24 @@ void CloudsRenderer::draw(float timer, float fogFactor, const Camera& camera) {
float totalWidth = WIDTH * scale;
float totalDepth = DEPTH * scale;
int cellX = glm::round(camera.position.x / totalWidth);
int cellZ = glm::round(camera.position.z / totalDepth);
float speed = 10.0f;
timeutil::ScopeLogTimer log(555);
int cellX = glm::floor(camera.position.x / totalWidth + 0.5f);
int cellZ = glm::floor(camera.position.z / totalDepth + 0.5f);
float speed = 10.0f * 100.0;
for (int i = 0; i < 2; i++) {
float speedX = glm::sin(i * 0.3f) * speed / (i + 1);
float speedZ = -glm::cos(i * 0.3f) * speed / (i + 1);
float speedX = glm::sin(i * 0.3f + 0.4f) * speed / (i + 1);
float speedZ = -glm::cos(i * 0.3f + 0.4f) * speed / (i + 1);
for (int x = -2; x <= 2; x++) {
for (int z = -2; z <= 2; z++) {
auto matrix = glm::mat4(1.0f);
// matrix = glm::rotate(matrix, timer * 0.003f * (i % 2 * 2 - 1) + i, glm::vec3(0, 1, 0));
matrix = glm::translate(
matrix,
glm::vec3(
-128 * scale + (x + cellX) * WIDTH * scale + glm::mod(timer * speedX, totalWidth),
-128 * scale + (x + cellX) * WIDTH * scale +
glm::mod(timer * speedX, totalWidth),
250 + i * 200,
-128 * scale + (z + cellZ) * DEPTH * scale + glm::mod(timer * speedZ, totalDepth)
-128 * scale + (z + cellZ) * DEPTH * scale +
glm::mod(timer * speedZ, totalDepth)
)
);
matrix = glm::scale(matrix, glm::vec3(scale, scale, scale));