oss/luanti
oss/luanti
1
0
Fork 0
mirror of https://github.com/luanti-org/luanti.git synced 2025-08-06 17:41:04 +00:00
Code Wiki Activity

Undo changes to the clouds

Browse source
This commit is contained in:
Gefüllte Taubenbrust 2024-12-28 21:41:33 +01:00
parent ba31db3eef
commit 6b6baf3fd7
1 changed files with 187 additions and 183 deletions
Download patch file Download diff file Expand all files Collapse all files

122
src/client/clouds.cpp
View file

@ -13,21 +13,22 @@
#include "settings.h" #include "settings.h"
#include <cmath> #include <cmath>
scene::ISceneManager *g_menucloudsmgr = nullptr; class Clouds;
Clouds *g_menuclouds = nullptr; scene::ISceneManager* g_menucloudsmgr = nullptr;
Clouds* g_menuclouds = nullptr;
// Constant for now // Constant for now
static constexpr const float cloud_size = BS * 64.0f; static constexpr const float cloud_size = BS * 64.0f;
static void cloud_3d_setting_changed(const std::string &settingname, void *data) static void cloud_3d_setting_changed(const std::string& settingname, void* data)
{ {
((Clouds *)data)->readSettings(); ((Clouds*)data)->readSettings();
} }
Clouds::Clouds(scene::ISceneManager* mgr, IShaderSource *ssrc, Clouds::Clouds(scene::ISceneManager* mgr, IShaderSource* ssrc,
s32 id, s32 id,
u32 seed u32 seed
): ) :
scene::ISceneNode(mgr->getRootSceneNode(), mgr, id), scene::ISceneNode(mgr->getRootSceneNode(), mgr, id),
m_seed(seed) m_seed(seed)
{ {
@ -62,7 +63,7 @@ Clouds::~Clouds()
void Clouds::OnRegisterSceneNode() void Clouds::OnRegisterSceneNode()
{ {
if(IsVisible) if (IsVisible)
{ {
SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT); SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT);
} }
@ -90,13 +91,16 @@ void Clouds::updateMesh()
if (!m_mesh_valid) { if (!m_mesh_valid) {
// mesh was never created or invalidated // mesh was never created or invalidated
} else if (m_mesh_origin.getDistanceFrom(m_origin) >= max_d) { }
else if (m_mesh_origin.getDistanceFrom(m_origin) >= max_d) {
// clouds moved // clouds moved
} else if (center_of_drawing_in_noise_i != m_last_noise_center) { }
else if (center_of_drawing_in_noise_i != m_last_noise_center) {
// noise offset changed // noise offset changed
// I think in practice this never happens due to the camera offset // I think in practice this never happens due to the camera offset
// being smaller than the cloud size.(?) // being smaller than the cloud size.(?)
} else { }
else {
return; return;
} }
@ -140,7 +144,7 @@ void Clouds::updateMesh()
std::vector<bool> grid(m_cloud_radius_i * 2 * m_cloud_radius_i * 2); std::vector<bool> grid(m_cloud_radius_i * 2 * m_cloud_radius_i * 2);
for(s16 zi = -m_cloud_radius_i; zi < m_cloud_radius_i; zi++) { for (s16 zi = -m_cloud_radius_i; zi < m_cloud_radius_i; zi++) {
u32 si = (zi + m_cloud_radius_i) * m_cloud_radius_i * 2 + m_cloud_radius_i; u32 si = (zi + m_cloud_radius_i) * m_cloud_radius_i * 2 + m_cloud_radius_i;
for (s16 xi = -m_cloud_radius_i; xi < m_cloud_radius_i; xi++) { for (s16 xi = -m_cloud_radius_i; xi < m_cloud_radius_i; xi++) {
@ -154,9 +158,9 @@ void Clouds::updateMesh()
} }
auto *mb = m_meshbuffer.get(); auto* mb = m_meshbuffer.get();
auto &vertices = mb->Vertices->Data; auto& vertices = mb->Vertices->Data;
auto &indices = mb->Indices->Data; auto& indices = mb->Indices->Data;
{ {
const u32 vertex_count = num_faces_to_draw * 16 * m_cloud_radius_i * m_cloud_radius_i; const u32 vertex_count = num_faces_to_draw * 16 * m_cloud_radius_i * m_cloud_radius_i;
const u32 quad_count = vertex_count / 4; const u32 quad_count = vertex_count / 4;
@ -172,15 +176,15 @@ void Clouds::updateMesh()
((x) >= -(radius) && (x) < (radius) && (z) >= -(radius) && (z) < (radius)) ((x) >= -(radius) && (x) < (radius) && (z) >= -(radius) && (z) < (radius))
vertices.clear(); vertices.clear();
for (s16 zi0= -m_cloud_radius_i; zi0 < m_cloud_radius_i; zi0++) for (s16 zi0 = -m_cloud_radius_i; zi0 < m_cloud_radius_i; zi0++)
for (s16 xi0= -m_cloud_radius_i; xi0 < m_cloud_radius_i; xi0++) for (s16 xi0 = -m_cloud_radius_i; xi0 < m_cloud_radius_i; xi0++)
{ {
s16 zi = zi0; s16 zi = zi0;
s16 xi = xi0; s16 xi = xi0;
// Draw from back to front for proper transparency // Draw from back to front for proper transparency
if(zi >= 0) if (zi >= 0)
zi = m_cloud_radius_i - zi - 1; zi = m_cloud_radius_i - zi - 1;
if(xi >= 0) if (xi >= 0)
xi = m_cloud_radius_i - xi - 1; xi = m_cloud_radius_i - xi - 1;
u32 i = GETINDEX(xi, zi, m_cloud_radius_i); u32 i = GETINDEX(xi, zi, m_cloud_radius_i);
@ -188,16 +192,7 @@ void Clouds::updateMesh()
if (!grid[i]) if (!grid[i])
continue; continue;
v2f p0 = v2f(xi,zi)*cloud_size + world_center_of_drawing_in_noise_f; v2f p0 = v2f(xi, zi) * cloud_size + world_center_of_drawing_in_noise_f;
const f32 rx = cloud_size / 2.0f;
// if clouds are flat, the top layer should be at the given height
const f32 ry = is3D() ? m_params.thickness * BS : 0.0f;
const f32 rz = cloud_size / 2;
bool soft_clouds_enabled = g_settings->getBool("soft_clouds");
v3f pos(p0.X, m_params.height * BS, p0.Y);
video::S3DVertex v[4] = { video::S3DVertex v[4] = {
video::S3DVertex(0,0,0, 0,0,0, c_top, 0, 1), video::S3DVertex(0,0,0, 0,0,0, c_top, 0, 1),
@ -206,18 +201,24 @@ void Clouds::updateMesh()
video::S3DVertex(0,0,0, 0,0,0, c_top, 0, 0) video::S3DVertex(0,0,0, 0,0,0, c_top, 0, 0)
}; };
const f32 rx = cloud_size / 2.0f;
// if clouds are flat, the top layer should be at the given height
const f32 ry = is3D() ? m_params.thickness * BS : 0.0f;
const f32 rz = cloud_size / 2;
bool soft_clouds_enabled = g_settings->getBool("soft_clouds");
for (u32 i = 0; i < num_faces_to_draw; i++) for (u32 i = 0; i < num_faces_to_draw; i++)
{ {
switch (i) switch (i)
{ {
case 0: // top case 0: // top
for (video::S3DVertex &vertex : v) { for (video::S3DVertex& vertex : v) {
vertex.Normal.set(0, 1, 0); vertex.Normal.set(0, 1, 0);
} }
v[0].Pos.set(-rx, ry,-rz); v[0].Pos.set(-rx, ry, -rz);
v[1].Pos.set(-rx, ry, rz); v[1].Pos.set(-rx, ry, rz);
v[2].Pos.set( rx, ry, rz); v[2].Pos.set(rx, ry, rz);
v[3].Pos.set( rx, ry,-rz); v[3].Pos.set(rx, ry, -rz);
break; break;
case 1: // back case 1: // back
if (INAREA(xi, zi - 1, m_cloud_radius_i)) { if (INAREA(xi, zi - 1, m_cloud_radius_i)) {
@ -226,22 +227,22 @@ void Clouds::updateMesh()
continue; continue;
} }
if (soft_clouds_enabled) { if (soft_clouds_enabled) {
for (video::S3DVertex &vertex : v) { for (video::S3DVertex& vertex : v) {
vertex.Normal.set(0, 0, -1); vertex.Normal.set(0, 0, -1);
} }
v[2].Color = c_bottom; v[2].Color = c_bottom;
v[3].Color = c_bottom; v[3].Color = c_bottom;
} }
else { else {
for (video::S3DVertex &vertex : v) { for (video::S3DVertex& vertex : v) {
vertex.Color = c_side_1; vertex.Color = c_side_1;
vertex.Normal.set(0, 0, -1); vertex.Normal.set(0, 0, -1);
} }
} }
v[0].Pos.set(-rx, ry,-rz); v[0].Pos.set(-rx, ry, -rz);
v[1].Pos.set( rx, ry,-rz); v[1].Pos.set(rx, ry, -rz);
v[2].Pos.set( rx, 0,-rz); v[2].Pos.set(rx, 0, -rz);
v[3].Pos.set(-rx, 0,-rz); v[3].Pos.set(-rx, 0, -rz);
break; break;
case 2: //right case 2: //right
if (INAREA(xi + 1, zi, m_cloud_radius_i)) { if (INAREA(xi + 1, zi, m_cloud_radius_i)) {
@ -250,22 +251,22 @@ void Clouds::updateMesh()
continue; continue;
} }
if (soft_clouds_enabled) { if (soft_clouds_enabled) {
for (video::S3DVertex &vertex : v) { for (video::S3DVertex& vertex : v) {
vertex.Normal.set(1, 0, 0); vertex.Normal.set(1, 0, 0);
} }
v[2].Color = c_bottom; v[2].Color = c_bottom;
v[3].Color = c_bottom; v[3].Color = c_bottom;
} }
else { else {
for (video::S3DVertex &vertex : v) { for (video::S3DVertex& vertex : v) {
vertex.Color = c_side_2; vertex.Color = c_side_2;
vertex.Normal.set(1, 0, 0); vertex.Normal.set(1, 0, 0);
} }
} }
v[0].Pos.set(rx, ry,-rz); v[0].Pos.set(rx, ry, -rz);
v[1].Pos.set(rx, ry, rz); v[1].Pos.set(rx, ry, rz);
v[2].Pos.set(rx, 0, rz); v[2].Pos.set(rx, 0, rz);
v[3].Pos.set(rx, 0,-rz); v[3].Pos.set(rx, 0, -rz);
break; break;
case 3: // front case 3: // front
if (INAREA(xi, zi + 1, m_cloud_radius_i)) { if (INAREA(xi, zi + 1, m_cloud_radius_i)) {
@ -274,22 +275,22 @@ void Clouds::updateMesh()
continue; continue;
} }
if (soft_clouds_enabled) { if (soft_clouds_enabled) {
for (video::S3DVertex &vertex : v) { for (video::S3DVertex& vertex : v) {
vertex.Normal.set(0, 0, -1); vertex.Normal.set(0, 0, -1);
} }
v[2].Color = c_bottom; v[2].Color = c_bottom;
v[3].Color = c_bottom; v[3].Color = c_bottom;
} }
else { else {
for (video::S3DVertex &vertex : v) { for (video::S3DVertex& vertex : v) {
vertex.Color = c_side_1; vertex.Color = c_side_1;
vertex.Normal.set(0, 0, -1); vertex.Normal.set(0, 0, -1);
} }
} }
v[0].Pos.set( rx, ry, rz); v[0].Pos.set(rx, ry, rz);
v[1].Pos.set(-rx, ry, rz); v[1].Pos.set(-rx, ry, rz);
v[2].Pos.set(-rx, 0, rz); v[2].Pos.set(-rx, 0, rz);
v[3].Pos.set( rx, 0, rz); v[3].Pos.set(rx, 0, rz);
break; break;
case 4: // left case 4: // left
if (INAREA(xi - 1, zi, m_cloud_radius_i)) { if (INAREA(xi - 1, zi, m_cloud_radius_i)) {
@ -298,36 +299,38 @@ void Clouds::updateMesh()
continue; continue;
} }
if (soft_clouds_enabled) { if (soft_clouds_enabled) {
for (video::S3DVertex &vertex : v) { for (video::S3DVertex& vertex : v) {
vertex.Normal.set(-1, 0, 0); vertex.Normal.set(-1, 0, 0);
} }
v[2].Color = c_bottom; v[2].Color = c_bottom;
v[3].Color = c_bottom; v[3].Color = c_bottom;
} }
else { else {
for (video::S3DVertex &vertex : v) { for (video::S3DVertex& vertex : v) {
vertex.Color = c_side_2; vertex.Color = c_side_2;
vertex.Normal.set(-1, 0, 0); vertex.Normal.set(-1, 0, 0);
} }
} }
v[0].Pos.set(-rx, ry, rz); v[0].Pos.set(-rx, ry, rz);
v[1].Pos.set(-rx, ry,-rz); v[1].Pos.set(-rx, ry, -rz);
v[2].Pos.set(-rx, 0,-rz); v[2].Pos.set(-rx, 0, -rz);
v[3].Pos.set(-rx, 0, rz); v[3].Pos.set(-rx, 0, rz);
break; break;
case 5: // bottom case 5: // bottom
for (video::S3DVertex &vertex : v) { for (video::S3DVertex& vertex : v) {
vertex.Color = c_bottom; vertex.Color = c_bottom;
vertex.Normal.set(0, -1, 0); vertex.Normal.set(0, -1, 0);
} }
v[0].Pos.set( rx, 0, rz); v[0].Pos.set(rx, 0, rz);
v[1].Pos.set(-rx, 0, rz); v[1].Pos.set(-rx, 0, rz);
v[2].Pos.set(-rx, 0,-rz); v[2].Pos.set(-rx, 0, -rz);
v[3].Pos.set( rx, 0,-rz); v[3].Pos.set(rx, 0, -rz);
break; break;
} }
for (video::S3DVertex &vertex : v) { v3f pos(p0.X, m_params.height * BS, p0.Y);
for (video::S3DVertex& vertex : v) {
vertex.Pos += pos; vertex.Pos += pos;
vertices.push_back(vertex); vertices.push_back(vertex);
} }
@ -341,7 +344,8 @@ void Clouds::updateMesh()
if (mb->getIndexCount() > index_count) { if (mb->getIndexCount() > index_count) {
indices.resize(index_count); indices.resize(index_count);
mb->setDirty(scene::EBT_INDEX); mb->setDirty(scene::EBT_INDEX);
} else if (mb->getIndexCount() < index_count) { }
else if (mb->getIndexCount() < index_count) {
const u32 start = mb->getIndexCount() / 6; const u32 start = mb->getIndexCount() / 6;
assert(start * 6 == mb->getIndexCount()); assert(start * 6 == mb->getIndexCount());
for (u32 k = start; k < quad_count; k++) { for (u32 k = start; k < quad_count; k++) {
@ -389,7 +393,7 @@ void Clouds::render()
const float cloud_full_radius = cloud_size * m_cloud_radius_i; const float cloud_full_radius = cloud_size * m_cloud_radius_i;
// Get fog parameters for setting them back later // Get fog parameters for setting them back later
video::SColor fog_color(0,0,0,0); video::SColor fog_color(0, 0, 0, 0);
video::E_FOG_TYPE fog_type = video::EFT_FOG_LINEAR; video::E_FOG_TYPE fog_type = video::EFT_FOG_LINEAR;
f32 fog_start = 0; f32 fog_start = 0;
f32 fog_end = 0; f32 fog_end = 0;
@ -402,7 +406,7 @@ void Clouds::render()
// Set our own fog, unless it was already disabled // Set our own fog, unless it was already disabled
if (fog_start < FOG_RANGE_ALL) { if (fog_start < FOG_RANGE_ALL) {
driver->setFog(fog_color, fog_type, cloud_full_radius * 0.5, driver->setFog(fog_color, fog_type, cloud_full_radius * 0.5,
cloud_full_radius*1.2, fog_density, fog_pixelfog, fog_rangefog); cloud_full_radius * 1.2, fog_density, fog_pixelfog, fog_rangefog);
} }
driver->drawMeshBuffer(m_meshbuffer.get()); driver->drawMeshBuffer(m_meshbuffer.get());
@ -417,7 +421,7 @@ void Clouds::step(float dtime)
m_origin = m_origin + dtime * BS * m_params.speed; m_origin = m_origin + dtime * BS * m_params.speed;
} }
void Clouds::update(const v3f &camera_p, const video::SColorf &color_diffuse) void Clouds::update(const v3f& camera_p, const video::SColorf& color_diffuse)
{ {
video::SColorf ambient(m_params.color_ambient); video::SColorf ambient(m_params.color_ambient);
video::SColorf bright(m_params.color_bright); video::SColorf bright(m_params.color_bright);