#include "assets/Heightmap.hpp" #include "core/Logger.hpp" #include #include #include #include namespace vercora { namespace { // --- Bruit de valeur (value noise) -------------------------------------- // Choix : bruit de VALEUR plutot que Perlin/Simplex. Il ne demande aucune // table de permutation ni gradients pre-calcules (donc zero etat, zero // allocation, et un resultat identique sur toutes les plateformes), et une // fois empile en fBm il est visuellement indiscernable de Perlin a cette // echelle. Le cout par echantillon est plus eleve que Perlin, mais on genere // 16384 points UNE fois au demarrage : c'est sans importance. // Hash entier -> [0,1). Melange multiplicatif + decalages facon "integer // finalizer" (meme famille que murmur3) : deux entrees voisines donnent des // sorties decorrelees, ce qui est tout ce qu'on demande a un bruit de valeur. float hash01(int64_t x, int64_t z, uint32_t seed) { uint32_t h = seed; h ^= static_cast(static_cast(x)) * 0x9E3779B1u; h ^= static_cast(static_cast(z)) * 0x85EBCA77u; h ^= h >> 15; h *= 0x2C1B3C6Du; h ^= h >> 12; h *= 0x297A2D39u; h ^= h >> 15; // 24 bits suffisent largement et tiennent exactement dans la mantisse d'un // float (pas d'arrondi, donc resultat parfaitement reproductible). return static_cast(h & 0x00FFFFFFu) / static_cast(0x01000000u); } // Courbe de Hermite : derivee nulle aux extremites, donc pas de cassure de // pente visible aux frontieres des cellules du bruit (une interpolation // lineaire donnerait un relief en facettes losangees, tres reconnaissable). float smoothCurve(float t) { return t * t * (3.0f - 2.0f * t); } float lerp(float a, float b, float t) { return a + (b - a) * t; } float valueNoise(float x, float z, uint32_t seed) { const float fx = std::floor(x); const float fz = std::floor(z); const int64_t ix = static_cast(fx); const int64_t iz = static_cast(fz); const float tx = smoothCurve(x - fx); const float tz = smoothCurve(z - fz); const float n00 = hash01(ix, iz, seed); const float n10 = hash01(ix + 1, iz, seed); const float n01 = hash01(ix, iz + 1, seed); const float n11 = hash01(ix + 1, iz + 1, seed); return lerp(lerp(n00, n10, tx), lerp(n01, n11, tx), tz); } // fBm : somme d'octaves de frequence doublee et d'amplitude halvee. // Renvoie une valeur dans [0,1] (division par la somme des amplitudes). // // 'ridged' transforme chaque octave en 1 - |2n - 1| : la valeur culmine la ou // le bruit passait par sa moyenne, ce qui remplace les dômes arrondis par des // LIGNES de crete continues, avec une derivee discontinue au sommet (arete // vive). C'est la recette classique pour un relief de montagne, et c'est ce qui // cree les versants raides dont le fragment shader a besoin pour montrer sa // coloration par pente. float fbm(float x, float z, const Heightmap::Params& params, bool ridged) { float sum = 0.0f; float normalization = 0.0f; float amplitude = 1.0f; float frequency = params.baseFrequency; for (uint32_t octave = 0; octave < params.octaves; ++octave) { // Graine decalee par octave : sans ca, toutes les octaves seraient la // meme image a des echelles differentes et leurs maxima s'aligneraient. // Le decalage differe aussi entre les deux variantes, pour que les // cretes ne tombent pas systematiquement sur les sommets du fBm doux. const uint32_t octaveSeed = params.seed + octave * 7919u + (ridged ? 104729u : 0u); float n = valueNoise(x * frequency, z * frequency, octaveSeed); if (ridged) { n = 1.0f - std::fabs(2.0f * n - 1.0f); } sum += amplitude * n; normalization += amplitude; amplitude *= 0.5f; frequency *= 2.0f; } return normalization > 0.0f ? sum / normalization : 0.0f; } } // namespace Heightmap::Heightmap(const Params& params) : params_(params) { if (params_.resolution < 2) { throw std::runtime_error( "Heightmap : resolution de " + std::to_string(params_.resolution) + " echantillons, il en faut au moins 2 pour former une surface."); } if (!(params_.worldSize > 0.0f) || !(params_.amplitude >= 0.0f)) { throw std::runtime_error( "Heightmap : worldSize doit etre > 0 et amplitude >= 0."); } if (params_.octaves == 0) { throw std::runtime_error("Heightmap : il faut au moins une octave de bruit."); } const uint32_t res = params_.resolution; // resolution-1 cellules couvrent worldSize -> pas de la grille. spacing_ = params_.worldSize / static_cast(res - 1); halfSize_ = params_.worldSize * 0.5f; heights_.resize(static_cast(res) * res); for (uint32_t iz = 0; iz < res; ++iz) { // Coordonnees normalisees [0,1] : la frequence du bruit est ainsi // exprimee en "motifs sur toute la largeur", independamment de la // resolution. Changer resolution affine donc le maillage SANS changer // la forme du relief - pratique pour comparer deux resolutions. const float v = static_cast(iz) / static_cast(res - 1); for (uint32_t ix = 0; ix < res; ++ix) { const float u = static_cast(ix) / static_cast(res - 1); // Deux reliefs superposes puis melanges : le fBm doux donne les // grandes ondulations et les fonds de vallee, le ridged donne les // aretes. std::pow sur une base garantie >= 0 : pas de NaN possible. const float smooth = std::pow(fbm(u, v, params_, /*ridged=*/false), params_.reliefExponent); const float ridge = fbm(u, v, params_, /*ridged=*/true); // Elevation au carre : accentue les cretes et aplatit le bas des // versants, ce qui evite le relief "en toile de tente" uniforme. const float shaped = lerp(smooth, ridge * ridge, std::clamp(params_.ridgeWeight, 0.0f, 1.0f)); heights_[static_cast(iz) * res + ix] = shaped * params_.amplitude; } } label_ = "terrain synthetique " + std::to_string(res) + "x" + std::to_string(res); finalize(); logInfo("Heightmap synthetique generee : " + std::to_string(res) + "x" + std::to_string(res) + " echantillons sur " + std::to_string(params_.worldSize) + " unites (pas de " + std::to_string(spacing_) + "), altitudes " + std::to_string(minHeight_) + " a " + std::to_string(maxHeight_) + "."); } Heightmap::Heightmap(std::vector heights, uint32_t resolution, float spacing, std::string label, const GeoReference& geo) : heights_(std::move(heights)), label_(std::move(label)), geo_(geo) { if (resolution < 2) { throw std::runtime_error( "Heightmap : grille de " + std::to_string(resolution) + " echantillons par cote, il en faut au moins 2 pour former une surface."); } if (!std::isfinite(spacing) || spacing <= 0.0f) { throw std::runtime_error( "Heightmap : pas de grille invalide (" + std::to_string(spacing) + ")."); } const std::size_t expected = static_cast(resolution) * static_cast(resolution); if (heights_.size() != expected) { throw std::runtime_error( "Heightmap : " + std::to_string(heights_.size()) + " altitudes fournies " "pour une grille " + std::to_string(resolution) + "x" + std::to_string(resolution) + " qui en attend " + std::to_string(expected) + "."); } params_.resolution = resolution; // La taille monde DECOULE du pas et du nombre d'echantillons : pour une // grille mesuree c'est le pas qui est la donnee (1 m sur la dalle LiDAR), // pas l'emprise. L'ordre est donc inverse de celui du generateur procedural, // ou l'on impose l'emprise et ou le pas s'en deduit. params_.worldSize = spacing * static_cast(resolution - 1); spacing_ = spacing; halfSize_ = params_.worldSize * 0.5f; finalize(); } void Heightmap::finalize() { minHeight_ = std::numeric_limits::max(); maxHeight_ = std::numeric_limits::lowest(); for (std::size_t i = 0; i < heights_.size(); ++i) { const float height = heights_[i]; // Un seul NaN suffit a produire un triangle degenere et un terrain qui // clignote, sans le moindre message d'erreur. On refuse ici plutot que // de le decouvrir a l'ecran : c'est le risque numero un avec des donnees // mesurees, ou une cellule sans aucun point de retour est frequente. if (!std::isfinite(height)) { const uint32_t res = params_.resolution; throw std::runtime_error( "Heightmap : altitude non finie (NaN ou infini) a l'echantillon (" + std::to_string(i % res) + ", " + std::to_string(i / res) + ")."); } minHeight_ = std::min(minHeight_, height); maxHeight_ = std::max(maxHeight_, height); } } float Heightmap::at(int64_t ix, int64_t iz) const { const int64_t last = static_cast(params_.resolution) - 1; const int64_t cx = std::clamp(ix, static_cast(0), last); const int64_t cz = std::clamp(iz, static_cast(0), last); return heights_[static_cast(cz) * params_.resolution + static_cast(cx)]; } float Heightmap::worldCoord(uint32_t index) const { return -halfSize_ + static_cast(index) * spacing_; } std::string Heightmap::describe() const { return label_; } void Heightmap::toProjected(float worldX, float worldZ, double* east, double* north) const { // Inverse de worldCoord() : worldX = -halfSize + ix * spacing, donc la // distance a l'echantillon 0 vaut worldX + halfSize. // // Le signe differe entre les deux axes et ce n'est pas une faute de frappe : // ix croissant va vers l'EST (meme sens que la coordonnee projetee), tandis // que iz croissant va vers le SUD, c'est-a-dire dans le sens DECROISSANT du // nord. Voir l'orientation documentee dans Heightmap.hpp. if (east) { *east = geo_.originEast + static_cast(worldX + halfSize_); } if (north) { *north = geo_.originNorth - static_cast(worldZ + halfSize_); } } void Heightmap::fromProjected(double east, double north, float* worldX, float* worldZ) const { // Inversion terme a terme de toProjected ci-dessus. La soustraction se fait // en DOUBLE avant la conversion en float, et c'est le point qui compte : un // Lambert 93 vaut ~6,4 millions en nord, ou l'ecart entre deux float // consecutifs atteint deja 0,5 m. Convertir d'abord puis soustraire // perdrait un demi-metre sur chaque objet pose. if (worldX) { *worldX = static_cast(east - geo_.originEast) - halfSize_; } if (worldZ) { *worldZ = static_cast(geo_.originNorth - north) - halfSize_; } } float Heightmap::heightAt(float worldX, float worldZ) const { const float last = static_cast(params_.resolution - 1); // Passage en coordonnees de grille (unite = un echantillon), ecretees sur // le domaine : au-dela du bord, on prolonge la hauteur du bord. // std::clamp sur des NaN renverrait NaN ; on s'en protege en amont plutot // que de propager une position de camera invalide. const float gx = std::isfinite(worldX) ? std::clamp((worldX + halfSize_) / spacing_, 0.0f, last) : 0.0f; const float gz = std::isfinite(worldZ) ? std::clamp((worldZ + halfSize_) / spacing_, 0.0f, last) : 0.0f; const float fx = std::floor(gx); const float fz = std::floor(gz); const int64_t ix = static_cast(fx); const int64_t iz = static_cast(fz); // Position dans la cellule, dans [0,1]. const float tx = gx - fx; const float tz = gz - fz; const float h00 = at(ix, iz); const float h10 = at(ix + 1, iz); const float h01 = at(ix, iz + 1); const float h11 = at(ix + 1, iz + 1); // TerrainMesh coupe chaque cellule le long de la diagonale h00-h11. // Interpoler bilineairement ici donnerait une hauteur legerement au-dessus // ou en dessous des triangles reellement affiches ; on reproduit donc le // decoupage exact, ce qui colle la camera pile sur la surface visible. if (tz > tx) { // Triangle (h00, h01, h11) : affine, exact aux trois sommets. return h00 + (h01 - h00) * tz + (h11 - h01) * tx; } // Triangle (h00, h10, h11). return h00 + (h10 - h00) * tx + (h11 - h10) * tz; } } // namespace vercora