Standard-of-Iron/render/ground/terrain_renderer.cpp

#include "terrain_renderer.h"
#include "../../game/map/visibility_service.h"
#include "../gl/mesh.h"
#include "../gl/render_constants.h"
#include "../gl/resources.h"
#include "../scene_renderer.h"
#include "ground/terrain_gpu.h"
#include "ground_utils.h"
#include "map/terrain.h"
#include <QDebug>
#include <QElapsedTimer>
#include <QQuaternion>
#include <QVector2D>
#include <QtGlobal>
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <memory>
#include <qelapsedtimer.h>
#include <qglobal.h>
#include <qmatrix4x4.h>
#include <qvectornd.h>
#include <unordered_map>
#include <utility>
#include <vector>

namespace {

using std::uint32_t;
using namespace Render::GL::BitShift;
using namespace Render::GL::Geometry;
using namespace Render::GL::HashXorShift;
using namespace Render::Ground;

const QMatrix4x4 k_identity_matrix;

inline auto applyTint(const QVector3D &color, float tint) -> QVector3D {
  QVector3D const c = color * tint;
  return {std::clamp(c.x(), 0.0F, 1.0F), std::clamp(c.y(), 0.0F, 1.0F),
          std::clamp(c.z(), 0.0F, 1.0F)};
}

inline auto clamp01(const QVector3D &c) -> QVector3D {
  return {std::clamp(c.x(), 0.0F, 1.0F), std::clamp(c.y(), 0.0F, 1.0F),
          std::clamp(c.z(), 0.0F, 1.0F)};
}

inline auto linstep(float a, float b, float x) -> float {
  return std::clamp((x - a) / std::max(1e-6F, (b - a)), 0.0F, 1.0F);
}
inline auto smooth(float a, float b, float x) -> float {
  float const t = linstep(a, b, x);
  return t * t * (3.0F - 2.0F * t);
}

inline auto value_noise(float x, float z, uint32_t salt = 0U) -> float {
  int const x0 = int(std::floor(x));
  int const z0 = int(std::floor(z));
  int const x1 = x0 + 1;
  int const z1 = z0 + 1;
  float const tx = x - float(x0);
  float const tz = z - float(z0);
  float const n00 = hash_to_01(hash_coords(x0, z0, salt));
  float const n10 = hash_to_01(hash_coords(x1, z0, salt));
  float const n01 = hash_to_01(hash_coords(x0, z1, salt));
  float const n11 = hash_to_01(hash_coords(x1, z1, salt));
  float const nx0 = n00 * (1 - tx) + n10 * tx;
  float const nx1 = n01 * (1 - tx) + n11 * tx;
  return nx0 * (1 - tz) + nx1 * tz;
}

} // namespace

namespace Render::GL {

TerrainRenderer::TerrainRenderer() = default;
TerrainRenderer::~TerrainRenderer() = default;

void TerrainRenderer::configure(
    const Game::Map::TerrainHeightMap &height_map,
    const Game::Map::BiomeSettings &biome_settings) {
  m_width = height_map.getWidth();
  m_height = height_map.getHeight();
  m_tile_size = height_map.getTileSize();

  m_height_data = height_map.getHeightData();
  m_terrain_types = height_map.getTerrainTypes();
  m_hill_entrances = height_map.getHillEntrances();
  m_biome_settings = biome_settings;
  m_noise_seed = biome_settings.seed;
  build_meshes();
}

void TerrainRenderer::submit(Renderer &renderer, ResourceManager *resources) {
  if (m_chunks.empty()) {
    return;
  }

  Q_UNUSED(resources);

  auto &visibility = Game::Map::VisibilityService::instance();
  const bool use_visibility = visibility.is_initialized();
  Game::Map::VisibilityService::Snapshot visibility_snapshot;
  std::uint64_t visibility_version = 0;
  if (use_visibility) {
    visibility_snapshot = visibility.snapshot();
    visibility_version = visibility.version();
    if (m_chunk_visibility_cache.size() != m_chunks.size()) {
      m_chunk_visibility_cache.assign(m_chunks.size(), {});
    }
  }

  for (std::size_t chunk_index = 0; chunk_index < m_chunks.size();
       ++chunk_index) {
    const auto &chunk = m_chunks[chunk_index];
    if (!chunk.mesh) {
      continue;
    }

    if (use_visibility) {
      auto &cache = m_chunk_visibility_cache[chunk_index];
      if (cache.visibility_version != visibility_version) {
        bool any_visible = false;
        for (int gz = chunk.min_z; gz <= chunk.max_z && !any_visible; ++gz) {
          for (int gx = chunk.min_x; gx <= chunk.max_x; ++gx) {
            if (visibility_snapshot.stateAt(gx, gz) ==
                Game::Map::VisibilityState::Visible) {
              any_visible = true;
              break;
            }
          }
        }
        cache.any_visible = any_visible;
        cache.visibility_version = visibility_version;
      }
      if (!cache.any_visible) {
        continue;
      }
    }

    renderer.terrain_chunk(chunk.mesh.get(), k_identity_matrix, chunk.params,
                           0x0080U, true, 0.0F);
  }
}

auto TerrainRenderer::section_for(Game::Map::TerrainType type) -> int {
  switch (type) {
  case Game::Map::TerrainType::Mountain:
    return 2;
  case Game::Map::TerrainType::Hill:
    return 1;
  case Game::Map::TerrainType::Forest:
  case Game::Map::TerrainType::Flat:
  default:
    return 0;
  }
}

void TerrainRenderer::build_meshes() {
  QElapsedTimer timer;
  timer.start();

  m_chunks.clear();
  m_chunk_visibility_cache.clear();

  if (m_width < 2 || m_height < 2 || m_height_data.empty()) {
    return;
  }

  std::vector<float> height_data = m_height_data;
  std::vector<float> entry_weight;
  if (!m_hill_entrances.empty() &&
      m_hill_entrances.size() == height_data.size()) {
    constexpr int k_entry_radius = 4;
    entry_weight.assign(height_data.size(), 0.0F);
    for (int z = 0; z < m_height; ++z) {
      for (int x = 0; x < m_width; ++x) {
        int const idx = z * m_width + x;
        if (m_terrain_types[idx] != Game::Map::TerrainType::Hill) {
          continue;
        }
        float min_dist = float(k_entry_radius + 1);
        for (int dz = -k_entry_radius; dz <= k_entry_radius; ++dz) {
          int const nz = z + dz;
          if (nz < 0 || nz >= m_height) {
            continue;
          }
          for (int dx = -k_entry_radius; dx <= k_entry_radius; ++dx) {
            int const nx = x + dx;
            if (nx < 0 || nx >= m_width) {
              continue;
            }
            int const n_idx = nz * m_width + nx;
            if (!m_hill_entrances[n_idx]) {
              continue;
            }
            float const dist = std::sqrt(float(dx * dx + dz * dz));
            min_dist = std::min(min_dist, dist);
          }
        }
        if (min_dist <= k_entry_radius) {
          float const t = 1.0F - (min_dist / float(k_entry_radius));
          entry_weight[idx] = t * t;
        }
      }
    }
  }

  float min_h = std::numeric_limits<float>::infinity();
  float max_h = -std::numeric_limits<float>::infinity();
  for (float const h : height_data) {
    min_h = std::min(min_h, h);
    max_h = std::max(max_h, h);
  }
  const float height_range = std::max(1e-4F, max_h - min_h);

  const float half_width = m_width * 0.5F - 0.5F;
  const float half_height = m_height * 0.5F - 0.5F;
  const int vertex_count = m_width * m_height;

  std::vector<QVector3D> positions(vertex_count);
  std::vector<QVector3D> normals(vertex_count, QVector3D(0.0F, 0.0F, 0.0F));
  std::vector<QVector3D> face_accum(vertex_count, QVector3D(0, 0, 0));

  for (int z = 0; z < m_height; ++z) {
    for (int x = 0; x < m_width; ++x) {
      int const idx = z * m_width + x;
      float const world_x = (x - half_width) * m_tile_size;
      float const world_z = (z - half_height) * m_tile_size;
      positions[idx] = QVector3D(world_x, height_data[idx], world_z);
    }
  }

  auto sample_height_at = [&](float gx, float gz) {
    gx = std::clamp(gx, 0.0F, float(m_width - 1));
    gz = std::clamp(gz, 0.0F, float(m_height - 1));
    int const x0 = int(std::floor(gx));
    int const z0 = int(std::floor(gz));
    int const x1 = std::min(x0 + 1, m_width - 1);
    int const z1 = std::min(z0 + 1, m_height - 1);
    float const tx = gx - float(x0);
    float const tz = gz - float(z0);
    float const h00 = height_data[z0 * m_width + x0];
    float const h10 = height_data[z0 * m_width + x1];
    float const h01 = height_data[z1 * m_width + x0];
    float const h11 = height_data[z1 * m_width + x1];
    float const h0 = h00 * (1.0F - tx) + h10 * tx;
    float const h1 = h01 * (1.0F - tx) + h11 * tx;
    return h0 * (1.0F - tz) + h1 * tz;
  };

  auto sample_entry_at = [&](float gx, float gz) {
    if (entry_weight.empty()) {
      return 0.0F;
    }
    gx = std::clamp(gx, 0.0F, float(m_width - 1));
    gz = std::clamp(gz, 0.0F, float(m_height - 1));
    int const x0 = int(std::floor(gx));
    int const z0 = int(std::floor(gz));
    int const x1 = std::min(x0 + 1, m_width - 1);
    int const z1 = std::min(z0 + 1, m_height - 1);
    float const tx = gx - float(x0);
    float const tz = gz - float(z0);
    float const e00 = entry_weight[z0 * m_width + x0];
    float const e10 = entry_weight[z0 * m_width + x1];
    float const e01 = entry_weight[z1 * m_width + x0];
    float const e11 = entry_weight[z1 * m_width + x1];
    float const e0 = e00 * (1.0F - tx) + e10 * tx;
    float const e1 = e01 * (1.0F - tx) + e11 * tx;
    return e0 * (1.0F - tz) + e1 * tz;
  };

  auto normal_from_heights_at = [&](float gx, float gz) {
    float const gx0 = std::clamp(gx - 1.0F, 0.0F, float(m_width - 1));
    float const gx1 = std::clamp(gx + 1.0F, 0.0F, float(m_width - 1));
    float const gz0 = std::clamp(gz - 1.0F, 0.0F, float(m_height - 1));
    float const gz1 = std::clamp(gz + 1.0F, 0.0F, float(m_height - 1));
    float const h_l = sample_height_at(gx0, gz);
    float const h_r = sample_height_at(gx1, gz);
    float const h_d = sample_height_at(gx, gz0);
    float const h_u = sample_height_at(gx, gz1);
    QVector3D const dx(2.0F * m_tile_size, h_r - h_l, 0.0F);
    QVector3D const dz(0.0F, h_u - h_d, 2.0F * m_tile_size);
    QVector3D n = QVector3D::crossProduct(dz, dx);
    if (n.lengthSquared() > 0.0F) {
      n.normalize();
    }
    return n.isNull() ? QVector3D(0, 1, 0) : n;
  };

  for (int i = 0; i < vertex_count; ++i) {
    int const x = i % m_width;
    int const z = i / m_width;
    normals[i] = normal_from_heights_at(float(x), float(z));
    face_accum[i] = normals[i];
  }

  {
    std::vector<QVector3D> filtered = normals;
    auto get_n = [&](int x, int z) -> QVector3D & {
      return normals[z * m_width + x];
    };

    for (int z = 1; z < m_height - 1; ++z) {
      for (int x = 1; x < m_width - 1; ++x) {
        const int idx = z * m_width + x;
        const float h0 = height_data[idx];
        const float nh = (h0 - min_h) / height_range;

        const float h_l = height_data[z * m_width + (x - 1)];
        const float h_r = height_data[z * m_width + (x + 1)];
        const float h_d = height_data[(z - 1) * m_width + x];
        const float h_u = height_data[(z + 1) * m_width + x];
        const float avg_nbr = 0.25F * (h_l + h_r + h_d + h_u);
        const float convexity = h0 - avg_nbr;

        const QVector3D n0 = normals[idx];
        const float slope = 1.0F - std::clamp(n0.y(), 0.0F, 1.0F);

        const float ridge_s = smooth(0.35F, 0.70F, slope);
        const float ridge_c = smooth(-0.02F, 0.18F, convexity);
        const float ridge_factor =
            std::clamp(0.5F * ridge_s + 0.5F * ridge_c, 0.0F, 1.0F);
        const float base_boost = 0.6F * (1.0F - nh);

        QVector3D acc(0, 0, 0);
        float wsum = 0.0F;
        for (int dz = -1; dz <= 1; ++dz) {
          for (int dx = -1; dx <= 1; ++dx) {
            const int nx = x + dx;
            const int nz = z + dz;
            const int n_idx = nz * m_width + nx;

            const float dh = std::abs(height_data[n_idx] - h0);
            const QVector3D nn = get_n(nx, nz);
            const float ndot = std::max(0.0F, QVector3D::dotProduct(n0, nn));

            const float w_h = 1.0F / (1.0F + 2.0F * dh);
            const float w_n = std::pow(ndot, 8.0F);
            const float w_b = 1.0F + base_boost;
            const float w_r = 1.0F - ridge_factor * 0.85F;

            const float w = w_h * w_n * w_b * w_r;
            acc += nn * w;
            wsum += w;
          }
        }

        QVector3D n_filtered = (wsum > 0.0F) ? (acc / wsum) : n0;
        n_filtered.normalize();

        const QVector3D n_orig = face_accum[idx];
        const QVector3D n_final =
            (ridge_factor > 0.0F)
                ? (n_filtered * (1.0F - ridge_factor) + n_orig * ridge_factor)
                : n_filtered;

        filtered[idx] = n_final.normalized();
      }
    }
    normals.swap(filtered);
  }

  auto quad_section = [&](Game::Map::TerrainType a, Game::Map::TerrainType b,
                          Game::Map::TerrainType c, Game::Map::TerrainType d) {
    int const priority_a = section_for(a);
    int const priority_b = section_for(b);
    int const priority_c = section_for(c);
    int const priority_d = section_for(d);
    int result = priority_a;
    result = std::max(result, priority_b);
    result = std::max(result, priority_c);
    result = std::max(result, priority_d);
    return result;
  };

  const int chunk_size = DefaultChunkSize;
  std::size_t total_triangles = 0;

  for (int chunk_z = 0; chunk_z < m_height - 1; chunk_z += chunk_size) {
    int const chunk_max_z = std::min(chunk_z + chunk_size, m_height - 1);
    for (int chunk_x = 0; chunk_x < m_width - 1; chunk_x += chunk_size) {
      int const chunk_max_x = std::min(chunk_x + chunk_size, m_width - 1);

      struct SectionData {
        std::vector<Vertex> vertices;
        std::vector<unsigned int> indices;
        std::unordered_map<int, unsigned int> remap;
        float heightSum = 0.0F;
        int heightCount = 0;
        float rotationDeg = 0.0F;
        bool flipU = false;
        float tint = 1.0F;
        QVector3D normalSum = QVector3D(0, 0, 0);
        float slopeSum = 0.0F;
        float heightVarSum = 0.0F;
        int statCount = 0;

        float aoSum = 0.0F;
        int aoCount = 0;
      };

      SectionData sections[3];

      uint32_t const chunk_seed = hash_coords(chunk_x, chunk_z, m_noise_seed);
      uint32_t const variant_seed = chunk_seed ^ k_golden_ratio;
      constexpr int k_rotation_shift = 5;
      constexpr int k_rotation_mask = 3;
      constexpr float k_rotation_step_degrees = 90.0F;
      constexpr int k_flip_shift = 7;
      constexpr int k_tint_shift = 12;
      constexpr int k_tint_variant_count = 7;

      float const rotation_step =
          static_cast<float>((variant_seed >> k_rotation_shift) &
                             k_rotation_mask) *
          k_rotation_step_degrees;
      bool const flip = ((variant_seed >> k_flip_shift) & 1U) != 0U;
      static const float tint_variants[k_tint_variant_count] = {
          0.9F, 0.94F, 0.97F, 1.0F, 1.03F, 1.06F, 1.1F};
      float const tint =
          tint_variants[(variant_seed >> k_tint_shift) % k_tint_variant_count];

      for (auto &section : sections) {
        section.rotationDeg = rotation_step;
        section.flipU = flip;
        section.tint = tint;
      }

      auto ensure_vertex = [&](SectionData &section,
                               int globalIndex) -> unsigned int {
        auto it = section.remap.find(globalIndex);
        if (it != section.remap.end()) {
          return it->second;
        }
        Vertex v{};
        const QVector3D &pos = positions[globalIndex];
        const QVector3D &normal = normals[globalIndex];
        v.position[0] = pos.x();
        v.position[1] = pos.y();
        v.position[2] = pos.z();
        v.normal[0] = normal.x();
        v.normal[1] = normal.y();
        v.normal[2] = normal.z();

        float const tex_scale = 0.2F / std::max(1.0F, m_tile_size);
        float uu = pos.x() * tex_scale;
        float const vv = pos.z() * tex_scale;

        if (section.flipU) {
          uu = -uu;
        }
        float ru = uu;
        float rv = vv;
        switch (static_cast<int>(section.rotationDeg)) {
        case 90: {
          float const t = ru;
          ru = -rv;
          rv = t;
        } break;
        case 180:
          ru = -ru;
          rv = -rv;
          break;
        case 270: {
          float const t = ru;
          ru = rv;
          rv = -t;
        } break;
        default:
          break;
        }
        v.tex_coord[0] = ru;
        v.tex_coord[1] =
            entry_weight.empty() ? 0.0F : entry_weight[globalIndex];

        section.vertices.push_back(v);
        auto const local_index =
            static_cast<unsigned int>(section.vertices.size() - 1);
        section.remap.emplace(globalIndex, local_index);
        section.normalSum += normal;
        return local_index;
      };

      auto add_vertex = [&](SectionData &section, const QVector3D &pos,
                            const QVector3D &normal,
                            float entry_mask) -> unsigned int {
        Vertex v{};
        v.position[0] = pos.x();
        v.position[1] = pos.y();
        v.position[2] = pos.z();
        v.normal[0] = normal.x();
        v.normal[1] = normal.y();
        v.normal[2] = normal.z();

        float const tex_scale = 0.2F / std::max(1.0F, m_tile_size);
        float uu = pos.x() * tex_scale;
        float const vv = pos.z() * tex_scale;
        if (section.flipU) {
          uu = -uu;
        }
        float ru = uu;
        float rv = vv;
        switch (static_cast<int>(section.rotationDeg)) {
        case 90: {
          float const t = ru;
          ru = -rv;
          rv = t;
        } break;
        case 180:
          ru = -ru;
          rv = -rv;
          break;
        case 270: {
          float const t = ru;
          ru = rv;
          rv = -t;
        } break;
        default:
          break;
        }
        v.tex_coord[0] = ru;
        v.tex_coord[1] = entry_weight.empty() ? 0.0F : entry_mask;

        section.vertices.push_back(v);
        auto const local_index =
            static_cast<unsigned int>(section.vertices.size() - 1);
        section.normalSum += normal;
        return local_index;
      };

      auto add_vertex_at_grid = [&](SectionData &section, float gx, float gz,
                                    float entry_mask) -> unsigned int {
        float const world_x = (gx - half_width) * m_tile_size;
        float const world_z = (gz - half_height) * m_tile_size;
        float const h = sample_height_at(gx, gz);
        QVector3D const pos(world_x, h, world_z);
        QVector3D const normal = normal_from_heights_at(gx, gz);
        return add_vertex(section, pos, normal, entry_mask);
      };

      for (int z = chunk_z; z < chunk_max_z; ++z) {
        for (int x = chunk_x; x < chunk_max_x; ++x) {
          int const idx0 = z * m_width + x;
          int const idx1 = idx0 + 1;
          int const idx2 = (z + 1) * m_width + x;
          int const idx3 = idx2 + 1;

          int const section_index =
              quad_section(m_terrain_types[idx0], m_terrain_types[idx1],
                           m_terrain_types[idx2], m_terrain_types[idx3]);

          if (section_index > 0) {
            SectionData &section = sections[section_index];
            unsigned int const v0 = ensure_vertex(section, idx0);
            unsigned int const v1 = ensure_vertex(section, idx1);
            unsigned int const v2 = ensure_vertex(section, idx2);
            unsigned int const v3 = ensure_vertex(section, idx3);

            float entry_factor = 0.0F;
            if (!entry_weight.empty()) {
              entry_factor = 0.25F * (entry_weight[idx0] + entry_weight[idx1] +
                                      entry_weight[idx2] + entry_weight[idx3]);
            }
            bool const subdivide = entry_factor > 0.25F;

            if (subdivide) {
              float const gx = float(x);
              float const gz = float(z);
              unsigned int const v00 = v0;
              unsigned int const v20 = v1;
              unsigned int const v02 = v2;
              unsigned int const v22 = v3;

              unsigned int const v10 = add_vertex_at_grid(
                  section, gx + 0.5F, gz, sample_entry_at(gx + 0.5F, gz));
              unsigned int const v01 = add_vertex_at_grid(
                  section, gx, gz + 0.5F, sample_entry_at(gx, gz + 0.5F));
              unsigned int const v21 =
                  add_vertex_at_grid(section, gx + 1.0F, gz + 0.5F,
                                     sample_entry_at(gx + 1.0F, gz + 0.5F));
              unsigned int const v12 =
                  add_vertex_at_grid(section, gx + 0.5F, gz + 1.0F,
                                     sample_entry_at(gx + 0.5F, gz + 1.0F));
              unsigned int const v11 =
                  add_vertex_at_grid(section, gx + 0.5F, gz + 0.5F,
                                     sample_entry_at(gx + 0.5F, gz + 0.5F));

              section.indices.push_back(v00);
              section.indices.push_back(v10);
              section.indices.push_back(v01);
              section.indices.push_back(v10);
              section.indices.push_back(v11);
              section.indices.push_back(v01);

              section.indices.push_back(v10);
              section.indices.push_back(v20);
              section.indices.push_back(v11);
              section.indices.push_back(v20);
              section.indices.push_back(v21);
              section.indices.push_back(v11);

              section.indices.push_back(v01);
              section.indices.push_back(v11);
              section.indices.push_back(v02);
              section.indices.push_back(v11);
              section.indices.push_back(v12);
              section.indices.push_back(v02);

              section.indices.push_back(v11);
              section.indices.push_back(v21);
              section.indices.push_back(v12);
              section.indices.push_back(v21);
              section.indices.push_back(v22);
              section.indices.push_back(v12);
            } else {
              section.indices.push_back(v0);
              section.indices.push_back(v1);
              section.indices.push_back(v2);
              section.indices.push_back(v2);
              section.indices.push_back(v1);
              section.indices.push_back(v3);
            }

            float const quad_height = (height_data[idx0] + height_data[idx1] +
                                       height_data[idx2] + height_data[idx3]) *
                                      0.25F;
            section.heightSum += quad_height;
            section.heightCount += 1;

            float const n_y = (normals[idx0].y() + normals[idx1].y() +
                               normals[idx2].y() + normals[idx3].y()) *
                              0.25F;
            float const slope = 1.0F - std::clamp(n_y, 0.0F, 1.0F);
            section.slopeSum += slope;

            float const hmin =
                std::min(std::min(height_data[idx0], height_data[idx1]),
                         std::min(height_data[idx2], height_data[idx3]));
            float const hmax =
                std::max(std::max(height_data[idx0], height_data[idx1]),
                         std::max(height_data[idx2], height_data[idx3]));
            section.heightVarSum += (hmax - hmin);
            section.statCount += 1;

            auto h = [&](int gx, int gz) {
              gx = std::clamp(gx, 0, m_width - 1);
              gz = std::clamp(gz, 0, m_height - 1);
              return height_data[gz * m_width + gx];
            };
            int const cx = x;
            int const cz = z;
            float const h_c = quad_height;
            float ao = 0.0F;
            ao += std::max(0.0F, h(cx - 1, cz) - h_c);
            ao += std::max(0.0F, h(cx + 1, cz) - h_c);
            ao += std::max(0.0F, h(cx, cz - 1) - h_c);
            ao += std::max(0.0F, h(cx, cz + 1) - h_c);
            ao = std::clamp(ao * 0.15F, 0.0F, 1.0F);
            section.aoSum += ao;
            section.aoCount += 1;
          }
        }
      }

      for (int i = 0; i < 3; ++i) {
        SectionData const &section = sections[i];
        if (section.indices.empty()) {
          continue;
        }

        auto mesh = std::make_unique<Mesh>(section.vertices, section.indices);
        if (!mesh) {
          continue;
        }

        ChunkMesh chunk;
        chunk.mesh = std::move(mesh);
        chunk.min_x = chunk_x;
        chunk.max_x = chunk_max_x - 1;
        chunk.min_z = chunk_z;
        chunk.max_z = chunk_max_z - 1;
        chunk.type = (i == 0)   ? Game::Map::TerrainType::Flat
                     : (i == 1) ? Game::Map::TerrainType::Hill
                                : Game::Map::TerrainType::Mountain;
        chunk.average_height =
            (section.heightCount > 0)
                ? section.heightSum / float(section.heightCount)
                : 0.0F;

        const float nh_chunk = (chunk.average_height - min_h) / height_range;
        const float avg_slope =
            (section.statCount > 0)
                ? (section.slopeSum / float(section.statCount))
                : 0.0F;
        const float roughness =
            (section.statCount > 0)
                ? (section.heightVarSum / float(section.statCount))
                : 0.0F;

        const float center_gx = 0.5F * (chunk.min_x + chunk.max_x);
        const float center_gz = 0.5F * (chunk.min_z + chunk.max_z);
        auto hgrid = [&](int gx, int gz) {
          gx = std::clamp(gx, 0, m_width - 1);
          gz = std::clamp(gz, 0, m_height - 1);
          return height_data[gz * m_width + gx];
        };
        const int cxi = int(center_gx);
        const int czi = int(center_gz);
        const float h_c = hgrid(cxi, czi);
        const float h_l = hgrid(cxi - 1, czi);
        const float h_r = hgrid(cxi + 1, czi);
        const float h_d = hgrid(cxi, czi - 1);
        const float h_u = hgrid(cxi, czi + 1);
        const float convexity = h_c - 0.25F * (h_l + h_r + h_d + h_u);

        const float edge_factor = smooth(0.25F, 0.55F, avg_slope);
        const float entrance_factor =
            (1.0F - edge_factor) * smooth(0.00F, 0.15F, -convexity);
        const float plateau_flat = 1.0F - smooth(0.10F, 0.25F, avg_slope);
        const float plateau_height = smooth(0.60F, 0.80F, nh_chunk);
        const float plateau_factor = plateau_flat * plateau_height;

        QVector3D const base_color =
            get_terrain_color(chunk.type, chunk.average_height);
        QVector3D const rock_tint = m_biome_settings.rock_low;

        float slope_mix = std::clamp(
            avg_slope * ((chunk.type == Game::Map::TerrainType::Flat) ? 0.30F
                         : (chunk.type == Game::Map::TerrainType::Hill)
                             ? 0.55F
                             : 0.90F),
            0.0F, 1.0F);

        slope_mix += 0.15F * edge_factor;
        slope_mix -= 0.10F * entrance_factor;
        slope_mix -= 0.08F * plateau_factor;
        slope_mix = std::clamp(slope_mix, 0.0F, 1.0F);

        float const center_wx = (center_gx - half_width) * m_tile_size;
        float const center_wz = (center_gz - half_height) * m_tile_size;
        float const macro = value_noise(center_wx * 0.02F, center_wz * 0.02F,
                                        m_noise_seed ^ 0x51C3U);
        float const macro_shade = 0.9F + 0.2F * macro;

        float const ao_avg = (section.aoCount > 0)
                                 ? (section.aoSum / float(section.aoCount))
                                 : 0.0F;
        float const ao_shade = 1.0F - 0.35F * ao_avg;

        QVector3D avg_n = section.normalSum;
        if (avg_n.lengthSquared() > 0.0F) {
          avg_n.normalize();
        }
        QVector3D const north(0, 0, 1);
        float const northness = std::clamp(
            QVector3D::dotProduct(avg_n, north) * 0.5F + 0.5F, 0.0F, 1.0F);
        QVector3D const cool_tint(0.96F, 1.02F, 1.04F);
        QVector3D const warm_tint(1.03F, 1.0F, 0.97F);
        QVector3D const aspect_tint =
            cool_tint * northness + warm_tint * (1.0F - northness);

        float const feature_bright =
            1.0F + 0.08F * plateau_factor - 0.05F * entrance_factor;
        QVector3D const feature_tint =
            QVector3D(1.0F + 0.03F * plateau_factor - 0.03F * entrance_factor,
                      1.0F + 0.01F * plateau_factor - 0.01F * entrance_factor,
                      1.0F - 0.02F * plateau_factor + 0.03F * entrance_factor);

        chunk.tint = section.tint;

        QVector3D color =
            base_color * (1.0F - slope_mix) + rock_tint * slope_mix;
        color = applyTint(color, chunk.tint);
        color *= macro_shade;
        color.setX(color.x() * aspect_tint.x() * feature_tint.x());
        color.setY(color.y() * aspect_tint.y() * feature_tint.y());
        color.setZ(color.z() * aspect_tint.z() * feature_tint.z());
        color *= ao_shade * feature_bright;

        color = color * 0.96F + QVector3D(0.04F, 0.04F, 0.04F);
        chunk.color = clamp01(color);

        TerrainChunkParams params;
        auto tint_color = [&](const QVector3D &base) {
          return clamp01(applyTint(base, chunk.tint));
        };
        params.grass_primary = tint_color(m_biome_settings.grass_primary);
        params.grass_secondary = tint_color(m_biome_settings.grass_secondary);
        params.grass_dry = tint_color(m_biome_settings.grass_dry);
        params.soil_color = tint_color(m_biome_settings.soil_color);
        params.rock_low = tint_color(m_biome_settings.rock_low);
        params.rock_high = tint_color(m_biome_settings.rock_high);

        params.tile_size = std::max(0.001F, m_tile_size);
        params.macro_noise_scale = m_biome_settings.terrain_macro_noise_scale;
        params.detail_noise_scale = m_biome_settings.terrain_detail_noise_scale;

        float slope_threshold = m_biome_settings.terrain_rock_threshold;
        float sharpness_mul = 1.0F;
        if (chunk.type == Game::Map::TerrainType::Hill) {
          slope_threshold -= 0.06F;
          sharpness_mul = 1.15F;
        } else if (chunk.type == Game::Map::TerrainType::Mountain) {
          slope_threshold -= 0.16F;
          sharpness_mul = 1.60F;
        }
        slope_threshold -= 0.05F * edge_factor;
        slope_threshold += 0.04F * entrance_factor;
        slope_threshold = std::clamp(
            slope_threshold - std::clamp(avg_slope * 0.20F, 0.0F, 0.12F), 0.05F,
            0.9F);

        params.slope_rock_threshold = slope_threshold;
        params.slope_rock_sharpness = std::max(
            1.0F, m_biome_settings.terrain_rock_sharpness * sharpness_mul);

        float soil_height = m_biome_settings.terrain_soil_height;
        if (chunk.type == Game::Map::TerrainType::Hill) {
          soil_height -= 0.04F;
        } else if (chunk.type == Game::Map::TerrainType::Mountain) {
          soil_height -= 0.12F;
        }
        soil_height += 0.05F * entrance_factor - 0.03F * plateau_factor;
        params.soil_blend_height = soil_height;

        params.soil_blend_sharpness =
            std::max(0.75F, m_biome_settings.terrain_soil_sharpness *
                                (chunk.type == Game::Map::TerrainType::Mountain
                                     ? 0.80F
                                     : 0.95F));

        const uint32_t noise_key_a =
            hash_coords(chunk.min_x, chunk.min_z, m_noise_seed ^ 0xB5297A4DU);
        const uint32_t noise_key_b =
            hash_coords(chunk.min_x, chunk.min_z, m_noise_seed ^ 0x68E31DA4U);
        constexpr float k_noise_offset_scale = 256.0F;
        params.noise_offset =
            QVector2D(hash_to_01(noise_key_a) * k_noise_offset_scale,
                      hash_to_01(noise_key_b) * k_noise_offset_scale);

        float base_amp =
            m_biome_settings.height_noise_amplitude *
            (0.7F + 0.3F * std::clamp(roughness * 0.6F, 0.0F, 1.0F));
        if (chunk.type == Game::Map::TerrainType::Hill) {
          base_amp *= 1.12F;
        } else if (chunk.type == Game::Map::TerrainType::Mountain) {
          base_amp *= 1.25F;
        }
        base_amp *= (1.0F + 0.10F * edge_factor - 0.08F * plateau_factor -
                     0.06F * entrance_factor);
        params.height_noise_strength = base_amp;
        params.height_noise_frequency = m_biome_settings.height_noise_frequency;

        params.ambient_boost =
            m_biome_settings.terrain_ambient_boost *
            ((chunk.type == Game::Map::TerrainType::Hill)       ? 0.97F
             : (chunk.type == Game::Map::TerrainType::Mountain) ? 0.90F
                                                                : 0.95F);
        params.rock_detail_strength =
            m_biome_settings.terrain_rock_detail_strength *
            (0.75F + 0.35F * std::clamp(avg_slope * 1.2F, 0.0F, 1.0F) +
             0.15F * edge_factor - 0.10F * plateau_factor -
             0.08F * entrance_factor);

        params.tint = clamp01(QVector3D(chunk.tint, chunk.tint, chunk.tint));
        params.light_direction = QVector3D(0.35F, 0.8F, 0.45F);

        chunk.params = params;

        total_triangles += chunk.mesh->get_indices().size() / 3;
        m_chunks.push_back(std::move(chunk));
      }
    }
  }

  m_chunk_visibility_cache.assign(m_chunks.size(), {});
}

auto TerrainRenderer::get_terrain_color(Game::Map::TerrainType type,
                                        float height) const -> QVector3D {
  switch (type) {
  case Game::Map::TerrainType::Mountain:
    if (height > 4.0F) {
      return m_biome_settings.rock_high;
    }
    return m_biome_settings.rock_low;
  case Game::Map::TerrainType::Hill: {
    float const t = std::clamp(height / 3.0F, 0.0F, 1.0F);
    float const t_smooth = t * t * (3.0F - 2.0F * t);

    QVector3D const grass_low = m_biome_settings.grass_primary * 0.3F +
                                m_biome_settings.grass_secondary * 0.7F;
    QVector3D const grass_high = m_biome_settings.grass_secondary * 0.6F +
                                 m_biome_settings.grass_dry * 0.4F;
    QVector3D const grass =
        grass_low * (1.0F - t_smooth) + grass_high * t_smooth;

    QVector3D const rock = m_biome_settings.rock_low * (1.0F - t_smooth) +
                           m_biome_settings.rock_high * t_smooth;

    float const rock_blend_base = 0.15F + 0.45F * t_smooth;
    float const height_factor = std::clamp((height - 0.5F) * 0.3F, 0.0F, 0.25F);
    float const rock_blend =
        std::clamp(rock_blend_base + height_factor, 0.0F, 0.70F);

    return grass * (1.0F - rock_blend) + rock * rock_blend;
  }
  case Game::Map::TerrainType::Forest: {

    float const moisture = std::clamp((height - 0.5F) * 0.2F, 0.0F, 0.4F);
    QVector3D const base = m_biome_settings.grass_primary * (1.0F - moisture) +
                           m_biome_settings.grass_secondary * moisture;
    float const dry_blend = std::clamp((height - 2.0F) * 0.12F, 0.0F, 0.3F);
    QVector3D const with_dry =
        base * (1.0F - dry_blend) + m_biome_settings.grass_dry * dry_blend;

    return QVector3D(with_dry.x() * 0.7F, with_dry.y() * 0.9F,
                     with_dry.z() * 0.6F);
  }
  case Game::Map::TerrainType::Flat:
  default: {
    float const moisture = std::clamp((height - 0.5F) * 0.2F, 0.0F, 0.4F);
    QVector3D const base = m_biome_settings.grass_primary * (1.0F - moisture) +
                           m_biome_settings.grass_secondary * moisture;
    float const dry_blend = std::clamp((height - 2.0F) * 0.12F, 0.0F, 0.3F);
    return base * (1.0F - dry_blend) + m_biome_settings.grass_dry * dry_blend;
  }
  }
}

} // namespace Render::GL