diff --git a/src/assets/Heightmap.hpp b/src/assets/Heightmap.hpp index b5cbed6..e777415 100644 --- a/src/assets/Heightmap.hpp +++ b/src/assets/Heightmap.hpp @@ -161,6 +161,12 @@ public: // [0, resolution-1] : appeler avec ix = -1 renvoie la colonne 0. float at(int64_t ix, int64_t iz) const; + // PHASE 30. La grille brute, [iz * resolution + ix], en lecture seule. Pour + // les boucles chaudes qui ont DEJA etabli que leurs indices sont dans la + // grille et n'ont donc que faire de l'ecretage de at() - la construction + // des tuiles interieures du quadtree (renderer/TerrainNodeMesh.cpp). + const float* rawHeights() const { return heights_.data(); } + // Position monde d'un echantillon (le long de X pour ix, de Z pour iz). float worldCoord(uint32_t index) const; diff --git a/src/renderer/TerrainNodeMesh.cpp b/src/renderer/TerrainNodeMesh.cpp index dc8475e..686eafc 100644 --- a/src/renderer/TerrainNodeMesh.cpp +++ b/src/renderer/TerrainNodeMesh.cpp @@ -227,9 +227,121 @@ MeshData terrainNodeMeshData(const Heightmap& heightmap, const TerrainQuadtree& return mesh; } +bool terrainNodeUsesFastPath(const Heightmap& heightmap, const TerrainQuadtree& quadtree, + uint32_t nodeIndex) { + if (nodeIndex >= quadtree.nodeCount()) { + return false; + } + const TerrainQuadtree::Node& node = quadtree.node(nodeIndex); + const uint64_t cells = heightmap.resolution() - 1; + const uint64_t stride = node.stride; + // Deux pas de marge de chaque cote : les voisins d'un sommet sont a un pas, + // ceux d'un echantillon du parent a deux pas (le pas du parent). + const uint64_t reach = static_cast(quadtree.nodeCells() + 2) * stride; + return node.ix0 >= 2 * stride && node.iz0 >= 2 * stride && + node.ix0 + reach <= cells && node.iz0 + reach <= cells; +} + void writeTerrainNodeVertices(const Heightmap& heightmap, const TerrainQuadtree& quadtree, uint32_t nodeIndex, TerrainVertex* out, bool reuseParentGrid) { + // --- PHASE 30 : chemin RAPIDE des tuiles interieures -------------------- + // Le parcours de reference lit chaque altitude ~6 fois, toujours par at() + // et son ecretage : cinq lectures par echantillon (le point et ses quatre + // voisins) pour les 4 225 sommets ET les 1 089 echantillons du parent. Or + // les voisins d'un sommet, au pas du noeud, sont exactement les sommets + // voisins de la tuile, et ceux du parent, au pas double, les sommets a + // deux rangs. Loin du bord, ou aucun indice n'est ecrete, une grille de + // (n + 5)^2 altitudes lues UNE fois contient donc tout. + // + // Les MEMES operations flottantes sur les MEMES valeurs que sampleGrid - + // memes differences, memes divisions (le pas reel, 2 ou 4 fois le pas du + // noeud, comme (xp - xm) la-bas), meme glm::normalize : le resultat est + // identique au bit pres, et tests/logic_tests.cpp le verifie sur toutes les + // tuiles de plusieurs grilles. Pres du bord, ou l'ecretage change les + // voisins, le chemin de reference ci-dessous reste seul juge. Le temoin + // --no-tile-cache (reuseParentGrid = false) le garde aussi : il mesure le + // travail d'avant la Phase 18. + if (reuseParentGrid && terrainNodeUsesFastPath(heightmap, quadtree, nodeIndex)) { + const TerrainQuadtree::Node& node = quadtree.node(nodeIndex); + const uint32_t verts = quadtree.nodeCells() + 1; + const uint32_t stride = node.stride; + const uint32_t res = heightmap.resolution(); + const float spacing = heightmap.spacing(); + const float* heights = heightmap.rawHeights(); + + // Grille bordee de deux rangs : l'indice local k correspond a + // l'echantillon ix0 + (k - 2) * stride. thread_local : le chemin + // parallele (Phase 19) l'appelle depuis plusieurs threads a la fois. + const uint32_t span = verts + 4; + thread_local std::vector grid; + grid.resize(static_cast(span) * span); + for (uint32_t jj = 0; jj < span; ++jj) { + const float* row = heights + static_cast(node.iz0 - 2u * stride + + jj * stride) * res; + const float* sample = row + (node.ix0 - 2u * stride); + float* destination = grid.data() + static_cast(jj) * span; + for (uint32_t ii = 0; ii < span; ++ii) { + destination[ii] = sample[static_cast(ii) * stride]; + } + } + const auto at = [&](uint32_t ii, uint32_t jj) { + return grid[static_cast(jj) * span + ii]; + }; + // Les pas reels des differences centrees : (xp - xm) * spacing dans + // sampleGrid, soit 2 pas du noeud pour un sommet, 4 pour le parent. + const float step = static_cast(2u * stride) * spacing; + const float parentStep = static_cast(4u * stride) * spacing; + + // Grille du parent, deja quantifiee : une fois par bloc 2 x 2. + struct ParentSample { + float height; + int16_t normal[2]; + }; + const uint32_t parentVerts = (verts + 1u) / 2u; + thread_local std::vector parents; + parents.resize(static_cast(parentVerts) * parentVerts); + bool finite = true; + for (uint32_t pj = 0; pj < parentVerts; ++pj) { + for (uint32_t pi = 0; pi < parentVerts; ++pi) { + const uint32_t ii = 2u * pi + 2u; + const uint32_t jj = 2u * pj + 2u; + const float dhdx = (at(ii + 2u, jj) - at(ii - 2u, jj)) / parentStep; + const float dhdz = (at(ii, jj + 2u) - at(ii, jj - 2u)) / parentStep; + const glm::vec3 normal = glm::normalize(glm::vec3(-dhdx, 1.0f, -dhdz)); + ParentSample& parent = parents[static_cast(pj) * parentVerts + pi]; + parent.height = at(ii, jj); + parent.normal[0] = packSnorm16(normal.x); + parent.normal[1] = packSnorm16(normal.z); + finite = finite && std::isfinite(parent.height) && std::isfinite(normal.y); + } + } + for (uint32_t j = 0; j < verts; ++j) { + for (uint32_t i = 0; i < verts; ++i) { + const uint32_t ii = i + 2u; + const uint32_t jj = j + 2u; + const float dhdx = (at(ii + 1u, jj) - at(ii - 1u, jj)) / step; + const float dhdz = (at(ii, jj + 1u) - at(ii, jj - 1u)) / step; + const glm::vec3 normal = glm::normalize(glm::vec3(-dhdx, 1.0f, -dhdz)); + const ParentSample& parent = + parents[static_cast(j / 2u) * parentVerts + (i / 2u)]; + + TerrainVertex& packed = out[static_cast(j) * verts + i]; + packed.height = at(ii, jj); + packed.morphHeight = parent.height; + packed.normal[0] = packSnorm16(normal.x); + packed.normal[1] = packSnorm16(normal.z); + packed.morphNormal[0] = parent.normal[0]; + packed.morphNormal[1] = parent.normal[1]; + finite = finite && std::isfinite(packed.height) && std::isfinite(normal.y); + } + } + if (!finite) { + throwNonFinite(); + } + return; + } + bool finite = true; forEachNodeVertex(heightmap, quadtree, nodeIndex, reuseParentGrid, [&](std::size_t v, uint32_t /*gx*/, uint32_t /*gz*/, diff --git a/src/renderer/TerrainNodeMesh.hpp b/src/renderer/TerrainNodeMesh.hpp index fa44c8f..a7e5dde 100644 --- a/src/renderer/TerrainNodeMesh.hpp +++ b/src/renderer/TerrainNodeMesh.hpp @@ -83,4 +83,12 @@ void writeTerrainNodeVertices(const Heightmap& heightmap, const TerrainQuadtree& uint32_t nodeIndex, TerrainVertex* out, bool reuseParentGrid = true); +// PHASE 30. true si writeTerrainNodeVertices prend le chemin RAPIDE pour ce +// noeud : une tuile assez loin du bord du terrain pour qu'aucun des +// echantillons qu'elle lit (ses sommets, leurs voisins au pas du noeud, et +// ceux de la grille du parent au pas double) ne soit ecrete. Expose pour que +// les tests verifient qu'ils couvrent bien les deux chemins. +bool terrainNodeUsesFastPath(const Heightmap& heightmap, const TerrainQuadtree& quadtree, + uint32_t nodeIndex); + } // namespace vercora diff --git a/tests/logic_tests.cpp b/tests/logic_tests.cpp index 55dfd49..3b295d5 100644 --- a/tests/logic_tests.cpp +++ b/tests/logic_tests.cpp @@ -10235,6 +10235,13 @@ void testGpuFormatsPhase30() { odd.resolution = 128; odd.worldSize = 127.0f; odd.seed = 3031u; + // Assez grande pour que des tuiles de niveau 2 et 3 soient INTERIEURES + // (chemin rapide de writeTerrainNodeVertices a plusieurs pas). + Heightmap::Params large; + large.resolution = 2049; + large.worldSize = 4096.0f; + large.amplitude = 900.0f; + large.seed = 3033u; TerrainQuadtree::Params qparams; qparams.nodeCells = 64; @@ -10242,7 +10249,9 @@ void testGpuFormatsPhase30() { bool positionsExact = true; bool uvExact = true; uint32_t nodesChecked = 0; - for (const Heightmap::Params& hp : { even, odd }) { + uint32_t fastNodes = 0; + uint32_t fastStrides = 0; // masque des pas couverts par le chemin rapide + for (const Heightmap::Params& hp : { even, odd, large }) { const Heightmap heightmap(hp); const TerrainQuadtree quadtree(heightmap, qparams); const uint32_t verts = qparams.nodeCells + 1; @@ -10250,6 +10259,10 @@ void testGpuFormatsPhase30() { const float origin = heightmap.worldCoord(0); std::vector written(static_cast(verts) * verts); for (uint32_t index = 0; index < quadtree.nodeCount(); ++index) { + if (terrainNodeUsesFastPath(heightmap, quadtree, index)) { + ++fastNodes; + fastStrides |= quadtree.node(index).stride; + } for (const bool cached : { true, false }) { const MeshData reference = terrainNodeMeshData(heightmap, quadtree, index, false, cached); @@ -10283,7 +10296,9 @@ void testGpuFormatsPhase30() { ++nodesChecked; } } - check(nodesChecked > 80, "Tuiles : toutes les tuiles des deux grilles verifiees"); + check(nodesChecked > 400, "Tuiles : toutes les tuiles des trois grilles verifiees"); + check(fastNodes > 0 && fastNodes < nodesChecked && (fastStrides & 0xFu) == 0xFu, + "Tuiles : chemin rapide ET chemin de reference exerces (pas 1, 2, 4 et 8)"); check(identical, "Tuiles : writeTerrainNodeVertices == toTerrainVertex(reference), au bit pres"); check(positionsExact,