Phase 30 (4/n) : construction des tuiles interieures sans relecture
Les voisins d'un sommet, au pas du noeud, sont les sommets voisins de la tuile ; ceux du parent, au pas double, les sommets a deux rangs. Loin du bord (aucun indice ecrete), writeTerrainNodeVertices lit donc les altitudes UNE fois dans une grille bordee de deux rangs au lieu de cinq lectures ecretees par echantillon, puis applique exactement les memes operations flottantes que sampleGrid. Les tuiles de bord et le temoin --no-tile-cache gardent le chemin de reference. Tests : resultat identique au bit pres sur toutes les tuiles de trois grilles, chemin rapide exerce aux pas 1, 2, 4 et 8. Survol (lavapipe, Release) : geometrie d'une tuile ~190 -> ~104 us, streaming terrain 1,3-1,6 -> 0,9 ms par image. Image identique. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2
Cette révision appartient à :
4 fichiers modifiés
+143
-2
Aucun fichier ne correspond à votre recherche
@@ -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;
|
||||
|
||||
|
||||
@@ -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<uint64_t>(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<float> grid;
|
||||
grid.resize(static_cast<std::size_t>(span) * span);
|
||||
for (uint32_t jj = 0; jj < span; ++jj) {
|
||||
const float* row = heights + static_cast<std::size_t>(node.iz0 - 2u * stride +
|
||||
jj * stride) * res;
|
||||
const float* sample = row + (node.ix0 - 2u * stride);
|
||||
float* destination = grid.data() + static_cast<std::size_t>(jj) * span;
|
||||
for (uint32_t ii = 0; ii < span; ++ii) {
|
||||
destination[ii] = sample[static_cast<std::size_t>(ii) * stride];
|
||||
}
|
||||
}
|
||||
const auto at = [&](uint32_t ii, uint32_t jj) {
|
||||
return grid[static_cast<std::size_t>(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<float>(2u * stride) * spacing;
|
||||
const float parentStep = static_cast<float>(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<ParentSample> parents;
|
||||
parents.resize(static_cast<std::size_t>(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<std::size_t>(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<std::size_t>(j / 2u) * parentVerts + (i / 2u)];
|
||||
|
||||
TerrainVertex& packed = out[static_cast<std::size_t>(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*/,
|
||||
|
||||
@@ -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
|
||||
@@ -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<TerrainVertex> written(static_cast<std::size_t>(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,
|
||||
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur