Phases 30-31 (PC, 11-12/10) : rochers visibles, builds separes, densite, demo candidate
Travail local non commite jusqu'ici, sauvegarde avant fusion avec la branche cloud. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
84a72fe30c
révision
9cf7546898
10 fichiers modifiés
+1517
-51
Aucun fichier ne correspond à votre recherche
+39
-2
@@ -19,10 +19,44 @@ endif()
|
||||
find_package(Vulkan 1.2 REQUIRED)
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Dependances externes via FetchContent (telechargees dans external/)
|
||||
# Dependances externes via FetchContent
|
||||
# ---------------------------------------------------------------------------
|
||||
# PHASE 31 : SOURCES partagees, BINAIRES propres a chaque dossier de build.
|
||||
#
|
||||
# Jusqu'a la Phase 30, FETCHCONTENT_BASE_DIR valait external/ : les dossiers
|
||||
# external/*-build (objets et glfw3.lib) etaient donc PARTAGES par tous les
|
||||
# dossiers de build. Un build Release y a reecrit glfw3.lib (/MD) sous le build
|
||||
# Debug (/MDd), sans que Ninja le voie (la sortie etait plus recente).
|
||||
#
|
||||
# Desormais :
|
||||
# - binaires, subbuild et stamps : ${CMAKE_BINARY_DIR}/_deps (un par build) ;
|
||||
# - sources : toujours external/<nom>-src, un cache commun en lecture seule.
|
||||
# tools/run_logic_tests.bat y lit GLM, GLFW et tinyobjloader.
|
||||
#
|
||||
# Mecanisme : si external/<nom>-src est deja peuple, FETCHCONTENT_SOURCE_DIR_<NOM>
|
||||
# y pointe ; FetchContent n'execute alors AUCUNE etape de population (ni
|
||||
# telechargement, ni mise a jour), connecte ou non. S'il est absent (clone neuf),
|
||||
# SOURCE_DIR fait telecharger les sources a cet endroit, une seule fois.
|
||||
# Un FETCHCONTENT_SOURCE_DIR_<NOM> passe en -D par l'utilisateur reste prioritaire.
|
||||
include(FetchContent)
|
||||
set(FETCHCONTENT_BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external)
|
||||
set(FETCHCONTENT_BASE_DIR ${CMAKE_BINARY_DIR}/_deps)
|
||||
set(VERCORA_DEPS_SOURCE_CACHE ${CMAKE_CURRENT_SOURCE_DIR}/external)
|
||||
|
||||
# vercora_use_cached_source(<nom> <fichier temoin>) : macro (et non fonction)
|
||||
# pour que la variable soit posee dans la portee de l'appelant.
|
||||
macro(vercora_use_cached_source dep_name marker)
|
||||
string(TOUPPER "${dep_name}" _vercora_dep_upper)
|
||||
if(NOT DEFINED FETCHCONTENT_SOURCE_DIR_${_vercora_dep_upper}
|
||||
AND EXISTS "${VERCORA_DEPS_SOURCE_CACHE}/${dep_name}-src/${marker}")
|
||||
set(FETCHCONTENT_SOURCE_DIR_${_vercora_dep_upper}
|
||||
"${VERCORA_DEPS_SOURCE_CACHE}/${dep_name}-src")
|
||||
message(STATUS "Vercora : ${dep_name} lu depuis le cache de sources ${VERCORA_DEPS_SOURCE_CACHE}/${dep_name}-src")
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
vercora_use_cached_source(glfw CMakeLists.txt)
|
||||
vercora_use_cached_source(glm CMakeLists.txt)
|
||||
vercora_use_cached_source(tinyobjloader tiny_obj_loader.h)
|
||||
|
||||
# --- GLFW (fenetrage cross-platform) ---
|
||||
FetchContent_Declare(
|
||||
@@ -30,6 +64,7 @@ FetchContent_Declare(
|
||||
GIT_REPOSITORY https://github.com/glfw/glfw.git
|
||||
GIT_TAG 3.4
|
||||
GIT_SHALLOW TRUE
|
||||
SOURCE_DIR ${VERCORA_DEPS_SOURCE_CACHE}/glfw-src
|
||||
)
|
||||
set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
|
||||
set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
|
||||
@@ -43,6 +78,7 @@ FetchContent_Declare(
|
||||
GIT_REPOSITORY https://github.com/g-truc/glm.git
|
||||
GIT_TAG 1.0.1
|
||||
GIT_SHALLOW TRUE
|
||||
SOURCE_DIR ${VERCORA_DEPS_SOURCE_CACHE}/glm-src
|
||||
)
|
||||
FetchContent_MakeAvailable(glm)
|
||||
|
||||
@@ -63,6 +99,7 @@ FetchContent_Declare(
|
||||
GIT_REPOSITORY https://github.com/tinyobjloader/tinyobjloader.git
|
||||
GIT_TAG v2.0.0rc13
|
||||
GIT_SHALLOW TRUE
|
||||
SOURCE_DIR ${VERCORA_DEPS_SOURCE_CACHE}/tinyobjloader-src
|
||||
SOURCE_SUBDIR cmake-volontairement-absent
|
||||
)
|
||||
FetchContent_MakeAvailable(tinyobjloader)
|
||||
|
||||
@@ -2650,3 +2650,39 @@ Tests **3807/3807** (3636 avant), 0 `[Validation]` au demarrage.
|
||||
- Relecture : seuls main.cpp et foliage.vert modifies ; Forest/Vegetation/faune/
|
||||
artisanat/collision/activites identiques octet pour octet ; chemin w >= 0 du shader inchange.
|
||||
- Outil : `build-release\` existe desormais (profil Release hors du `build\` Debug).
|
||||
|
||||
## PHASE 30 (2026-10-11/12) - rochers visibles (detail : NOTES-PHASE30.md)
|
||||
|
||||
- Rochers invisibles en Phase 29 a cause de la TAILLE ANGULAIRE (tache mediane 3 px),
|
||||
pas du contraste (Weber -0,36) ni de la portee. Mesure : sonde sur Rocks.cpp + captures.
|
||||
- Plancher de bruit des captures = 0 px SEULEMENT avec `--no-grass --no-wildlife
|
||||
--no-bushes` des deux cotes : l'herbe ondule meme avec `--time-scale=0`.
|
||||
- Correction (Rocks/RockMesh seulement) : rochers moyens 0,60-1,40 x clamp(rug/0,15 ; 0,8 ; 2,0)
|
||||
plafonnes a 1,29 (sous le seuil de collision 1,3) ; pierraille 10-25 cm a 20 faces ;
|
||||
ombre de contact ; gros blocs inchanges en taille. Placement et comptes identiques au bit.
|
||||
- Pierrier -120,10 : 0,386 % -> 1,313 % de pixels, taches > 100 px 4 -> 27 ; la cible de 2 %
|
||||
n'est PAS atteinte (il manque de la densite pres du joueur). Pied de barre : inchange.
|
||||
- Cout Release pierrier : rochers 0,46 -> 0,75 ms (GPU), 273 img/s. Tests 4000/4000,
|
||||
0 `[Validation]`, A-J vert.
|
||||
- PIEGE : `FETCHCONTENT_BASE_DIR = external` -> dossiers binaires GLFW/GLM partages entre
|
||||
builds ; un build Release ecrase le Debug. Builds valides : `build-agent0\` (Debug),
|
||||
`build-release-p30\` (Release) ; `build\` et `build-release\` sont perimes.
|
||||
|
||||
## PHASE 31 (2026-10-12) - builds separes, densite des rochers, demo candidate (detail : NOTES-PHASE31.md)
|
||||
|
||||
- PERF : chiffres UHD 770 en 1280x720, INDICATIFS. Aucune conclusion ; a remesurer sur la
|
||||
GTX 1660 Super en 1440p.
|
||||
- CMake : `FETCHCONTENT_BASE_DIR = ${CMAKE_BINARY_DIR}/_deps` ; sources dans
|
||||
`external\*-src` via `FETCHCONTENT_SOURCE_DIR_<NOM>`. Debug (`build-agent0\`) et Release
|
||||
(`build-release-p30\`) independants (verifie au bit). `external\*-build` et `-subbuild`
|
||||
sont devenus inutiles.
|
||||
- Rochers : emplacements de PROXIMITE sous le meme masque (moyens +60 par cellule de 32 m,
|
||||
portee 60 m ; pierraille +24 par cellule de 8 m, portee 26 m) ; aucun gros bloc ajoute,
|
||||
collision identique ; plafond par bloc 1 792 / 1 024. Pierrier -120,10 : 1,3 -> 6,9 %
|
||||
de pixels (6,1 % a 5 h 48, soleil rasant). Pied de barre : 0 gain, le masque n'y couvre
|
||||
que 2,2 % du sol a < 10 m. Tests 4029, A-J vert, 0 `[Validation]`.
|
||||
- Lecon : un test d'anisotropie passait avec une densite ajoutee SANS trainees ; deux tests
|
||||
ajoutes (contraste >= 3, rien la ou la trainee est nulle).
|
||||
- Demo : `dist\VercoraDemo-candidate(.zip)` = 110,7 Mio, avec les 4 cartes de couvert et
|
||||
`precip.*.spv` ; teste depuis I: et OK. `dist\VercoraDemo` NON remplace (decision
|
||||
utilisateur). `deploy_beta_to_desktop.ps1` est a revoir.
|
||||
@@ -345,3 +345,73 @@ et non 8,4 % / 1,85 / 4,75 / 46 comme dans la section Agent 2 : `Rocks.cpp` date
|
||||
## Non mesure
|
||||
Scintillement et apparitions en mouvement ; a-coup du premier semis d'un bloc ; cout
|
||||
sous la pluie ; vue de survol. Trainees de rochers a l'oeil (voir 4).
|
||||
|
||||
|
||||
# Reprise du 2026-10-11 - prompt Phase 29 relance alors que la phase etait FAITE
|
||||
|
||||
Le prompt de cette session decrivait l'etat "Agent 1 termine, aucun code ecrit" et
|
||||
attendait 3877 tests. **Faux** : Agents 2, 3 et 4 sont livres depuis le 2026-09-27
|
||||
(sections ci-dessus). Decision (session sans supervision) : NE RIEN reecrire, aucun
|
||||
fichier de `src/`, `shaders/`, `data/`, `assets/` ni `dist/` modifie ; etat verifie,
|
||||
manques comblés par mesure seulement.
|
||||
|
||||
## Agent 0 - etat de depart
|
||||
- Projet DEPLACE : `_CODE\_Vercora` -> `_CODE\4-vercors\vercora` (rangement du 09/10).
|
||||
`build\CMakeCache.txt` pointe encore vers `_CODE/_Vercora` -> `build\` est PERIME
|
||||
(et `tools\screenshot_scene.ps1` / `run_vulkan_check.ps1` lancent `build\vercora.exe`).
|
||||
Des dossiers vides `_CODE\_Vercora\build` et `external\glfw-build\src` ont ete
|
||||
recrees le 11/10 a 12:08 par quelque chose qui suivait l'ancien chemin.
|
||||
- Aucun vercora/find/harnais orphelin au depart. Charge CPU 22 % (CurseForge,
|
||||
Antigravity, navigateur) : machine PAS au repos -> aucune mesure de perf refaite.
|
||||
- Build Debug depuis zero dans un dossier NEUF `build-agent0\` (pour ne pas detruire
|
||||
`build\phase29\`) : 86/86, 0 avertissement compilateur (2 avertissements CMake
|
||||
"deprecated" de glm-src, connus).
|
||||
- Tests headless : **3968/3968** = 3877 + 53 (rochers) + 38 (buissons). L'ecart avec
|
||||
les 3877 du prompt est exactement la Phase 29.
|
||||
|
||||
## Ecarts entre le prompt et l'existant (non corriges, documentes)
|
||||
- Temoin buissons : `--no-bushes` (pas `--no-shrubs`).
|
||||
- Collision : les gros blocs >= 1,3 m sont SOLIDES (via le solveur composite,
|
||||
decision Agent 2 documentee) ; le prompt demandait "non solides par defaut sauf si
|
||||
trivial" - c'est le cas "trivial" qui a ete retenu.
|
||||
- Criteres, rugosite, semis par hachage, trainees, LOD, copie des cartes lowveg
|
||||
(`_canopy_lowveg*`) : conformes.
|
||||
|
||||
## --demo : decision
|
||||
Dans le code, `--demo` ne coupe ni rochers ni buissons (rendu pur, c'est le propos
|
||||
de la demo : regarder le terrain). Decision : **les garder actifs**. MAIS le paquet
|
||||
`dist\VercoraDemo\` date du 27/08 (Phase 21) et ne contient que `vercora_zone_1m.vchm`
|
||||
et l'ortho : **aucune carte de couvert**, donc dans la demo distribuee (et dans
|
||||
`deploy_beta_to_desktop.ps1`, qui copie ces assets) : ZERO rocher, ZERO buisson
|
||||
(et rien de ce qui depend du couvert). Pour les y mettre il faut ajouter au paquet
|
||||
`vercora_zone_canopy.vchm`, `_canopy_height`, `_canopy_lowveg`, `_canopy_lowveg_height`
|
||||
(+ ~16 Mo). NON fait : c'est un changement de ce qui part chez les testeurs.
|
||||
|
||||
## Captures aux points demandes - `build\phase29\captures_20261011\`
|
||||
Exe `build-agent0`, `--hour=13 --day=12 --time-scale=0 --look=yaw,-20 --lock-input`,
|
||||
avant = `--no-rocks --no-bushes`. 0 `[Validation]` sur 15 lancements.
|
||||
|
||||
| site | y0 | y90 | y180 | y270 |
|
||||
|---|---|---|---|---|
|
||||
| pierrier E903578 N6438125 (rug 0,10) | 1,0 % | 0,5 % | 1,1 % | avant manquant (*) |
|
||||
| pied de barre E903602 N6438269 (rug 3,38) | 0,0 % | 0,1 % | 0,4 % | 0,0 % |
|
||||
|
||||
(*) le script de capture est reste bloque 20 min sans ecrire de ligne CAPTURE alors
|
||||
que le jeu repondait et journalisait ; processus tue par PID. Cause non instruite.
|
||||
Images `*_diff.png` : pixels changes en rouge.
|
||||
|
||||
**Constat** : au pierrier, l'ajout visible se reduit a UN petit arbre et 3-4
|
||||
cailloux minuscules gris clair sur calcaire gris clair ; le reste des pixels rouges
|
||||
est l'herbe Phase 28 qui ondule (le vent n'est pas gele par --time-scale=0). Au pied
|
||||
de barre : rien de visible. Les rochers existent (journal : masque 9,4 %, 1,82 blocs
|
||||
/ 4,66 rochers / 23,2 plaques par ha) mais **ne se voient pas aux deux sites que la
|
||||
conception avait choisis** : densite faible + teinte proche du calcaire. Pistes (non
|
||||
faites) : densite, teinte plus sombre/contrastee, ou blocs plus gros en pied de barre.
|
||||
Et ces sites "pierrier" portent de l'herbe dense : pierrier vs pelouse raide, non
|
||||
separables au LiDAR (limite Agent 1), se voit ici.
|
||||
|
||||
## Toujours non fait / non verifie
|
||||
Zone boisee avec lisiere et zone a buissons trouvee par sondage aux points du prompt
|
||||
(les captures du 27/09 `buissons_*` et `belvedere_*` couvrent le sujet ailleurs) ;
|
||||
perf refaite (machine non au repos) ; suite A-J (inchangee depuis le 27/09, binaire
|
||||
identique aux sources) ; scintillement en mouvement.
|
||||
@@ -0,0 +1,114 @@
|
||||
# Phase 30 - Rendre les rochers visibles (2026-10-11 / 12)
|
||||
|
||||
Session sans supervision, sous-agents sequentiels. Detail complet :
|
||||
`build-phase30\agentA\DIAGNOSTIC.md`, `build-phase30\agentB\RAPPORT.md`,
|
||||
`build-phase30\agentC\VERIFICATION.md`. Agent D (paquet de demo) NON fait.
|
||||
|
||||
Point de depart : Phase 29 livree, mais rochers invisibles aux sites de la conception
|
||||
(pierrier E 903578 / N 6438125 : <= 1,1 % de pixels changes ; pied de barre
|
||||
E 903602 / N 6438269 : 0-0,4 %). Build de reference : `build-agent0\` (Debug) ;
|
||||
`build\` et `build-release\` ont un cache CMake perime (ancien chemin `_CODE\_Vercora`),
|
||||
non touches.
|
||||
|
||||
## Agent A - diagnostic (aucun code modifie)
|
||||
|
||||
- Sonde compilee sur `Rocks.cpp` + capture ; la sonde retrouve a l'unite les comptes du
|
||||
journal du jeu.
|
||||
- **Plancher de bruit : 0 px** avec `--no-grass --no-wildlife --no-bushes` dans les deux
|
||||
conditions. Les 1,1 % du 11/10 etaient l'herbe qui ondule (le vent n'est pas gele par
|
||||
`--time-scale=0`).
|
||||
- Vues de reference (cap vers l'amont tire du gradient DTM, hauteur d'yeux) :
|
||||
pierrier `--look=-120,10`, pied de barre `--look=-175,10` (le cap -100 y montre une
|
||||
paroi pleine, hors masque : 0 px).
|
||||
- **Facteur : la TAILLE ANGULAIRE.** Tache mediane 3 px ; pierraille depassant de 2-5 cm,
|
||||
seule presente a < 20 m ; gros bloc le plus proche a 33 m. Le relief masque 84 % des blocs
|
||||
dans le cadre. Contraste suffisant (luminance 143 contre 224, Weber -0,36) ; portee non
|
||||
limitante (rochers vus de 7 a 175 m pour des portees de 70 a 700 m).
|
||||
- Le site 903578 est sur la frontiere de rugosite (0,104 m au point, 0,074 au centre de sa
|
||||
cellule de pierraille).
|
||||
|
||||
## Agent B - correction
|
||||
|
||||
Fichiers : `src/world/Rocks.{hpp,cpp}`, `src/world/RockMesh.{hpp,cpp}`,
|
||||
`tests/logic_tests.cpp`. Shaders et `main.cpp` NON modifies. Sources avant/apres :
|
||||
`build-phase30\agentB\sources_avant\`, `sources_apres\`.
|
||||
|
||||
| | Phase 29 | Phase 30 |
|
||||
|---|---|---|
|
||||
| rochers moyens (echelle) | 0,35-0,95 | 0,60-1,40 x clamp(rugosite/0,15 ; 0,8 ; 2,0), plafond 1,29 (< seuil de collision 1,3) ; mediane reelle 0,51 -> 0,99 |
|
||||
| gros blocs | - | taille INCHANGEE (collision identique), teinte x0,85 |
|
||||
| pierraille | cailloux 5-12 cm, 8 faces, 40 % hors sol | 10-25 cm, 20 faces, ~55 % hors sol, plaques enfoncees sur sol convexe |
|
||||
| ombre de contact | aucune | x0,55 au pied -> x1 a 0,4 de la hauteur visible (couleur de sommet) |
|
||||
|
||||
- Nombre et placement **identiques au bit** (empreinte de hachage dans les tests ; 4 755
|
||||
instances reelles comparees ; comptes du journal identiques). Masque inchange. Aucune
|
||||
nouvelle collision.
|
||||
- 726 cailloux flottaient en Phase 29 ; 0 maintenant (sur 449 blocs, 1 103 rochers et
|
||||
21 846 cailloux).
|
||||
- Resultat (meme binaire, rochers contre `--no-rocks`, bruit 0 px sur 8 paires) :
|
||||
|
||||
| vue | avant | apres | taches > 100 px |
|
||||
|---|---|---|---|
|
||||
| pierrier -120,10 | 0,386 % | **1,313 %** | 4 -> 27 |
|
||||
| pied de barre -175,10 | 0,144 % | 0,159 % | 1 -> 1 |
|
||||
|
||||
- **Critere de l'Agent A : PARTIELLEMENT atteint.** Les taches (>= 10) sont atteintes, pas
|
||||
les 2 % : la moitie basse du cadre (0-6,6 m) n'a aucun rocher, donc c'est une affaire de
|
||||
densite, hors perimetre. Au pied de barre, les pixels viennent des gros blocs, laisses
|
||||
tels quels pour ne pas changer la collision.
|
||||
- Un caillou de 32 faces donnait 1,498 % mais coutait +0,50 ms : rejete. Un test limite
|
||||
le caillou a 20 triangles.
|
||||
- Tests : **4000/4000** (3968 + 32). Trois tests de la Phase 29 ajustes parce qu'ils
|
||||
encodaient les anciennes tailles : bornes de la plaque de pierraille, tolerance "pose au
|
||||
sol" (pierraille jusqu'a 0,5 m enfoncee), borne basse des rochers moyens.
|
||||
- `shotx.ps1` (capture) corrige : une fenetre de taille nulle laissait le jeu orphelin.
|
||||
|
||||
## Agent C - verification (aucun code modifie)
|
||||
|
||||
| point | verdict |
|
||||
|---|---|
|
||||
| build Debug + headless 4000 (x2) | VERT |
|
||||
| suite Vulkan A-J | VERT : 0 `[Validation]`, sorties 0, fermetures propres ; C passe (0,75/0,89 m, imprecision connue) |
|
||||
| build Release `build-release-p30\` | VERT, apres restauration de `external\` (voir piege) |
|
||||
| captures lisiere (0,38 %, bruit 0,16 %) et zone a buissons 902660,6438835 (15 %, bruit 0,10 %) | VERT : rien de flottant |
|
||||
| scintillement : 14 positions espacees de 0,75 m, avec et sans rochers | VERT dans les limites de la methode : aucun pop ni moire au loin |
|
||||
|
||||
Cout Release (A contre `--no-rocks --no-bushes`, entrelace avec A2 temoin) :
|
||||
|
||||
| vue | rochers + buissons | dont rochers | img/s |
|
||||
|---|---|---|---|
|
||||
| pierrier | +697 us (+23,5 %) | tout | 273 |
|
||||
| alpage ref. | +144 us (+3 %) | 0 | 201 |
|
||||
| zone a buissons | +810 us (+33 %) | +109 us | 309 |
|
||||
|
||||
Part propre a la Phase 30 : un temoin Release (code actuel + fichiers rochers de la
|
||||
Phase 29) donne au pierrier 3 636 us (Phase 30), 3 347 us (rochers Phase 29) et
|
||||
2 891 us (sans rochers), 12 runs valides sur 12. Le cout des rochers passe donc de
|
||||
0,46 a **0,75 ms** (+0,29 ms), tout sur le GPU (le semis coute 24 us). Le pierrier reste
|
||||
a 273 img/s.
|
||||
|
||||
Conditions : l'utilisateur jouait sur le meme GPU de 21:27 a 23:23 (10 captures sur 12
|
||||
etaient vides) ; tout a ete refait apres 23:24. `TextInputHost.exe` occupait ~90 % d'un
|
||||
coeur, d'ou un seuil de rejet releve de 1 a 1,5 coeur ; 16 runs sur 72 restent NON
|
||||
CONCLUANTS. Debug a l'alpage : +1,5 ms par rapport a la Phase 29 dans TOUTES les
|
||||
conditions, meme sans rochers ni buissons ; le Release concorde. Non explique, sans lien
|
||||
avec cette phase.
|
||||
|
||||
## Pieges
|
||||
|
||||
- `CMakeLists.txt` : `FETCHCONTENT_BASE_DIR = external`, donc les dossiers de build de
|
||||
GLFW et GLM sont PARTAGES entre tous les builds. Le build Release a ecrase 28 fichiers,
|
||||
dont `glfw3.lib` ; ils ont ete restaures depuis `build-phase30\agentC\outils\external_avant_release\`.
|
||||
Correctif recommande, non applique : `${CMAKE_BINARY_DIR}/_deps`.
|
||||
- Arbre temoin `build-phase30\agentC\temoin_p29\` : sa jonction `assets` vers les vrais
|
||||
assets a ete RETIREE (rmdir sans /s) par l'orchestrateur.
|
||||
|
||||
## Non fait / non verifie
|
||||
|
||||
- Agent D (candidat de demo `dist\VercoraDemo-candidate`) : pas fait. `dist\VercoraDemo`
|
||||
date du 27/08, sans carte de couvert : dans la demo, ni rochers ni buissons.
|
||||
- Scintillement d'une image a l'autre en mouvement continu : un pas de 0,75 m vaut environ
|
||||
0,5 s de marche.
|
||||
- Lumiere rasante : seul 13 h a ete teste.
|
||||
- Densite des rochers pres du joueur : c'est elle qui manque pour atteindre 2 %, hors
|
||||
perimetre (le nombre devait suivre le masque).
|
||||
@@ -0,0 +1,112 @@
|
||||
# Phase 31 - Builds separes, densite des rochers, demo candidate (2026-10-12)
|
||||
|
||||
Session sans supervision, sous-agents sequentiels. Detail complet :
|
||||
`build-phase31\agent1\RAPPORT.md`, `build-phase31\agent2\RAPPORT.md`,
|
||||
`build-phase31\agent3\RAPPORT.md`.
|
||||
|
||||
**PERF : tous les chiffres de FPS ou de cout de cette phase viennent de l'Intel UHD 770
|
||||
en 1280x720 et sont INDICATIFS.** Aucune conclusion de performance n'a ete tiree ; tout
|
||||
sera remesure sur la GTX 1660 Super en 1440p.
|
||||
|
||||
## 1. CMake : Debug et Release ne partagent plus rien
|
||||
|
||||
- `FETCHCONTENT_BASE_DIR = ${CMAKE_BINARY_DIR}/_deps`. Les sources restent dans
|
||||
`external\*-src` : `FETCHCONTENT_SOURCE_DIR_<NOM>` pointe dessus quand ce cache existe,
|
||||
donc il n'y a ni clone ni acces reseau.
|
||||
- `SOURCE_DIR` a ete ajoute dans chaque `FetchContent_Declare`, pour le cas d'un clone neuf.
|
||||
Utilise seul, il aurait ete dangereux : l'etape de clone efface le dossier source.
|
||||
- `tools\build.bat` et `tools\run_logic_tests.bat` sont inchanges.
|
||||
- Preuves d'independance :
|
||||
- apres un Release complet depuis zero, les 127 fichiers de `build-agent0\` sont
|
||||
identiques au bit ;
|
||||
- `glfw3.lib` du Debug et du Release sont deux fichiers distincts ;
|
||||
- `ninja: no work to do` dans les deux sens ;
|
||||
- `external\` est reste identique tout au long de la session.
|
||||
- Debug (`build-agent0\`) et Release (`build-release-p30\`) reconstruits depuis zero :
|
||||
les deux tournent, 0 `[Validation]`.
|
||||
- A nettoyer par l'utilisateur (non supprime) : `external\*-build` et `external\*-subbuild`
|
||||
(~19 Mo), devenus inutiles. GARDER `external\*-src`. `build\` et `build-release\` sont
|
||||
toujours perimes.
|
||||
|
||||
## 2. Rochers : densite pres du joueur
|
||||
|
||||
Fichiers : `src/world/Rocks.{hpp,cpp}`, `tests/logic_tests.cpp`.
|
||||
|
||||
- Emplacements de PROXIMITE dans les memes cellules, sous le meme masque (pente
|
||||
0,60-0,84, couvert < 0,10, rugosite -> classe, trainees) :
|
||||
- rochers moyens : +60 par cellule de 32 m, portee 60 -> 18 m ;
|
||||
- pierraille : +24 par cellule de 8 m, portee 26 -> 12 m ;
|
||||
- fondu par retrecissement a partir de 60 % de la portee ; au-dela, ni parcourus ni dessines.
|
||||
- AUCUN gros bloc ajoute ; les rochers moyens restent plafonnes a 1,29, donc jamais solides.
|
||||
Collision identique (empreinte sur ~25 000 corps).
|
||||
- Plafond par bloc : 1 792 (grille des blocs) et 1 024 (pierraille). Seule la proximite est
|
||||
eclaircie, par un tirage uniforme independant de l'ordre de semis. Sur toute la zone, le
|
||||
plafond eclaircit 7 blocs de pierraille sur 2 275, et aucun aux deux sites.
|
||||
- Correctif d'un defaut anterieur : pendant le fondu, 1 a 4 cailloux flottaient (jusqu'a 1 cm).
|
||||
- Instances de la Phase 30 identiques au bit.
|
||||
|
||||
Pixels changes contre `--no-rocks`, meme binaire, herbe/faune/buissons coupes des deux
|
||||
cotes (plancher de bruit : 0 px sur 16 paires) :
|
||||
|
||||
| vue | 13 h : P30 -> P31 | 5 h 48, soleil 12,8 deg : P30 -> P31 |
|
||||
|---|---|---|
|
||||
| pierrier -120,10 | 1,313 -> **6,891 %** (taches > 100 px : 27 -> 57) | 1,143 -> **6,065 %** |
|
||||
| pierrier -120,-30 | 0 -> **5,576 %** | 0 -> **5,369 %** |
|
||||
| pied de barre -175,10 | 0,159 -> 0,160 % | 0,133 -> 0,134 % |
|
||||
| pied de barre -175,-30 | 0,454 -> 0,472 % | 0,418 -> 0,437 % |
|
||||
|
||||
- Pierrier, a moins de 15 m : 32 -> 111 plaques. Au-dela de 50 m (plaques) et de 100 m
|
||||
(rochers), les comptes sont inchanges.
|
||||
- **Pied de barre : aucun gain, par la regle.** A moins de 10 m, le masque ne couvre que
|
||||
2,2 % du sol (c'est la paroi), et les rochers ajoutes plus loin sont caches par l'arete.
|
||||
- A l'oeil (planche `build-phase31\agent2\captures\planche_pierrier_avant_apres.png`) :
|
||||
rochers poses, en trainees, sol nu entre elles. Les blocs proches font anguleux (bas-poly)
|
||||
en vue plongeante. Sous lumiere rasante, la limite la plus visible est l'absence d'ombre
|
||||
portee (le moteur n'en fait pas).
|
||||
- Pop et scintillement :
|
||||
- `gather` rejoue au pas de 1 cm sur 10 m : rien n'apparait ni ne disparait,
|
||||
saut maximal 0,034 px ;
|
||||
- 80 captures espacees de 0,5 m : aucun pop au loin, pas de moire.
|
||||
- Trainees conservees (contraste 9,8). Lecon : l'ancien test d'anisotropie passait encore
|
||||
avec une densite ajoutee SANS trainees. Deux tests ajoutes (contraste >= 3 ; aucune instance
|
||||
la ou la trainee est nulle) ; ils echouent tous deux sur ce temoin negatif.
|
||||
- Tests : **4029/4029** (+29). Deux tests modifies : la borne de densite par cellule inclut
|
||||
la proximite ; l'empreinte de la Phase 30 ignore la proximite (references inchangees).
|
||||
- Suite Vulkan A-J verte, 0 `[Validation]`, C passe (0,66/0,87 m).
|
||||
- Release lance au pierrier : ~265 img/s. Semis Debug d'environ 170 a 294 us par image,
|
||||
releve seulement (UHD 770, indicatif).
|
||||
|
||||
## 3. Paquet de demo candidat (dist\VercoraDemo NON modifie)
|
||||
|
||||
- `dist\VercoraDemo-candidate\` (19 fichiers) contient :
|
||||
- le Release de `build-release-p30` (a jour) ;
|
||||
- les DLL VC++ (verifiees avec dumpbin) ;
|
||||
- le terrain 1 m et l'ortho, identiques a l'ancien paquet ;
|
||||
- les 4 cartes de couvert ;
|
||||
- les shaders `precip.*.spv`, indispensables au pipeline meteo.
|
||||
- Exclus : `LHD_*` (casserait l'auto-detection de la demo), `test_2x2`, le terrain 2 m
|
||||
(simple repli), les scenes et `.obj` de l'editeur.
|
||||
- Tailles : dossier 155,2 Mio (ancien 142,4) ; zip `dist\VercoraDemo-candidate.zip`
|
||||
110,7 Mio (ancien 103,3), sha256 `EF938B5E72AE946801E09DB6794E58179D9B542B7808D31CAB7FEBEA91527650`.
|
||||
La racine du zip s'appelle `VercoraDemo/`.
|
||||
- Test depuis I: (disque SATA distinct du NVMe de C:), zip decompresse, lance sans argument :
|
||||
- la demo s'auto-detecte ;
|
||||
- le journal annonce rochers (1,82 / 4,66 / 23,2 par ha) et buissons (21,7 / 31,0 par ha) ;
|
||||
- les captures sont normales ; ~365 / 268 / 275 img/s (indicatif) ;
|
||||
- Debug `--demo` : 0 `[Validation]`.
|
||||
- Copie de test laissee en place : `I:\VercoraDemo-candidate-test-20261012\` (155,2 Mio).
|
||||
- Limites et points connus :
|
||||
- acces aux shaders et a l'ortho deduits du code, pas observes (pas de Process Monitor) ;
|
||||
- console noire au double-clic, deja le cas avant ;
|
||||
- chemin `C:/Users/...` de repli inscrit dans l'exe, jamais lu ;
|
||||
- la console de la demo liste encore des touches desactivees ;
|
||||
- `tools\deploy_beta_to_desktop.ps1` deploie toujours SANS cartes de couvert ni
|
||||
`precip.*.spv`, et depuis `build\` (perime) : a revoir si le candidat est promu.
|
||||
|
||||
## Non fait / non verifie
|
||||
|
||||
- Le cout (sur la nouvelle carte).
|
||||
- Un pied de barre dont le premier plan serait sous masque.
|
||||
- La lumiere rasante du soir (le pierrier y est a contre-jour).
|
||||
- Le scintillement image par image en vrai deplacement.
|
||||
- La decision de remplacer `dist\VercoraDemo` revient a l'utilisateur.
|
||||
@@ -2,6 +2,7 @@
|
||||
|
||||
#include <glm/glm.hpp>
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cmath>
|
||||
#include <cstdint>
|
||||
@@ -21,8 +22,12 @@ const glm::vec3 kLimestone{0.63f, 0.62f, 0.58f};
|
||||
using Face = std::array<uint32_t, 3>;
|
||||
using EdgeKey = std::pair<uint32_t, uint32_t>;
|
||||
|
||||
// PHASE 30 (Agent B) : `top` = sommet visible de la piece (y > 0, repere du
|
||||
// mesh). Chaque SOMMET recoit l'ombre de contact a sa hauteur (voir
|
||||
// rockContactShade) : la couleur est interpolee d'un sommet a l'autre, d'ou un
|
||||
// degrade du pied assombri vers le haut clair, sans toucher au shader.
|
||||
void appendFacet(MeshData& mesh, const glm::vec3& a, const glm::vec3& b,
|
||||
const glm::vec3& c, const glm::vec3& color) {
|
||||
const glm::vec3& c, const glm::vec3& color, float top) {
|
||||
const glm::vec3 raw = glm::cross(b - a, c - a);
|
||||
const float length = glm::length(raw);
|
||||
if (length < 1e-9f) {
|
||||
@@ -33,7 +38,7 @@ void appendFacet(MeshData& mesh, const glm::vec3& a, const glm::vec3& b,
|
||||
for (const glm::vec3& p : { a, b, c }) {
|
||||
Vertex v{};
|
||||
v.pos = p;
|
||||
v.color = color;
|
||||
v.color = color * rockContactShade(p.y, top);
|
||||
v.normal = normal;
|
||||
mesh.vertices.push_back(v);
|
||||
}
|
||||
@@ -76,11 +81,36 @@ void unitSphere(int levels, std::vector<glm::vec3>& points, std::vector<Face>& f
|
||||
}
|
||||
}
|
||||
|
||||
// PHASE 30 (Agent B) : icosaedre sur la sphere unite (20 faces), orientees vers
|
||||
// l'exterieur. Sert aux cailloux de la pierraille : l'octaedre (8 faces) se lit
|
||||
// comme une petite pyramide a 10-25 cm, l'octaedre subdivise (32 faces) coutait
|
||||
// +0,5 ms par image a 361 plaques (mesure entrelacee, RAPPORT Phase 30).
|
||||
void unitIcosahedron(std::vector<glm::vec3>& points, std::vector<Face>& faces) {
|
||||
const float t = 1.6180339887f;
|
||||
points = { { -1, t, 0 }, { 1, t, 0 }, { -1, -t, 0 }, { 1, -t, 0 },
|
||||
{ 0, -1, t }, { 0, 1, t }, { 0, -1, -t }, { 0, 1, -t },
|
||||
{ t, 0, -1 }, { t, 0, 1 }, { -t, 0, -1 }, { -t, 0, 1 } };
|
||||
for (glm::vec3& p : points) {
|
||||
p = glm::normalize(p);
|
||||
}
|
||||
faces = { {0, 11, 5}, {0, 5, 1}, {0, 1, 7}, {0, 7, 10}, {0, 10, 11},
|
||||
{1, 5, 9}, {5, 11, 4}, {11, 10, 2}, {10, 7, 6}, {7, 1, 8},
|
||||
{3, 9, 4}, {3, 4, 2}, {3, 2, 6}, {3, 6, 8}, {3, 8, 9},
|
||||
{4, 9, 5}, {2, 4, 11}, {6, 2, 10}, {8, 6, 7}, {9, 8, 1} };
|
||||
// Orientation verifiee plutot que supposee : normale sortante (convexe).
|
||||
for (Face& f : faces) {
|
||||
const glm::vec3 n = glm::cross(points[f[1]] - points[f[0]], points[f[2]] - points[f[0]]);
|
||||
if (glm::dot(n, points[f[0]] + points[f[1]] + points[f[2]]) < 0.0f) {
|
||||
std::swap(f[1], f[2]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Un caillou irregulier : sphere bosselee puis TRONQUEE par `cuts` plans
|
||||
// aleatoires - chaque plan aplatit une calotte et donne une face de fracture
|
||||
// franche, ce qui distingue un bloc d'eboulis d'un galet roule.
|
||||
struct RockShape {
|
||||
int levels = 1;
|
||||
int levels = 1; // subdivisions de l'octaedre ; < 0 : icosaedre (20 faces)
|
||||
float bumpMin = 0.78f;
|
||||
int cuts = 5;
|
||||
float cutDepth = 0.72f; // distance du plan au centre (sphere unite)
|
||||
@@ -94,7 +124,11 @@ struct RockShape {
|
||||
void appendRock(MeshData& mesh, const RockShape& shape) {
|
||||
std::vector<glm::vec3> points;
|
||||
std::vector<Face> faces;
|
||||
unitSphere(shape.levels, points, faces);
|
||||
if (shape.levels < 0) {
|
||||
unitIcosahedron(points, faces);
|
||||
} else {
|
||||
unitSphere(shape.levels, points, faces);
|
||||
}
|
||||
|
||||
std::mt19937 rng(shape.seed);
|
||||
std::uniform_real_distribution<float> unit(0.0f, 1.0f);
|
||||
@@ -123,11 +157,15 @@ void appendRock(MeshData& mesh, const RockShape& shape) {
|
||||
p.z += shape.offset.y;
|
||||
p.y += shape.yOffset;
|
||||
}
|
||||
float top = 0.0f;
|
||||
for (const glm::vec3& p : points) {
|
||||
top = std::max(top, p.y);
|
||||
}
|
||||
// Legere variation de teinte par face (patine, lichen) : sans elle un bloc a
|
||||
// facettes planes a l'air d'un solide de synthese uniforme.
|
||||
for (const Face& f : faces) {
|
||||
const float shade = 0.90f + 0.14f * unit(rng);
|
||||
appendFacet(mesh, points[f[0]], points[f[1]], points[f[2]], shape.color * shade);
|
||||
appendFacet(mesh, points[f[0]], points[f[1]], points[f[2]], shape.color * shade, top);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -144,6 +182,11 @@ MeshData boulderMeshData() {
|
||||
// Hauteur totale 2 x 0,475 = 0,95 : 0,70 visibles, 0,25 enterres.
|
||||
shape.halfSize = { 0.52f, 0.475f, 0.44f };
|
||||
shape.yOffset = kRockVisibleHeight - 0.475f;
|
||||
// PHASE 30 (Agent B) : patine grise, albedo ~0,53 au lieu de 0,63. Le gros
|
||||
// bloc etait deja 36 % plus sombre que le sol rendu (Weber -0,36, mesure) ;
|
||||
// on CREUSE cet ecart, on ne l'inverse surtout pas : eclaircir "pour coller
|
||||
// au calcaire" fondrait le bloc dans un sol rendu tres clair (~224).
|
||||
shape.color = kLimestone * 0.85f;
|
||||
shape.seed = 0xB01DE5u;
|
||||
appendRock(mesh, shape);
|
||||
return mesh;
|
||||
@@ -175,15 +218,26 @@ MeshData gravelMeshData() {
|
||||
// Disque de rayon 0,5, repartition en racine pour ne pas tasser au centre.
|
||||
const float angle = 6.28318530718f * unit(rng);
|
||||
const float radius = 0.44f * std::sqrt(unit(rng));
|
||||
const float size = 0.05f + 0.07f * unit(rng); // demi-largeur 5 a 12 cm
|
||||
// PHASE 30 (Agent B) : des CAILLOUX et non du gravier. Demi-largeur 5-12 cm
|
||||
// -> 10-25 cm : a 5-12 cm, enterres a 60 %, il en depassait 2 a 5 cm, soit
|
||||
// 2 a 3 px a 10 m (mesure, build-phase30gentA\DIAGNOSTIC.md). Meme
|
||||
// nombre de tirages qu'avant : la disposition des cailloux est conservee.
|
||||
const float size = 0.10f + 0.15f * unit(rng);
|
||||
RockShape shape;
|
||||
shape.levels = 0; // 8 faces : un caillou de quelques cm n'en montre pas plus
|
||||
shape.bumpMin = 0.65f;
|
||||
shape.cuts = 2;
|
||||
// PHASE 30 : icosaedre, 20 faces (etait l'octaedre, 8). A 10-25 cm de
|
||||
// demi-largeur, l'octaedre se lisait comme une petite PYRAMIDE (vu sur
|
||||
// capture). L'octaedre subdivise (32 faces) etait plus rond mais coutait
|
||||
// +0,5 ms de drawFrame a 361 plaques (mesure entrelacee) ; l'icosaedre +
|
||||
// trois coupes donne un caillou anguleux et trapu pour 20 faces.
|
||||
shape.levels = -1;
|
||||
shape.bumpMin = 0.72f;
|
||||
shape.cuts = 3;
|
||||
shape.cutDepth = 0.55f;
|
||||
shape.halfSize = { size, 0.6f * size, 0.8f * size };
|
||||
// A moitie enterre : 0,4 x hauteur au-dessus du sol.
|
||||
shape.yOffset = -0.2f * shape.halfSize.y;
|
||||
// PHASE 30 : centre a +0,1 demi-hauteur (etait -0,2) : ~55 % de la
|
||||
// hauteur hors sol au lieu de 40 %, le pied reste enfoui de 0,9 demi-
|
||||
// hauteur (voir le controle de pose sur le DTM reel, RAPPORT Phase 30).
|
||||
shape.yOffset = 0.1f * shape.halfSize.y;
|
||||
shape.offset = { radius * std::cos(angle), radius * std::sin(angle) };
|
||||
shape.color = kLimestone * (0.85f + 0.2f * unit(rng));
|
||||
shape.seed = 0x9E11u + static_cast<uint32_t>(i) * 7919u;
|
||||
|
||||
@@ -38,4 +38,23 @@ inline constexpr float kRockVisibleHeight = 0.70f; // bloc et rocher
|
||||
inline constexpr float kRockBuriedDepth = 0.25f;
|
||||
inline constexpr float kRockFootprintRadius = 0.50f;
|
||||
|
||||
// PHASE 30 (Agent B) : OMBRE DE CONTACT cuite dans la couleur de sommet. Le
|
||||
// moteur n'a pas d'ombre portee ; sans elle un bloc pose sur un sol clair n'a
|
||||
// pas de pied et semble colle a plat. Facteur x kRockContactShade au niveau du
|
||||
// sol (y <= 0), remontant en smoothstep jusqu'a x1 a kRockContactHeight du
|
||||
// sommet visible de la piece (`top`, repere du mesh). Aucune modification du
|
||||
// shader : foliage.vert transmet deja la couleur de sommet.
|
||||
inline constexpr float kRockContactShade = 0.55f;
|
||||
inline constexpr float kRockContactHeight = 0.40f;
|
||||
inline float rockContactShade(float y, float top) {
|
||||
const float h = kRockContactHeight * top;
|
||||
if (h <= 0.0f) {
|
||||
return 1.0f;
|
||||
}
|
||||
float t = y / h;
|
||||
t = t < 0.0f ? 0.0f : (t > 1.0f ? 1.0f : t);
|
||||
const float smooth = t * t * (3.0f - 2.0f * t);
|
||||
return kRockContactShade + (1.0f - kRockContactShade) * smooth;
|
||||
}
|
||||
|
||||
} // namespace vercora
|
||||
+187
-27
@@ -70,6 +70,21 @@ Rocks::Rocks(const HeightSampler& terrain, const HeightSampler* cover, float ter
|
||||
params_.gravelDistanceNear > params_.gravelDistanceFar) {
|
||||
throw std::runtime_error("Rocks : portee proche au-dela de la portee lointaine.");
|
||||
}
|
||||
// PHASE 31 : les emplacements de proximite restent EN DECA des portees
|
||||
// d'origine (sinon ce ne serait plus de la proximite), et le plafond par
|
||||
// bloc ne peut jamais retirer une instance d'origine.
|
||||
if (params_.stoneNearDistanceNear > params_.stoneNearDistanceFar ||
|
||||
params_.gravelNearDistanceNear > params_.gravelNearDistanceFar ||
|
||||
params_.stoneNearDistanceFar > params_.stoneDistanceNear ||
|
||||
params_.gravelNearDistanceFar > params_.gravelDistanceNear ||
|
||||
params_.nearFadeStart <= 0.0f || params_.nearFadeStart >= 1.0f) {
|
||||
throw std::runtime_error("Rocks : portees de proximite incoherentes.");
|
||||
}
|
||||
const auto cells = static_cast<uint32_t>(kBlockCells * kBlockCells);
|
||||
if (params_.blockInstanceCap < cells * (params_.boulderSlots + params_.stoneSlots) ||
|
||||
params_.gravelInstanceCap < cells * params_.gravelSlots) {
|
||||
throw std::runtime_error("Rocks : plafond par bloc sous le maximum des emplacements d'origine.");
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -174,12 +189,14 @@ float Rocks::streakDensityAt(float worldX, float worldZ) const {
|
||||
void Rocks::fitBox(Cell& cell, float baseX, float baseZ, float size) const {
|
||||
float minY = 0.0f, maxY = 0.0f;
|
||||
bool first = true;
|
||||
for (const RockInstance& r : cell.rocks) {
|
||||
const float lo = r.position.y - kRockBuriedDepth * r.scale;
|
||||
const float hi = r.position.y + (kRockVisibleHeight + 0.3f) * r.scale;
|
||||
minY = first ? lo : std::min(minY, lo);
|
||||
maxY = first ? hi : std::max(maxY, hi);
|
||||
first = false;
|
||||
for (const std::vector<RockInstance>* list : { &cell.rocks, &cell.nearRocks }) {
|
||||
for (const RockInstance& r : *list) {
|
||||
const float lo = r.position.y - kRockBuriedDepth * r.scale;
|
||||
const float hi = r.position.y + (kRockVisibleHeight + 0.3f) * r.scale;
|
||||
minY = first ? lo : std::min(minY, lo);
|
||||
maxY = first ? hi : std::max(maxY, hi);
|
||||
first = false;
|
||||
}
|
||||
}
|
||||
if (first) {
|
||||
minY = maxY = terrain_.heightAt(baseX + 0.5f * size, baseZ + 0.5f * size);
|
||||
@@ -190,8 +207,8 @@ void Rocks::fitBox(Cell& cell, float baseX, float baseZ, float size) const {
|
||||
}
|
||||
|
||||
bool Rocks::makeCandidate(float x, float z, RockKind kind, uint32_t slot, uint32_t slots,
|
||||
uint32_t hSize, uint32_t hYaw, uint32_t hTint,
|
||||
RockInstance& out) const {
|
||||
uint32_t hSize, uint32_t hYaw, uint32_t hTint, float roughness,
|
||||
RockInstance& out, bool nearSlot) const {
|
||||
float sizeMin = 0.0f, sizeMax = 0.0f, far = 0.0f, near = 0.0f;
|
||||
switch (kind) {
|
||||
case RockKind::Boulder:
|
||||
@@ -207,16 +224,59 @@ bool Rocks::makeCandidate(float x, float z, RockKind kind, uint32_t slot, uint32
|
||||
far = params_.gravelDistanceFar; near = params_.gravelDistanceNear;
|
||||
break;
|
||||
}
|
||||
if (nearSlot) {
|
||||
// PHASE 31 : seule la PORTEE change ; taille, orientation, teinte et
|
||||
// assise suivent exactement la loi de la classe.
|
||||
if (kind == RockKind::Gravel) {
|
||||
far = params_.gravelNearDistanceFar; near = params_.gravelNearDistanceNear;
|
||||
} else {
|
||||
far = params_.stoneNearDistanceFar; near = params_.stoneNearDistanceNear;
|
||||
}
|
||||
}
|
||||
out.nearSlot = nearSlot;
|
||||
const glm::vec2 gradient = walkTerrainGradient(terrain_, x, z, slopeProbe_.params().slopeSampleStep);
|
||||
out.kind = kind;
|
||||
out.position = { x, terrain_.heightAt(x, z), z };
|
||||
// Taille : loi en carre, les petits sujets dominent comme dans un vrai eboulis.
|
||||
const float s = unitFloat(hSize);
|
||||
out.scale = sizeMin + (sizeMax - sizeMin) * s * s;
|
||||
if (kind == RockKind::Stone) {
|
||||
// PHASE 30 (Agent B) : un rocher moyen grossit avec la rugosite du DTM au
|
||||
// point (facteur borne, sans tirage : le hachage `hSize` reste le seul
|
||||
// alea de taille, et rien de ce qui decide la PRESENCE n'est touche).
|
||||
// Plafond sous collideMinScale : voir RockParams::stoneSizeCap.
|
||||
out.scale = std::min(out.scale * rockRoughnessScale(roughness, params_), params_.stoneSizeCap);
|
||||
}
|
||||
out.yaw = unitFloat(hYaw) * kTwoPi;
|
||||
out.variation = packRockVariation(unitFloat(hTint), gradient * params_.tiltFollow);
|
||||
const float t = slots > 1 ? static_cast<float>(slot) / static_cast<float>(slots - 1) : 0.0f;
|
||||
out.maxDistance = glm::mix(far, near, t);
|
||||
if (kind == RockKind::Gravel) {
|
||||
// PHASE 30 (Agent B) : ASSISE de la plaque. Une plaque est un plan RIGIDE
|
||||
// (incline par le gradient encode, a 85 %) ; le DTM au pas de 1 m, lui,
|
||||
// se courbe sous un disque de 1 a 2 m. Mesure sur le DTM reel
|
||||
// (build-phase30gentB\outilserif.cpp) : 3,2 % des cailloux de la
|
||||
// Phase 29 avaient leur point bas AU-DESSUS du sol, jusqu'a 0,3 m. On
|
||||
// sonde le sol sur deux anneaux du disque des cailloux et on ENFONCE la
|
||||
// plaque de l'ecart maximal plan - sol. x et z ne bougent pas ; seul y
|
||||
// descend, de quelques cm la ou le sol est convexe. Le plus petit caillou
|
||||
// a deja 0,45 demi-hauteur (>= 0,027 x echelle) enfouie sous le plan,
|
||||
// apres ses coupes : on ne compense que l'ecart AU-DELA de cette marge
|
||||
// (kGravelBuriedMargin), sinon on enterrerait aussi tout ce qui depassait.
|
||||
constexpr float kGravelBuriedMargin = 0.025f;
|
||||
const glm::vec2 plane = unpackRockGradient(out.variation); // pente reelle du plan
|
||||
float sink = 0.0f;
|
||||
for (const float ring : { 0.22f, 0.44f }) {
|
||||
const float radius = ring * out.scale;
|
||||
for (int i = 0; i < 8; ++i) {
|
||||
const float a = static_cast<float>(i) * (kTwoPi / 8.0f);
|
||||
const float ox = radius * std::cos(a), oz = radius * std::sin(a);
|
||||
const float planeY = out.position.y + plane.x * ox + plane.y * oz;
|
||||
sink = std::max(sink, planeY - terrain_.heightAt(x + ox, z + oz));
|
||||
}
|
||||
}
|
||||
out.position.y -= std::max(0.0f, sink - kGravelBuriedMargin * out.scale);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -241,14 +301,37 @@ Rocks::Cell Rocks::buildBlockCell(int32_t cx, int32_t cz) const {
|
||||
const float allowed = streakDensityAt(x, z) * static_cast<float>(kindSlots);
|
||||
if (static_cast<float>(kindSlot) >= allowed) { continue; }
|
||||
// 3. Choix du mesh par la rugosite : les blocs ne vont que sur le rugueux.
|
||||
if (roughnessAt(x, z) < params_.roughBlocks) { continue; }
|
||||
const float roughness = roughnessAt(x, z);
|
||||
if (roughness < params_.roughBlocks) { continue; }
|
||||
RockInstance r;
|
||||
makeCandidate(x, z, boulder ? RockKind::Boulder : RockKind::Stone, kindSlot,
|
||||
kindSlots, cellHash(cx, cz, params_.seed, stream + 2u),
|
||||
cellHash(cx, cz, params_.seed, stream + 3u),
|
||||
cellHash(cx, cz, params_.seed, stream + 4u), r);
|
||||
cellHash(cx, cz, params_.seed, stream + 4u), roughness, r);
|
||||
cell.rocks.push_back(r);
|
||||
}
|
||||
// PHASE 31 : emplacements de PROXIMITE, rochers moyens seulement (jamais
|
||||
// de gros bloc : l'ensemble des blocs solides ne change pas). Memes trois
|
||||
// filtres, dans le meme ordre ; flux disjoints (>= 6000, les flux
|
||||
// d'origine s'arretent a 439) et graine distincte pour le rang.
|
||||
const uint32_t nearSlots = params_.stoneNearSlots;
|
||||
const uint32_t nearSeed = params_.seed ^ 0x3C6EF372u;
|
||||
for (uint32_t slot = 0; slot < nearSlots; ++slot) {
|
||||
const uint32_t stream = slot * 5u + 6000u;
|
||||
const float x = baseX + unitFloat(cellHash(cx, cz, nearSeed, stream)) * size;
|
||||
const float z = baseZ + unitFloat(cellHash(cx, cz, nearSeed, stream + 1u)) * size;
|
||||
if (!maskAt(x, z)) { continue; }
|
||||
const float allowed = streakDensityAt(x, z) * static_cast<float>(nearSlots);
|
||||
if (static_cast<float>(slot) >= allowed) { continue; }
|
||||
const float roughness = roughnessAt(x, z);
|
||||
if (roughness < params_.roughBlocks) { continue; }
|
||||
RockInstance r;
|
||||
makeCandidate(x, z, RockKind::Stone, slot, nearSlots,
|
||||
cellHash(cx, cz, nearSeed, stream + 2u), cellHash(cx, cz, nearSeed, stream + 3u),
|
||||
cellHash(cx, cz, nearSeed, stream + 4u), roughness, r, true);
|
||||
r.rank = cellHash(cx, cz, nearSeed ^ 0xB5297A4Du, stream);
|
||||
cell.nearRocks.push_back(r);
|
||||
}
|
||||
}
|
||||
fitBox(cell, baseX, baseZ, size);
|
||||
return cell;
|
||||
@@ -281,19 +364,59 @@ Rocks::Cell Rocks::buildGravelCell(int32_t cx, int32_t cz) const {
|
||||
RockInstance r;
|
||||
makeCandidate(x, z, RockKind::Gravel, slot, params_.gravelSlots,
|
||||
cellHash(cx, cz, seed, stream + 2u), cellHash(cx, cz, seed, stream + 3u),
|
||||
cellHash(cx, cz, seed, stream + 4u), r);
|
||||
cellHash(cx, cz, seed, stream + 4u), 0.0f, r);
|
||||
cell.rocks.push_back(r);
|
||||
}
|
||||
// PHASE 31 : emplacements de PROXIMITE de la pierraille. Meme masque,
|
||||
// memes trainees, meme decision de rugosite (au centre de la cellule,
|
||||
// la MEME valeur que ci-dessus : une cellule rugueuse reste aux blocs).
|
||||
const uint32_t nearSlots = params_.gravelNearSlots;
|
||||
const uint32_t nearSeed = seed ^ 0x3C6EF372u;
|
||||
for (uint32_t slot = 0; slot < nearSlots && !(roughKnown && rough); ++slot) {
|
||||
const uint32_t stream = slot * 5u + 5000u;
|
||||
const float x = baseX + unitFloat(cellHash(cx, cz, nearSeed, stream)) * size;
|
||||
const float z = baseZ + unitFloat(cellHash(cx, cz, nearSeed, stream + 1u)) * size;
|
||||
if (!maskAt(x, z)) { continue; }
|
||||
const float allowed = streakDensityAt(x, z) * static_cast<float>(nearSlots);
|
||||
if (static_cast<float>(slot) >= allowed) { continue; }
|
||||
if (!roughKnown) {
|
||||
rough = roughnessAt(baseX + 0.5f * size, baseZ + 0.5f * size) >= params_.roughBlocks;
|
||||
roughKnown = true;
|
||||
}
|
||||
if (rough) { break; }
|
||||
RockInstance r;
|
||||
makeCandidate(x, z, RockKind::Gravel, slot, nearSlots,
|
||||
cellHash(cx, cz, nearSeed, stream + 2u), cellHash(cx, cz, nearSeed, stream + 3u),
|
||||
cellHash(cx, cz, nearSeed, stream + 4u), 0.0f, r, true);
|
||||
r.rank = cellHash(cx, cz, nearSeed ^ 0xB5297A4Du, stream);
|
||||
cell.nearRocks.push_back(r);
|
||||
}
|
||||
}
|
||||
fitBox(cell, baseX, baseZ, size);
|
||||
return cell;
|
||||
}
|
||||
|
||||
namespace {
|
||||
std::vector<RockInstance> concatenated(const std::vector<RockInstance>& a, const std::vector<RockInstance>& b) {
|
||||
std::vector<RockInstance> out;
|
||||
out.reserve(a.size() + b.size());
|
||||
out.insert(out.end(), a.begin(), a.end());
|
||||
out.insert(out.end(), b.begin(), b.end());
|
||||
return out;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
std::vector<RockInstance> Rocks::blockCellRocks(int32_t cx, int32_t cz) const {
|
||||
return buildBlockCell(cx, cz).rocks;
|
||||
const Cell cell = buildBlockCell(cx, cz);
|
||||
return concatenated(cell.rocks, cell.nearRocks);
|
||||
}
|
||||
std::vector<RockInstance> Rocks::gravelCellRocks(int32_t cx, int32_t cz) const {
|
||||
return buildGravelCell(cx, cz).rocks;
|
||||
const Cell cell = buildGravelCell(cx, cz);
|
||||
return concatenated(cell.rocks, cell.nearRocks);
|
||||
}
|
||||
std::vector<RockInstance> Rocks::blockRocks(int32_t bx, int32_t bz, bool gravelGrid) const {
|
||||
const Cell block = buildBlock(bx, bz, gravelGrid);
|
||||
return concatenated(block.rocks, block.nearRocks);
|
||||
}
|
||||
|
||||
Rocks::Cell Rocks::buildBlock(int32_t bx, int32_t bz, bool gravelGrid) const {
|
||||
@@ -307,13 +430,38 @@ Rocks::Cell Rocks::buildBlock(int32_t bx, int32_t bz, bool gravelGrid) const {
|
||||
for (int32_t i = 0; i < kBlockCells; ++i) {
|
||||
const int32_t cx = bx * kBlockCells + i, cz = bz * kBlockCells + j;
|
||||
const Cell cell = gravelGrid ? buildGravelCell(cx, cz) : buildBlockCell(cx, cz);
|
||||
if (cell.rocks.empty()) { continue; }
|
||||
if (cell.rocks.empty() && cell.nearRocks.empty()) { continue; }
|
||||
block.boxMin = first ? cell.boxMin : glm::min(block.boxMin, cell.boxMin);
|
||||
block.boxMax = first ? cell.boxMax : glm::max(block.boxMax, cell.boxMax);
|
||||
first = false;
|
||||
block.rocks.insert(block.rocks.end(), cell.rocks.begin(), cell.rocks.end());
|
||||
block.nearRocks.insert(block.nearRocks.end(), cell.nearRocks.begin(), cell.nearRocks.end());
|
||||
}
|
||||
}
|
||||
// PHASE 31 : PLAFOND d'instances par bloc. Seules les instances de
|
||||
// proximite sont eclaircies, en gardant les `rank` les plus petits : un
|
||||
// tirage uniforme (pas un decoupage par cellule ou par emplacement, qui
|
||||
// ferait des trous ou casserait le LOD), et independant de l'ordre dans
|
||||
// lequel les blocs sont semes (le bloc est une fonction pure de (bx, bz)).
|
||||
// Egalites de rang departagees par l'indice : resultat total et
|
||||
// deterministe. Les instances d'origine ne sont jamais touchees (le
|
||||
// constructeur garantit cap >= leur maximum).
|
||||
const uint32_t cap = gravelGrid ? params_.gravelInstanceCap : params_.blockInstanceCap;
|
||||
const std::size_t room = cap > block.rocks.size() ? cap - block.rocks.size() : 0;
|
||||
if (block.nearRocks.size() > room) {
|
||||
std::vector<uint32_t> order(block.nearRocks.size());
|
||||
for (uint32_t i = 0; i < order.size(); ++i) { order[i] = i; }
|
||||
std::sort(order.begin(), order.end(), [&](uint32_t a, uint32_t b) {
|
||||
const uint32_t ra = block.nearRocks[a].rank, rb = block.nearRocks[b].rank;
|
||||
return ra != rb ? ra < rb : a < b;
|
||||
});
|
||||
order.resize(room);
|
||||
std::sort(order.begin(), order.end());
|
||||
std::vector<RockInstance> kept;
|
||||
kept.reserve(room);
|
||||
for (const uint32_t i : order) { kept.push_back(block.nearRocks[i]); }
|
||||
block.nearRocks.swap(kept);
|
||||
}
|
||||
return block;
|
||||
}
|
||||
|
||||
@@ -346,6 +494,7 @@ void Rocks::gatherGrid(const glm::vec3& eye, const Frustum& frustum, bool gravel
|
||||
const float cellSize = gravelGrid ? params_.gravelCell : params_.blockCell;
|
||||
const float reach = gravelGrid ? params_.gravelDistanceFar
|
||||
: std::max(params_.boulderDistanceFar, params_.stoneDistanceFar);
|
||||
const float nearReach = gravelGrid ? params_.gravelNearDistanceFar : params_.stoneNearDistanceFar;
|
||||
const uint32_t budget = gravelGrid ? params_.gravelCellBudget : params_.blockCellBudget;
|
||||
Cache& cache = gravelGrid ? gravelCache_ : blockCache_;
|
||||
const float blockSize = static_cast<float>(kBlockCells) * cellSize;
|
||||
@@ -385,21 +534,32 @@ void Rocks::gatherGrid(const glm::vec3& eye, const Frustum& frustum, bool gravel
|
||||
found = cache.emplace(CellKey{ bx, bz }, buildBlock(bx, bz, gravelGrid)).first;
|
||||
}
|
||||
const Cell& block = found->second;
|
||||
if (block.rocks.empty() || !frustum.intersectsAABB(block.boxMin, block.boxMax)) {
|
||||
if ((block.rocks.empty() && block.nearRocks.empty()) ||
|
||||
!frustum.intersectsAABB(block.boxMin, block.boxMax)) {
|
||||
continue;
|
||||
}
|
||||
for (const RockInstance& r : block.rocks) {
|
||||
const glm::vec3 d = eye - r.position;
|
||||
const float d2 = glm::dot(d, d);
|
||||
if (d2 >= r.maxDistance * r.maxDistance) { continue; }
|
||||
const float distance = std::sqrt(d2);
|
||||
InstanceData instance;
|
||||
instance.position = r.position;
|
||||
instance.scale = r.scale;
|
||||
instance.yaw = r.yaw;
|
||||
instance.variation = r.variation;
|
||||
instance.fade = 1.0f - ramp(distance, 0.82f * r.maxDistance, r.maxDistance);
|
||||
outs[static_cast<int>(r.kind)]->push_back(instance);
|
||||
const auto emit = [&](const std::vector<RockInstance>& list, float fadeStart) {
|
||||
for (const RockInstance& r : list) {
|
||||
const glm::vec3 d = eye - r.position;
|
||||
const float d2 = glm::dot(d, d);
|
||||
if (d2 >= r.maxDistance * r.maxDistance) { continue; }
|
||||
const float distance = std::sqrt(d2);
|
||||
InstanceData instance;
|
||||
instance.position = r.position;
|
||||
instance.scale = r.scale;
|
||||
instance.yaw = r.yaw;
|
||||
instance.variation = r.variation;
|
||||
instance.fade = 1.0f - ramp(distance, fadeStart * r.maxDistance, r.maxDistance);
|
||||
instance.position.y -= rockFadeSink(r.kind, r.scale, instance.fade);
|
||||
outs[static_cast<int>(r.kind)]->push_back(instance);
|
||||
}
|
||||
};
|
||||
emit(block.rocks, 0.82f);
|
||||
// PHASE 31 : les emplacements de proximite ne sont meme pas parcourus
|
||||
// quand le bloc est hors de leur portee (distance horizontale au bloc,
|
||||
// qui minore la distance 3D) : aucun surcout lointain.
|
||||
if (!block.nearRocks.empty() && bdx * bdx + bdz * bdz < nearReach * nearReach) {
|
||||
emit(block.nearRocks, params_.nearFadeStart);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -51,8 +51,26 @@ struct RockParams {
|
||||
float blockCell = 32.0f;
|
||||
uint32_t boulderSlots = 8; // au plus 8 gros blocs / 1024 m2 (1 / 128 m2)
|
||||
uint32_t stoneSlots = 20; // au plus 20 rochers moyens / 1024 m2
|
||||
// Gros blocs : loi de taille de la Phase 29, INCHANGEE en Phase 30. C'est
|
||||
// elle qui porte la collision (collideMinScale, rayon x echelle) : la garder
|
||||
// telle quelle garantit une collision identique au bit pres.
|
||||
float boulderSizeMin = 1.1f, boulderSizeMax = 2.6f; // echelle (m)
|
||||
float stoneSizeMin = 0.35f, stoneSizeMax = 0.95f;
|
||||
// PHASE 30 (Agent B) : rochers moyens 0,35-0,95 -> 0,6-1,4, puis x le
|
||||
// facteur de rugosite (voir rockRoughnessScale) et plafonnes a stoneSizeCap.
|
||||
// Mesure (build-phase30gentA\DIAGNOSTIC.md) : a 0,36 m hors sol ils
|
||||
// n'apportaient que 2 % des pixels de rochers, 3 px de mediane a 35 m.
|
||||
float stoneSizeMin = 0.60f, stoneSizeMax = 1.40f;
|
||||
// Plafond STRICTEMENT sous collideMinScale : un rocher moyen n'a pas de
|
||||
// collision ; il ne doit donc jamais atteindre la taille d'un gros bloc qui
|
||||
// en a une (sinon on traverserait un bloc d'aspect bloquant).
|
||||
float stoneSizeCap = 1.29f;
|
||||
// PHASE 30 : facteur de taille = clamp(rugosite / ref, min, max). Un DTM de
|
||||
// 0,10 m RMS ne porte pas de blocs de 2 m ; une zone a 0,30 m RMS, si. Ne
|
||||
// s'applique qu'aux rochers MOYENS (les gros blocs gardent leur loi, voir
|
||||
// plus haut). Mediane de la rugosite au pied des rochers : 0,16-0,18 m,
|
||||
// donc un facteur median ~1,1.
|
||||
float roughScaleRef = 0.15f;
|
||||
float roughScaleMin = 0.80f, roughScaleMax = 2.00f;
|
||||
float boulderDistanceFar = 700.0f, boulderDistanceNear = 350.0f;
|
||||
float stoneDistanceFar = 320.0f, stoneDistanceNear = 140.0f;
|
||||
|
||||
@@ -76,6 +94,41 @@ struct RockParams {
|
||||
// de la pente est lue au centre de chaque tuile de 96 m.
|
||||
float streakTile = 96.0f;
|
||||
|
||||
// --- PHASE 31 (Agent 2) : emplacements de PROXIMITE ---------------------
|
||||
// Mesure (build-phase30\agentA\DIAGNOSTIC.md, NOTES-PHASE30.md) : le premier
|
||||
// plan (0-15 m) n'avait AUCUN rocher, faute de densite. On ajoute, dans les
|
||||
// MEMES cellules et sous le MEME masque (pente, couvert, rugosite -> classe,
|
||||
// trainees), des emplacements supplementaires a PORTEE COURTE : c'est le LOD
|
||||
// de densite existant (chaque emplacement a sa portee) prolonge vers le
|
||||
// joueur. Au-dela de stone/gravelNearDistanceFar ils ne sont ni parcourus
|
||||
// ni dessines : aucun surcout lointain.
|
||||
// - rochers moyens seulement (jamais de gros bloc : la collision ne change
|
||||
// pas), meme loi de taille, donc plafonnes a stoneSizeCap < 1,3 ;
|
||||
// - pierraille : memes plaques.
|
||||
// Flux de hachage DISJOINTS de ceux de la Phase 29/30 : les instances
|
||||
// d'origine sont identiques au bit (empreinte dans les tests).
|
||||
// Valeurs MESUREES (build-phase31\agent2\RAPPORT.md) : 40 emplacements a
|
||||
// 48 m ou 60 a 80 m donnent le meme gain d'image au pierrier (6,87 / 6,93 %
|
||||
// de pixels) ; on garde 60 emplacements (densite proche) sur 60 m.
|
||||
uint32_t stoneNearSlots = 60; // en plus des 20 : au plus 80 rochers / 1024 m2 pres du joueur
|
||||
float stoneNearDistanceFar = 60.0f, stoneNearDistanceNear = 18.0f;
|
||||
uint32_t gravelNearSlots = 24; // en plus des 12 : au plus 36 plaques / 64 m2 pres du joueur
|
||||
float gravelNearDistanceFar = 26.0f, gravelNearDistanceNear = 12.0f;
|
||||
// Fondu par retrecissement des emplacements de proximite : sur les 40 %
|
||||
// derniers de leur portee (0,82 -> 1 pour les autres). Portees courtes,
|
||||
// donc bande plus large en proportion : une plaque ne doit pas "pousser"
|
||||
// en 2 m de marche.
|
||||
float nearFadeStart = 0.60f;
|
||||
// PLAFOND d'instances par BLOC de cache (8 x 8 cellules), toutes classes.
|
||||
// Seules les instances de PROXIMITE sont eclaircies pour tenir dessous
|
||||
// (tirage `rank` uniforme, independant de l'ordre) : les instances
|
||||
// d'origine, gros blocs compris, ne sont JAMAIS retirees. Le constructeur
|
||||
// refuse un plafond sous le maximum d'origine (64 x emplacements d'origine).
|
||||
// Sans plafond, le pire cas theorique serait 64 x 88 = 5 632 (blocs) et
|
||||
// 64 x 36 = 2 304 (pierraille). Mesure sur la zone : max 1 080 et 1 315.
|
||||
uint32_t blockInstanceCap = 1792; // = maximum d'origine 64 x 28 (le plafond le plus bas permis)
|
||||
uint32_t gravelInstanceCap = 1024; // origine : au plus 64 x 12 = 768
|
||||
|
||||
// Part de la pente suivie par l'inclinaison du rocher (1 = normale au sol).
|
||||
float tiltFollow = 0.85f;
|
||||
|
||||
@@ -95,6 +148,28 @@ struct RockParams {
|
||||
|
||||
enum class RockKind : uint8_t { Boulder = 0, Stone = 1, Gravel = 2 };
|
||||
|
||||
// PHASE 30 (Agent B) : facteur de taille des rochers moyens selon la rugosite
|
||||
// locale du DTM (m). Borne, monotone, sans alea : il ne consomme AUCUN tirage du
|
||||
// hachage, donc ne change ni la presence ni la position d'aucun rocher.
|
||||
inline float rockRoughnessScale(float roughness, const RockParams& p) {
|
||||
const float k = roughness / p.roughScaleRef;
|
||||
return std::fmin(std::fmax(k, p.roughScaleMin), p.roughScaleMax);
|
||||
}
|
||||
|
||||
// PHASE 31 (Agent 2) : ENFONCEMENT d'une plaque de pierraille pendant son fondu
|
||||
// (m, a retrancher a y). Le fondu retrecit la plaque vers son origine ; l'assise
|
||||
// (Rocks::makeCandidate) n'est sondee qu'a pleine echelle, sur deux anneaux. Mesure
|
||||
// (sonde, 150 m autour des deux sites) : a 30 % d'echelle, 1 a 4 cailloux sur des
|
||||
// dizaines de milliers ont leur point bas jusqu'a 1 cm AU-DESSUS du sol - defaut
|
||||
// anterieur a la Phase 31, plus frequent avec la densite. On enfonce donc la plaque
|
||||
// de 4 cm x echelle x (1 - fondu) : nul a pleine echelle (assise inchangee), et
|
||||
// la plaque s'enterre en meme temps qu'elle rapetisse. Blocs et rochers : 0 (pied
|
||||
// au sol, ils ne flottent a aucune echelle, mesure).
|
||||
constexpr float kGravelFadeSink = 0.04f;
|
||||
inline float rockFadeSink(RockKind kind, float scale, float fade) {
|
||||
return kind == RockKind::Gravel ? kGravelFadeSink * scale * (1.0f - fade) : 0.0f;
|
||||
}
|
||||
|
||||
// Encodage de l'inclinaison dans InstanceData::variation (voir shaders/
|
||||
// foliage.vert, mode rocher = params.w < 0). La struct d'instance est pleine
|
||||
// (28 o, stride fige) ; plutot que d'en creer une seconde et un second format
|
||||
@@ -124,6 +199,10 @@ struct RockInstance {
|
||||
float variation = 0.0f; // deja encode (packRockVariation)
|
||||
float maxDistance = 0.0f; // portee propre a l'emplacement (LOD de densite)
|
||||
RockKind kind = RockKind::Gravel;
|
||||
// PHASE 31 : emplacement de PROXIMITE (portee courte, fondu large, eclairci
|
||||
// par le plafond du bloc selon `rank`). false = emplacement d'origine.
|
||||
bool nearSlot = false;
|
||||
uint32_t rank = 0;
|
||||
};
|
||||
|
||||
class Rocks : public CollisionSolver {
|
||||
@@ -145,9 +224,15 @@ public:
|
||||
float roughnessAt(float worldX, float worldZ) const; // m
|
||||
float streakDensityAt(float worldX, float worldZ) const; // [0,1]
|
||||
|
||||
// Tous les candidats RETENUS par le semis d'une cellule (tests).
|
||||
// Tous les candidats RETENUS par le semis d'une cellule (tests) : origine
|
||||
// puis proximite, AVANT le plafond par bloc.
|
||||
std::vector<RockInstance> blockCellRocks(int32_t cx, int32_t cz) const;
|
||||
std::vector<RockInstance> gravelCellRocks(int32_t cx, int32_t cz) const;
|
||||
// PHASE 31 : contenu d'un BLOC de cache (kBlockCells x kBlockCells
|
||||
// cellules), APRES le plafond - exactement ce que gather et la collision
|
||||
// lisent. Construit a neuf (fonction pure du bloc ; tests, diagnostic).
|
||||
std::vector<RockInstance> blockRocks(int32_t bx, int32_t bz, bool gravelGrid) const;
|
||||
static constexpr int32_t kBlockCells = 8;
|
||||
|
||||
// Estimation sur toute la zone (une cellule de blocs sur `step`) : part de
|
||||
// la surface sous masque et nombre de rochers par hectare de masque.
|
||||
@@ -182,7 +267,8 @@ private:
|
||||
}
|
||||
};
|
||||
struct Cell {
|
||||
std::vector<RockInstance> rocks;
|
||||
std::vector<RockInstance> rocks; // emplacements d'origine (Phase 29/30)
|
||||
std::vector<RockInstance> nearRocks; // PHASE 31 : emplacements de proximite
|
||||
glm::vec3 boxMin{0.0f}, boxMax{0.0f};
|
||||
};
|
||||
using Cache = std::unordered_map<CellKey, Cell, CellKeyHash>;
|
||||
@@ -190,7 +276,6 @@ private:
|
||||
Cell buildBlockCell(int32_t cx, int32_t cz) const;
|
||||
Cell buildGravelCell(int32_t cx, int32_t cz) const;
|
||||
// Cache par BLOC de kBlockCells x kBlockCells cellules (voir buildBlock).
|
||||
static constexpr int32_t kBlockCells = 8;
|
||||
Cell buildBlock(int32_t bx, int32_t bz, bool gravelGrid) const;
|
||||
const Cell& cachedBlock(int32_t bx, int32_t bz, bool gravelGrid) const;
|
||||
|
||||
@@ -199,9 +284,12 @@ private:
|
||||
std::vector<InstanceData>* outs[3]);
|
||||
|
||||
// Candidat a (x, z) : filtre dur + construction. Renvoie false si rejete.
|
||||
// `roughness` : rugosite deja calculee au point par le semis (blocs) ; sert
|
||||
// a la taille des rochers moyens (PHASE 30), ignoree pour les autres types.
|
||||
// `nearSlot` (PHASE 31) : portee tiree de stone/gravelNearDistance*.
|
||||
bool makeCandidate(float x, float z, RockKind kind, uint32_t slot, uint32_t slots,
|
||||
uint32_t hSize, uint32_t hYaw, uint32_t hTint,
|
||||
RockInstance& out) const;
|
||||
uint32_t hSize, uint32_t hYaw, uint32_t hTint, float roughness,
|
||||
RockInstance& out, bool nearSlot = false) const;
|
||||
float coverAt(float worldX, float worldZ) const;
|
||||
void fitBox(Cell& cell, float baseX, float baseZ, float size) const;
|
||||
|
||||
|
||||
+781
-5
@@ -9582,7 +9582,12 @@ void testRockMeshes() {
|
||||
check(std::max(hi.x - lo.x, hi.z - lo.z) <= 2.0f * kRockFootprintRadius + 0.05f,
|
||||
std::string("Mesh ") + names[m] + " : empreinte dans le rayon de collision");
|
||||
} else {
|
||||
check(hi.y < 0.15f && std::max(hi.x - lo.x, hi.z - lo.z) <= 1.2f,
|
||||
// PHASE 30 (Agent B) : bornes elargies (etaient hi.y < 0,15 et
|
||||
// emprise <= 1,2). Les cailloux passent de 5-12 cm a 10-25 cm de
|
||||
// demi-largeur et sortent a ~55 % au lieu de 40 % : sommet <= 0,165,
|
||||
// emprise <= 2 x (0,44 + 0,25) = 1,38. La plaque reste BASSE (sous
|
||||
// 0,20 a l'echelle 1) - c'est ce que ce test protege.
|
||||
check(hi.y < 0.20f && std::max(hi.x - lo.x, hi.z - lo.z) <= 1.45f,
|
||||
"Mesh pierraille : plaque basse d'un metre environ");
|
||||
}
|
||||
}
|
||||
@@ -9646,7 +9651,17 @@ void testRockPlacement() {
|
||||
outside += rocks.maskAt(r.position.x, r.position.z) ? 0u : 1u;
|
||||
// Bande attendue : pente 0,6..0,84 -> x = -500..100, nue a l'ouest de 0.
|
||||
outside += (r.position.x < -505.0f || r.position.x > 0.0f) ? 1u : 0u;
|
||||
badY += std::abs(r.position.y - ramp.heightAt(r.position.x, r.position.z)) > 1e-2f ? 1u : 0u;
|
||||
// PHASE 30 (Agent B) : la plaque de pierraille est ENFONCEE de
|
||||
// quelques cm la ou le sol est convexe (assise, voir
|
||||
// Rocks::makeCandidate) ; elle n'est donc plus a y = sol exact,
|
||||
// mais jamais AU-DESSUS du sol, et jamais de plus de 0,5 m dessous.
|
||||
// Blocs et rochers : y = sol, comme en Phase 29.
|
||||
const float ground = ramp.heightAt(r.position.x, r.position.z);
|
||||
if (r.kind == RockKind::Gravel) {
|
||||
badY += (r.position.y > ground + 1e-2f || r.position.y < ground - 0.5f) ? 1u : 0u;
|
||||
} else {
|
||||
badY += std::abs(r.position.y - ground) > 1e-2f ? 1u : 0u;
|
||||
}
|
||||
}
|
||||
};
|
||||
for (int32_t cz = -20; cz <= 20; ++cz) {
|
||||
@@ -9704,11 +9719,18 @@ void testRockPlacement() {
|
||||
}
|
||||
differs = differs || rc.size() != ra.size() ||
|
||||
(!ra.empty() && ra[0].position != rc[0].position);
|
||||
bounded = bounded && ra.size() <= defaults.boulderSlots + defaults.stoneSlots;
|
||||
// PHASE 31 (Agent 2) : + stoneNearSlots (emplacements de proximite,
|
||||
// rochers moyens seulement) ; les gros blocs restent bornes par
|
||||
// boulderSlots juste en dessous.
|
||||
bounded = bounded && ra.size() <= defaults.boulderSlots + defaults.stoneSlots + defaults.stoneNearSlots;
|
||||
uint32_t boulders = 0;
|
||||
for (const RockInstance& r : ra) {
|
||||
boulders += (r.kind == RockKind::Boulder) ? 1u : 0u;
|
||||
bounded = bounded && r.scale >= defaults.stoneSizeMin - 1e-4f &&
|
||||
// PHASE 30 (Agent B) : borne basse = stoneSizeMin x roughScaleMin
|
||||
// (etait stoneSizeMin) : la rugosite peut reduire un rocher
|
||||
// moyen de 20 %. Borne haute inchangee (boulderSizeMax).
|
||||
bounded = bounded &&
|
||||
r.scale >= defaults.stoneSizeMin * defaults.roughScaleMin - 1e-4f &&
|
||||
r.scale <= defaults.boulderSizeMax + 1e-4f;
|
||||
}
|
||||
bounded = bounded && boulders <= defaults.boulderSlots;
|
||||
@@ -9718,7 +9740,7 @@ void testRockPlacement() {
|
||||
}
|
||||
check(same, "Determinisme : meme graine -> memes rochers, au bit pres");
|
||||
check(differs, "Graine differente -> semis different");
|
||||
check(bounded, "Densite bornee : <= boulderSlots + stoneSlots par cellule, tailles dans les bornes");
|
||||
check(bounded, "Densite bornee : <= boulderSlots + stoneSlots (+ stoneNearSlots, Phase 31) par cellule, tailles dans les bornes");
|
||||
std::printf(" (%u cellules sous masque : %u vides)\n", cells, empty);
|
||||
check(empty > 0 && empty < cells, "Trainees : le bruit module la densite (cellules vides ET peuplees sous masque)");
|
||||
const Rocks::Stats st = a.estimate(3);
|
||||
@@ -9839,6 +9861,756 @@ void testRockPlacement() {
|
||||
}
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// PHASE 30 (Agent B) : rochers LISIBLES - taille liee a la rugosite, pierraille
|
||||
// en cailloux, ombre de contact. Le semis (presence, position, nombre) et la
|
||||
// collision des gros blocs doivent rester ceux de la Phase 29 AU BIT PRES.
|
||||
// ===========================================================================
|
||||
|
||||
// Empreinte du semis : FNV-1a sur (type, x, z au mm) de chaque instance, et
|
||||
// separement sur (x, z, echelle au 1/10 000) des seuls GROS BLOCS - ceux qui
|
||||
// portent la collision. Valeurs de reference relevees avec le code de la
|
||||
// Phase 29 (build-phase30\agentB\sources_avant), AVANT toute modification.
|
||||
struct RockFingerprint {
|
||||
uint64_t positions = 1469598103934665603ull;
|
||||
uint64_t boulders = 1469598103934665603ull;
|
||||
uint32_t counts[3] = { 0, 0, 0 };
|
||||
};
|
||||
void fnvMix(uint64_t& h, int64_t v) {
|
||||
for (int b = 0; b < 8; ++b) {
|
||||
h ^= static_cast<uint64_t>((v >> (8 * b)) & 0xFF);
|
||||
h *= 1099511628211ull;
|
||||
}
|
||||
}
|
||||
// PHASE 31 (Agent 2) : `includeNear` = false (defaut) ignore les emplacements de
|
||||
// PROXIMITE ajoutes en Phase 31 : l'empreinte porte alors exactement sur le semis
|
||||
// de la Phase 29/30, dont les valeurs de reference ci-dessous sont INCHANGEES.
|
||||
RockFingerprint rockFingerprint(const Rocks& rocks, int32_t blockRange, int32_t gravelRange,
|
||||
bool includeNear = false) {
|
||||
RockFingerprint fp;
|
||||
const auto add = [&](const RockInstance& r) {
|
||||
if (r.nearSlot && !includeNear) { return; }
|
||||
fp.counts[static_cast<int>(r.kind)] += 1;
|
||||
fnvMix(fp.positions, static_cast<int64_t>(r.kind));
|
||||
fnvMix(fp.positions, std::llround(r.position.x * 1000.0));
|
||||
fnvMix(fp.positions, std::llround(r.position.z * 1000.0));
|
||||
if (r.kind == RockKind::Boulder) {
|
||||
fnvMix(fp.boulders, std::llround(r.position.x * 1000.0));
|
||||
fnvMix(fp.boulders, std::llround(r.position.z * 1000.0));
|
||||
fnvMix(fp.boulders, std::llround(r.scale * 10000.0));
|
||||
}
|
||||
};
|
||||
for (int32_t cz = -blockRange; cz <= blockRange; ++cz) {
|
||||
for (int32_t cx = -blockRange; cx <= blockRange; ++cx) {
|
||||
for (const RockInstance& r : rocks.blockCellRocks(cx, cz)) { add(r); }
|
||||
}
|
||||
}
|
||||
for (int32_t cz = -gravelRange; cz <= gravelRange; ++cz) {
|
||||
for (int32_t cx = -gravelRange; cx <= gravelRange; ++cx) {
|
||||
for (const RockInstance& r : rocks.gravelCellRocks(cx, cz)) { add(r); }
|
||||
}
|
||||
}
|
||||
return fp;
|
||||
}
|
||||
|
||||
void testRockReadability() {
|
||||
section("Phase 30 : rochers lisibles (taille ~ rugosite, semis et collision inchanges)");
|
||||
ConstantMap bare(0.0f);
|
||||
RoughSlope rough(0.72f, 0.50f);
|
||||
SlopedTerrain smooth(1500.0f, 0.72f);
|
||||
|
||||
// --- Ancre de non-regression : semis et gros blocs de la Phase 29 --------
|
||||
{
|
||||
Rocks onRough(rough, &bare, 1000.0f), onSmooth(smooth, &bare, 1000.0f);
|
||||
const RockFingerprint a = rockFingerprint(onRough, 8, 24);
|
||||
const RockFingerprint b = rockFingerprint(onSmooth, 8, 24);
|
||||
std::printf(" (rugueux : %u blocs %u rochers %u plaques, positions %016llx, gros blocs %016llx)\n",
|
||||
a.counts[0], a.counts[1], a.counts[2], static_cast<unsigned long long>(a.positions),
|
||||
static_cast<unsigned long long>(a.boulders));
|
||||
std::printf(" (lisse : %u blocs %u rochers %u plaques, positions %016llx)\n",
|
||||
b.counts[0], b.counts[1], b.counts[2], static_cast<unsigned long long>(b.positions));
|
||||
check(a.counts[0] == 1204u && a.counts[1] == 2889u && a.counts[2] == 0u,
|
||||
"Phase 30 : comptes par type IDENTIQUES a la Phase 29 (versant rugueux)");
|
||||
check(a.positions == 0xffd1c148f9c8c6fbull, "Phase 30 : positions IDENTIQUES a la Phase 29 (versant rugueux)");
|
||||
check(a.boulders == 0xff89983fdbfdc457ull,
|
||||
"Phase 30 : gros blocs (position ET echelle, donc collision) IDENTIQUES a la Phase 29");
|
||||
check(b.counts[0] == 0u && b.counts[1] == 0u && b.counts[2] == 15168u &&
|
||||
b.positions == 0xfc49aaeae3bcd6feull,
|
||||
"Phase 30 : pierraille du versant lisse : comptes et positions IDENTIQUES a la Phase 29");
|
||||
// PHASE 31 (Agent 2) : AVEC les emplacements de proximite, les gros blocs
|
||||
// (position ET echelle) restent ceux de la Phase 29 - aucun bloc ajoute.
|
||||
const RockFingerprint all = rockFingerprint(onRough, 8, 24, true);
|
||||
std::printf(" (avec proximite : %u blocs %u rochers %u plaques, gros blocs %016llx)\n", all.counts[0],
|
||||
all.counts[1], all.counts[2], static_cast<unsigned long long>(all.boulders));
|
||||
check(all.counts[0] == 1204u && all.boulders == 0xff89983fdbfdc457ull,
|
||||
"Phase 31 : avec la proximite, gros blocs IDENTIQUES a la Phase 29 (empreinte)");
|
||||
check(all.counts[1] > a.counts[1], "Phase 31 : la proximite ajoute bien des rochers moyens (effet non nul)");
|
||||
}
|
||||
|
||||
const RockParams defaults;
|
||||
|
||||
// --- Loi rugosite -> facteur de taille -----------------------------------
|
||||
{
|
||||
checkNear(rockRoughnessScale(0.15f, defaults), 1.0f, 1e-6f, "Facteur de taille : 1 a la rugosite de reference 0,15 m");
|
||||
checkNear(rockRoughnessScale(0.0f, defaults), defaults.roughScaleMin, 1e-6f, "Facteur de taille : borne basse 0,8 (sol lisse)");
|
||||
checkNear(rockRoughnessScale(0.10f, defaults), defaults.roughScaleMin, 1e-6f, "Facteur de taille : 0,10 m (seuil des blocs) -> 0,8");
|
||||
checkNear(rockRoughnessScale(0.30f, defaults), 2.0f, 1e-6f, "Facteur de taille : 0,30 m -> 2");
|
||||
checkNear(rockRoughnessScale(5.0f, defaults), defaults.roughScaleMax, 1e-6f, "Facteur de taille : borne haute 2 (artefact de paroi)");
|
||||
bool monotone = true;
|
||||
for (float r = 0.0f; r < 1.0f; r += 0.01f) {
|
||||
monotone = monotone && rockRoughnessScale(r + 0.01f, defaults) >= rockRoughnessScale(r, defaults);
|
||||
}
|
||||
check(monotone, "Facteur de taille : monotone croissant en rugosite");
|
||||
check(defaults.stoneSizeCap < defaults.collideMinScale,
|
||||
"Plafond des rochers moyens SOUS le seuil de collision (pas de faux bloc traversable)");
|
||||
}
|
||||
|
||||
// --- Rochers moyens : taille = base x facteur, bornee, deterministe -------
|
||||
{
|
||||
RoughSlope rougher(0.72f, 1.50f);
|
||||
Rocks onRough(rough, &bare, 1000.0f), onRougher(rougher, &bare, 1000.0f),
|
||||
again(rougher, &bare, 1000.0f);
|
||||
std::vector<float> s1, s2;
|
||||
bool law = true, capped = true, same = true;
|
||||
uint32_t boulderScaleOk = 0, boulders = 0;
|
||||
const auto inspect = [&](const Rocks& rocks, std::vector<float>& out) {
|
||||
for (int32_t cz = -6; cz <= 6; ++cz) {
|
||||
for (int32_t cx = -6; cx <= 6; ++cx) {
|
||||
for (const RockInstance& r : rocks.blockCellRocks(cx, cz)) {
|
||||
if (r.kind == RockKind::Boulder) {
|
||||
++boulders;
|
||||
boulderScaleOk += (r.scale >= defaults.boulderSizeMin - 1e-4f &&
|
||||
r.scale <= defaults.boulderSizeMax + 1e-4f) ? 1u : 0u;
|
||||
continue;
|
||||
}
|
||||
out.push_back(r.scale);
|
||||
capped = capped && r.scale <= defaults.stoneSizeCap + 1e-6f &&
|
||||
r.scale >= defaults.stoneSizeMin * defaults.roughScaleMin - 1e-4f;
|
||||
const float k = rockRoughnessScale(rocks.roughnessAt(r.position.x, r.position.z), defaults);
|
||||
if (r.scale < defaults.stoneSizeCap - 1e-4f) {
|
||||
// Hors plafond, l'echelle divisee par le facteur retombe dans la plage de base.
|
||||
const float base = r.scale / k;
|
||||
law = law && base >= defaults.stoneSizeMin - 1e-3f && base <= defaults.stoneSizeMax + 1e-3f;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
inspect(onRough, s1);
|
||||
inspect(onRougher, s2);
|
||||
for (int32_t cz = -6; cz <= 6 && same; ++cz) {
|
||||
for (int32_t cx = -6; cx <= 6 && same; ++cx) {
|
||||
const auto a = onRougher.blockCellRocks(cx, cz), b = again.blockCellRocks(cx, cz);
|
||||
same = a.size() == b.size();
|
||||
for (std::size_t i = 0; same && i < a.size(); ++i) { same = a[i].scale == b[i].scale; }
|
||||
}
|
||||
}
|
||||
std::sort(s1.begin(), s1.end());
|
||||
std::sort(s2.begin(), s2.end());
|
||||
const float m1 = s1.empty() ? 0.0f : s1[s1.size() / 2];
|
||||
const float m2 = s2.empty() ? 0.0f : s2[s2.size() / 2];
|
||||
std::printf(" (rochers moyens : rugosite %.3f -> mediane %.2f (%zu) ; rugosite %.3f -> mediane %.2f (%zu))\n",
|
||||
onRough.roughnessAt(5.5f, 5.5f), m1, s1.size(), onRougher.roughnessAt(5.5f, 5.5f), m2, s2.size());
|
||||
check(!s1.empty() && !s2.empty(), "Rochers moyens presents sur les deux versants");
|
||||
check(law, "Rochers moyens : echelle = base [0,6 ; 1,4] x facteur de rugosite");
|
||||
check(capped, "Rochers moyens : echelle dans [0,48 ; stoneSizeCap]");
|
||||
check(m2 > 1.2f * m1, "Rochers moyens : plus gros sur le versant plus rugueux");
|
||||
check(same, "Rochers moyens : taille deterministe (meme graine -> meme echelle au bit pres)");
|
||||
check(boulders > 0 && boulderScaleOk == boulders,
|
||||
"Gros blocs : loi de taille de la Phase 29 inchangee (1,1-2,6, independante de la rugosite)");
|
||||
}
|
||||
|
||||
// Composantes d'un mesh de rochers : sommets relies par un triangle ou qui
|
||||
// partagent une position exacte (un caillou = une composante).
|
||||
const auto rockParts = [](const MeshData& mesh) {
|
||||
const std::size_t n = mesh.vertices.size();
|
||||
std::vector<std::size_t> parent(n);
|
||||
for (std::size_t i = 0; i < n; ++i) { parent[i] = i; }
|
||||
const auto root = [&](std::size_t i) {
|
||||
while (parent[i] != i) { i = parent[i] = parent[parent[i]]; }
|
||||
return i;
|
||||
};
|
||||
for (std::size_t t = 0; t + 2 < mesh.indices.size(); t += 3) {
|
||||
parent[root(mesh.indices[t + 1])] = root(mesh.indices[t]);
|
||||
parent[root(mesh.indices[t + 2])] = root(mesh.indices[t]);
|
||||
}
|
||||
for (std::size_t i = 0; i < n; ++i) {
|
||||
for (std::size_t j = i + 1; j < n; ++j) {
|
||||
if (mesh.vertices[i].pos == mesh.vertices[j].pos) { parent[root(j)] = root(i); }
|
||||
}
|
||||
}
|
||||
std::vector<std::size_t> part(n);
|
||||
for (std::size_t i = 0; i < n; ++i) { part[i] = root(i); }
|
||||
return part;
|
||||
};
|
||||
|
||||
// --- Meshes : cailloux plus gros, ombre de contact, pas d'eclaircissement --
|
||||
{
|
||||
checkNear(rockContactShade(0.0f, 1.0f), kRockContactShade, 1e-6f, "Ombre de contact : x0,55 au sol");
|
||||
checkNear(rockContactShade(-0.2f, 1.0f), kRockContactShade, 1e-6f, "Ombre de contact : x0,55 sous le sol");
|
||||
checkNear(rockContactShade(kRockContactHeight, 1.0f), 1.0f, 1e-6f, "Ombre de contact : x1 a 0,4 du sommet");
|
||||
checkNear(rockContactShade(0.9f, 1.0f), 1.0f, 1e-6f, "Ombre de contact : x1 au-dessus");
|
||||
const MeshData boulder = boulderMeshData();
|
||||
float lowSum = 0.0f, highSum = 0.0f;
|
||||
uint32_t lowN = 0, highN = 0;
|
||||
for (const Vertex& v : boulder.vertices) {
|
||||
const float l = v.color.r + v.color.g + v.color.b;
|
||||
if (v.pos.y >= 0.0f && v.pos.y < 0.05f) { lowSum += l; ++lowN; }
|
||||
if (v.pos.y > 0.45f) { highSum += l; ++highN; }
|
||||
}
|
||||
check(lowN > 0 && highN > 0 && lowSum / lowN < 0.75f * (highSum / highN),
|
||||
"Gros bloc : le pied est nettement plus sombre que le haut (ombre de contact)");
|
||||
// Ne PAS eclaircir : aucun sommet plus clair que le plus clair de la Phase 29
|
||||
// (calcaire 0,63 x nuance 1,04 x teinte de caillou 1,05).
|
||||
float brightest = 0.0f;
|
||||
for (const MeshData& m : { boulder, rockMeshData(), gravelMeshData() }) {
|
||||
for (const Vertex& v : m.vertices) { brightest = std::max(brightest, v.color.r); }
|
||||
}
|
||||
check(brightest <= 0.63f * 1.04f * 1.05f + 1e-4f, "Rochers : albedo jamais plus clair qu'en Phase 29");
|
||||
float boulderTop = 0.0f;
|
||||
for (const Vertex& v : boulder.vertices) {
|
||||
if (v.pos.y > 0.45f) { boulderTop = std::max(boulderTop, v.color.r); }
|
||||
}
|
||||
check(boulderTop <= 0.63f * 0.85f * 1.04f + 1e-4f, "Gros bloc : patine grise (albedo <= 0,56)");
|
||||
|
||||
const MeshData gravel = gravelMeshData();
|
||||
const std::vector<std::size_t> part = rockParts(gravel);
|
||||
std::vector<std::size_t> roots;
|
||||
std::vector<float> tops, widths;
|
||||
for (std::size_t i = 0; i < part.size(); ++i) {
|
||||
if (std::find(roots.begin(), roots.end(), part[i]) != roots.end()) { continue; }
|
||||
roots.push_back(part[i]);
|
||||
glm::vec3 lo(1e9f), hi(-1e9f);
|
||||
for (std::size_t j = 0; j < part.size(); ++j) {
|
||||
if (part[j] == part[i]) {
|
||||
lo = glm::min(lo, gravel.vertices[j].pos);
|
||||
hi = glm::max(hi, gravel.vertices[j].pos);
|
||||
}
|
||||
}
|
||||
tops.push_back(hi.y);
|
||||
widths.push_back(std::max(hi.x - lo.x, hi.z - lo.z));
|
||||
}
|
||||
std::sort(tops.begin(), tops.end());
|
||||
std::sort(widths.begin(), widths.end());
|
||||
std::printf(" (pierraille : %zu cailloux, sommet median %.3f, largeur mediane %.3f a l'echelle 1)\n",
|
||||
roots.size(), tops[tops.size() / 2], widths[widths.size() / 2]);
|
||||
check(roots.size() == 11, "Pierraille : 11 cailloux par plaque (comme en Phase 29)");
|
||||
check(tops.front() > 0.0f && tops[tops.size() / 2] >= 0.06f,
|
||||
"Pierraille : chaque caillou depasse du sol, sommet median >= 6 cm a l'echelle 1");
|
||||
check(widths[widths.size() / 2] >= 0.18f, "Pierraille : largeur mediane d'un caillou >= 18 cm a l'echelle 1");
|
||||
// Budget de triangles : MESURE (entrelacee, 4 paires, vue pierrier a 361
|
||||
// plaques) : 32 faces par caillou = +0,50 ms de drawFrame, 20 faces =
|
||||
// +0,26 ms. Ce test empeche de revenir silencieusement a la sphere
|
||||
// subdivisee : au plus 20 faces (icosaedre) par caillou.
|
||||
check(gravel.indices.size() / 3 <= 11u * 20u,
|
||||
"Pierraille : au plus 20 triangles par caillou (cout GPU mesure)");
|
||||
// Faces sortantes (icosaedre oriente par le code, pas suppose) : la
|
||||
// normale de chaque facette s'eloigne du centre de son caillou.
|
||||
std::vector<glm::vec3> centre(part.size(), glm::vec3(0.0f));
|
||||
std::vector<float> weight(part.size(), 0.0f);
|
||||
for (std::size_t i = 0; i < part.size(); ++i) {
|
||||
centre[part[i]] += gravel.vertices[i].pos;
|
||||
weight[part[i]] += 1.0f;
|
||||
}
|
||||
bool outward = true;
|
||||
for (std::size_t i = 0; i < part.size(); ++i) {
|
||||
const glm::vec3 c = centre[part[i]] / weight[part[i]];
|
||||
outward = outward && glm::dot(gravel.vertices[i].normal, gravel.vertices[i].pos - c) > -1e-4f;
|
||||
}
|
||||
check(outward, "Pierraille : facettes orientees vers l'exterieur du caillou");
|
||||
}
|
||||
|
||||
// --- Assise : aucun caillou ne flotte sur un sol qui se courbe -----------
|
||||
{
|
||||
// Versant 0,72 ondule (+/- 10 cm, periode ~3 m) : rugosite < 0,10, donc de
|
||||
// la pierraille, et un sol qui se courbe sous chaque plaque.
|
||||
class WavySlope : public HeightSampler {
|
||||
public:
|
||||
float heightAt(float x, float z) const override {
|
||||
return 1500.0f + 0.72f * x + 0.10f * std::sin(x * 1.9f) * std::cos(z * 2.3f + 0.4f);
|
||||
}
|
||||
};
|
||||
WavySlope wavy;
|
||||
Rocks rocks(wavy, &bare, 1000.0f);
|
||||
const MeshData gravel = gravelMeshData();
|
||||
const std::vector<std::size_t> part = rockParts(gravel);
|
||||
uint32_t plates = 0, pebbles = 0, floating = 0, floatingRaw = 0;
|
||||
for (int32_t cz = -10; cz <= 10 && plates < 80; ++cz) {
|
||||
for (int32_t cx = -10; cx <= 10 && plates < 80; ++cx) {
|
||||
for (const RockInstance& r : rocks.gravelCellRocks(cx, cz)) {
|
||||
++plates;
|
||||
// Meme transformation que foliage.vert : echelle, lacet, inclinaison.
|
||||
const glm::vec2 g = unpackRockGradient(r.variation);
|
||||
const glm::vec3 nrm = glm::normalize(glm::vec3(-g.x, 1.0f, -g.y));
|
||||
const glm::vec3 axis(nrm.z, 0.0f, -nrm.x);
|
||||
const float sine = glm::length(axis);
|
||||
glm::mat3 tilt(1.0f);
|
||||
if (sine > 1e-4f) {
|
||||
const glm::vec3 k = axis / sine;
|
||||
const glm::mat3 K(0.0f, k.z, -k.y, -k.z, 0.0f, k.x, k.y, -k.x, 0.0f);
|
||||
tilt = glm::mat3(nrm.y) + sine * K + (1.0f - nrm.y) * glm::outerProduct(k, k);
|
||||
}
|
||||
const float c = std::cos(r.yaw), sn = std::sin(r.yaw);
|
||||
// Temoin negatif : la meme plaque posee a y = sol exact (sans assise).
|
||||
const glm::vec3 unseated(r.position.x, wavy.heightAt(r.position.x, r.position.z), r.position.z);
|
||||
std::vector<float> partMin(part.size(), 1e9f), rawMin(part.size(), 1e9f);
|
||||
for (std::size_t i = 0; i < part.size(); ++i) {
|
||||
const glm::vec3 l = gravel.vertices[i].pos * r.scale;
|
||||
const glm::vec3 o = tilt * glm::vec3(c * l.x + sn * l.z, l.y, -sn * l.x + c * l.z);
|
||||
const glm::vec3 w = r.position + o, w0 = unseated + o;
|
||||
partMin[part[i]] = std::min(partMin[part[i]], w.y - wavy.heightAt(w.x, w.z));
|
||||
rawMin[part[i]] = std::min(rawMin[part[i]], w0.y - wavy.heightAt(w0.x, w0.z));
|
||||
}
|
||||
for (std::size_t i = 0; i < part.size(); ++i) {
|
||||
if (part[i] != i) { continue; }
|
||||
++pebbles;
|
||||
floating += partMin[i] > 0.0f ? 1u : 0u;
|
||||
floatingRaw += rawMin[i] > 0.0f ? 1u : 0u;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
std::printf(" (assise : %u plaques, %u cailloux, %u flottants ; sans assise %u ; rugosite %.3f)\n",
|
||||
plates, pebbles, floating, floatingRaw, rocks.roughnessAt(3.0f, 3.0f));
|
||||
check(floatingRaw > 0,
|
||||
"Assise : temoin negatif - sans enfoncement, des cailloux flotteraient (le test voit le defaut)");
|
||||
check(plates > 0 && pebbles == 11u * plates, "Assise : plaques de pierraille semees sur le versant ondule");
|
||||
check(floating == 0, "Assise : AUCUN caillou dont le point bas est au-dessus du sol");
|
||||
}
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// PHASE 31 (Agent 2) : DENSITE pres du joueur. Emplacements de PROXIMITE (portee
|
||||
// courte, fondu large) sous le MEME masque ; plafond d'instances par bloc ; gros
|
||||
// blocs et collision inchanges ; determinisme independant du chemin ; trainees
|
||||
// toujours lisibles dans la densite reelle.
|
||||
// ===========================================================================
|
||||
|
||||
// Parametres "Phase 30" : les memes, sans emplacement de proximite (temoin).
|
||||
RockParams phase30RockParams() {
|
||||
RockParams p;
|
||||
p.stoneNearSlots = 0;
|
||||
p.gravelNearSlots = 0;
|
||||
return p;
|
||||
}
|
||||
|
||||
void testRockNearDensity() {
|
||||
section("Phase 31 : densite des rochers pres du joueur (proximite, plafond, collision, chemin)");
|
||||
const RockParams defaults;
|
||||
ConstantMap bare(0.0f);
|
||||
RoughSlope rough(0.72f, 0.50f);
|
||||
SlopedTerrain smooth(1500.0f, 0.72f);
|
||||
|
||||
// --- Les emplacements de proximite : rochers moyens et pierraille seulement --
|
||||
{
|
||||
Rocks onRough(rough, &bare, 1000.0f), onSmooth(smooth, &bare, 1000.0f);
|
||||
uint32_t nearStones = 0, nearGravel = 0, nearBoulders = 0;
|
||||
bool sizes = true, ranges = true;
|
||||
for (int32_t cz = -8; cz <= 8; ++cz) {
|
||||
for (int32_t cx = -8; cx <= 8; ++cx) {
|
||||
for (const RockInstance& r : onRough.blockCellRocks(cx, cz)) {
|
||||
if (!r.nearSlot) { continue; }
|
||||
nearBoulders += r.kind == RockKind::Boulder ? 1u : 0u;
|
||||
nearStones += r.kind == RockKind::Stone ? 1u : 0u;
|
||||
sizes = sizes && r.scale <= defaults.stoneSizeCap + 1e-6f;
|
||||
ranges = ranges && r.maxDistance <= defaults.stoneNearDistanceFar + 1e-3f &&
|
||||
r.maxDistance >= defaults.stoneNearDistanceNear - 1e-3f;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int32_t cz = -24; cz <= 24; ++cz) {
|
||||
for (int32_t cx = -24; cx <= 24; ++cx) {
|
||||
for (const RockInstance& r : onSmooth.gravelCellRocks(cx, cz)) {
|
||||
if (!r.nearSlot) { continue; }
|
||||
++nearGravel;
|
||||
ranges = ranges && r.kind == RockKind::Gravel &&
|
||||
r.maxDistance <= defaults.gravelNearDistanceFar + 1e-3f &&
|
||||
r.maxDistance >= defaults.gravelNearDistanceNear - 1e-3f;
|
||||
}
|
||||
}
|
||||
}
|
||||
std::printf(" (proximite : %u rochers moyens (versant rugueux), %u plaques (versant lisse), %u gros blocs)\n",
|
||||
nearStones, nearGravel, nearBoulders);
|
||||
check(nearStones > 0 && nearGravel > 0, "Proximite : des rochers moyens ET des plaques sont ajoutes (effet non nul)");
|
||||
check(nearBoulders == 0, "Proximite : AUCUN gros bloc ajoute (les blocs solides ne changent pas)");
|
||||
check(sizes && defaults.stoneSizeCap < defaults.collideMinScale,
|
||||
"Proximite : rochers moyens plafonnes sous le seuil de collision (non solides)");
|
||||
check(ranges, "Proximite : portees dans [Near, Far] de proximite (portee COURTE)");
|
||||
check(defaults.stoneNearDistanceFar <= defaults.stoneDistanceNear &&
|
||||
defaults.gravelNearDistanceFar <= defaults.gravelDistanceNear,
|
||||
"Proximite : portee max sous la plus courte portee d'origine");
|
||||
// Classe toujours decidee par la rugosite : pas de pierraille sur le rugueux,
|
||||
// pas de rocher sur le lisse, proximite comprise.
|
||||
uint32_t wrong = 0;
|
||||
for (int32_t cz = -8; cz <= 8; ++cz) {
|
||||
for (int32_t cx = -8; cx <= 8; ++cx) {
|
||||
wrong += static_cast<uint32_t>(onSmooth.blockCellRocks(cx, cz).size());
|
||||
wrong += static_cast<uint32_t>(onRough.gravelCellRocks(cx, cz).size());
|
||||
}
|
||||
}
|
||||
check(wrong == 0, "Proximite : regle rugosite -> classe respectee (rien de rugueux sur le lisse ni l'inverse)");
|
||||
}
|
||||
|
||||
// --- Collision et blocs solides : IDENTIQUES au temoin sans proximite -------
|
||||
{
|
||||
Rocks rocks(rough, &bare, 1000.0f), witness(rough, &bare, 1000.0f, phase30RockParams());
|
||||
bool sameSolids = true;
|
||||
uint32_t solids = 0, bitten = 0;
|
||||
for (int32_t bz = -2; bz <= 1; ++bz) {
|
||||
for (int32_t bx = -2; bx <= 1; ++bx) {
|
||||
std::vector<RockInstance> a, b;
|
||||
for (const RockInstance& r : rocks.blockRocks(bx, bz, false)) {
|
||||
if (r.kind == RockKind::Boulder) { a.push_back(r); }
|
||||
}
|
||||
for (const RockInstance& r : witness.blockRocks(bx, bz, false)) {
|
||||
if (r.kind == RockKind::Boulder) { b.push_back(r); }
|
||||
}
|
||||
sameSolids = sameSolids && a.size() == b.size();
|
||||
for (std::size_t i = 0; sameSolids && i < a.size(); ++i) {
|
||||
sameSolids = a[i].position == b[i].position && a[i].scale == b[i].scale;
|
||||
solids += a[i].scale >= defaults.collideMinScale ? 1u : 0u;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Corps sondes sur une grille dense autour des blocs : overlaps ET resolve.
|
||||
bool sameCollision = true;
|
||||
uint32_t hits = 0;
|
||||
for (float z = -60.0f; z <= 60.0f; z += 0.73f) {
|
||||
for (float x = -60.0f; x <= 60.0f; x += 0.79f) {
|
||||
BodyCylinder body;
|
||||
const float ground = rough.heightAt(x, z);
|
||||
body.position = { x, ground + 1.7f, z };
|
||||
body.feetY = ground;
|
||||
body.headY = ground + 1.8f;
|
||||
const bool o = rocks.overlaps(body);
|
||||
hits += o ? 1u : 0u;
|
||||
sameCollision = sameCollision && o == witness.overlaps(body) &&
|
||||
rocks.resolve(body) == witness.resolve(body);
|
||||
}
|
||||
}
|
||||
(void)bitten;
|
||||
std::printf(" (blocs solides compares : %u ; corps en contact : %u)\n", solids, hits);
|
||||
check(solids > 0 && sameSolids, "Collision : ensemble des gros blocs (position, echelle) IDENTIQUE au temoin sans proximite");
|
||||
check(hits > 0 && sameCollision, "Collision : overlaps et resolve IDENTIQUES au temoin sur ~25 000 corps");
|
||||
}
|
||||
|
||||
// --- Plafond par bloc : borne, origine intacte, eclaircissement uniforme ------
|
||||
{
|
||||
RockParams tight;
|
||||
tight.gravelInstanceCap = 64u * tight.gravelSlots; // le plus bas permis : 768
|
||||
Rocks capped(smooth, &bare, 1000.0f, tight);
|
||||
uint32_t blocksBitten = 0;
|
||||
bool bounded = true, originKept = true, subset = true, spread = true;
|
||||
for (int32_t bz = -2; bz <= 1; ++bz) {
|
||||
for (int32_t bx = -2; bx <= 1; ++bx) {
|
||||
std::vector<RockInstance> origin, nearAll;
|
||||
std::vector<int32_t> nearCellOf;
|
||||
for (int32_t j = 0; j < Rocks::kBlockCells; ++j) {
|
||||
for (int32_t i = 0; i < Rocks::kBlockCells; ++i) {
|
||||
for (const RockInstance& r : capped.gravelCellRocks(bx * 8 + i, bz * 8 + j)) {
|
||||
(r.nearSlot ? nearAll : origin).push_back(r);
|
||||
if (r.nearSlot) { nearCellOf.push_back(j * 8 + i); }
|
||||
}
|
||||
}
|
||||
}
|
||||
const std::vector<RockInstance> block = capped.blockRocks(bx, bz, true);
|
||||
bounded = bounded && block.size() <= tight.gravelInstanceCap;
|
||||
uint32_t keptOrigin = 0;
|
||||
std::vector<bool> cellKept(64, false), cellHad(64, false);
|
||||
for (const int32_t c : nearCellOf) { cellHad[static_cast<std::size_t>(c)] = true; }
|
||||
for (const RockInstance& r : block) {
|
||||
if (!r.nearSlot) {
|
||||
++keptOrigin;
|
||||
continue;
|
||||
}
|
||||
bool found = false;
|
||||
for (std::size_t k = 0; k < nearAll.size() && !found; ++k) {
|
||||
if (nearAll[k].position == r.position && nearAll[k].rank == r.rank) {
|
||||
found = true;
|
||||
cellKept[static_cast<std::size_t>(nearCellOf[k])] = true;
|
||||
}
|
||||
}
|
||||
subset = subset && found;
|
||||
}
|
||||
originKept = originKept && keptOrigin == origin.size();
|
||||
if (origin.size() + nearAll.size() > tight.gravelInstanceCap) {
|
||||
++blocksBitten;
|
||||
// Eclaircissement UNIFORME : les cellules qui avaient de la
|
||||
// proximite en gardent presque toutes (pas de coupe par ordre).
|
||||
uint32_t had = 0, kept = 0;
|
||||
for (int c = 0; c < 64; ++c) {
|
||||
had += cellHad[c] ? 1u : 0u;
|
||||
kept += (cellHad[c] && cellKept[c]) ? 1u : 0u;
|
||||
}
|
||||
spread = spread && block.size() == tight.gravelInstanceCap && kept * 10u >= had * 8u;
|
||||
}
|
||||
}
|
||||
}
|
||||
std::printf(" (plafond %u par bloc : %u blocs eclaircis sur 16)\n", tight.gravelInstanceCap, blocksBitten);
|
||||
check(blocksBitten > 0, "Plafond : le cas teste le declenche bien (effet non nul)");
|
||||
check(bounded, "Plafond : jamais plus d'instances par bloc que le plafond");
|
||||
check(originKept, "Plafond : les instances d'origine ne sont JAMAIS retirees");
|
||||
check(subset, "Plafond : les instances gardees sont des candidats de proximite du bloc (au bit)");
|
||||
check(spread, "Plafond : plein exactement, eclaircissement uniforme (>= 80 % des cellules gardent de la proximite)");
|
||||
bool refused = false;
|
||||
try {
|
||||
RockParams bad;
|
||||
bad.blockInstanceCap = 64u * (bad.boulderSlots + bad.stoneSlots) - 1u;
|
||||
Rocks r(smooth, &bare, 1000.0f, bad);
|
||||
} catch (const std::exception&) {
|
||||
refused = true;
|
||||
}
|
||||
check(refused, "Plafond : un plafond sous le maximum d'origine est refuse (origine jamais tronquee)");
|
||||
}
|
||||
|
||||
// --- Determinisme : meme resultat quel que soit le chemin parcouru -------------
|
||||
{
|
||||
Rocks pathA(smooth, &bare, 1000.0f), pathB(smooth, &bare, 1000.0f);
|
||||
Rocks roughA(rough, &bare, 1000.0f), roughB(rough, &bare, 1000.0f);
|
||||
std::vector<InstanceData> b1, s1, g1, b2, s2, g2;
|
||||
const auto eyeAt = [](const HeightSampler& t, float x, float z) { return glm::vec3(x, t.heightAt(x, z) + 1.7f, z); };
|
||||
// A : arrive par l'ouest ; B : par l'est puis le nord (ordres de semis differents, purges comprises).
|
||||
for (float x = -400.0f; x <= 0.0f; x += 7.0f) {
|
||||
pathA.gather(eyeAt(smooth, x, 0.0f), permissiveFrustum(), b1, s1, g1);
|
||||
roughA.gather(eyeAt(rough, x, 0.0f), permissiveFrustum(), b1, s1, g1);
|
||||
}
|
||||
for (float x = 400.0f; x >= 0.0f; x -= 11.0f) {
|
||||
pathB.gather(eyeAt(smooth, x, 300.0f), permissiveFrustum(), b2, s2, g2);
|
||||
roughB.gather(eyeAt(rough, x, 300.0f), permissiveFrustum(), b2, s2, g2);
|
||||
}
|
||||
for (float z = 300.0f; z >= 0.0f; z -= 13.0f) {
|
||||
pathB.gather(eyeAt(smooth, 0.0f, z), permissiveFrustum(), b2, s2, g2);
|
||||
roughB.gather(eyeAt(rough, 0.0f, z), permissiveFrustum(), b2, s2, g2);
|
||||
}
|
||||
const auto same = [](const std::vector<InstanceData>& a, const std::vector<InstanceData>& b) {
|
||||
if (a.size() != b.size()) { return false; }
|
||||
for (std::size_t i = 0; i < a.size(); ++i) {
|
||||
if (a[i].position != b[i].position || a[i].scale != b[i].scale || a[i].yaw != b[i].yaw ||
|
||||
a[i].variation != b[i].variation || a[i].fade != b[i].fade) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
};
|
||||
bool identical = true;
|
||||
std::size_t gravelSeen = 0, stonesSeen = 0;
|
||||
for (int i = 0; i < 80; ++i) { // budget de semis : on laisse les deux caches se remplir
|
||||
pathA.gather(eyeAt(smooth, 0.0f, 0.0f), permissiveFrustum(), b1, s1, g1);
|
||||
pathB.gather(eyeAt(smooth, 0.0f, 0.0f), permissiveFrustum(), b2, s2, g2);
|
||||
}
|
||||
identical = identical && same(b1, b2) && same(s1, s2) && same(g1, g2);
|
||||
gravelSeen = g1.size();
|
||||
for (int i = 0; i < 80; ++i) {
|
||||
roughA.gather(eyeAt(rough, 0.0f, 0.0f), permissiveFrustum(), b1, s1, g1);
|
||||
roughB.gather(eyeAt(rough, 0.0f, 0.0f), permissiveFrustum(), b2, s2, g2);
|
||||
}
|
||||
identical = identical && same(b1, b2) && same(s1, s2) && same(g1, g2);
|
||||
stonesSeen = s1.size();
|
||||
// Blocs construits dans deux ordres differents : contenu identique au bit.
|
||||
Rocks fwd(smooth, &bare, 1000.0f), bwd(smooth, &bare, 1000.0f);
|
||||
std::vector<std::vector<RockInstance>> f, b;
|
||||
for (int32_t k = -3; k <= 3; ++k) { f.push_back(fwd.blockRocks(k, -k, true)); }
|
||||
for (int32_t k = 3; k >= -3; --k) { b.insert(b.begin(), bwd.blockRocks(k, -k, true)); }
|
||||
bool sameBlocks = f.size() == b.size();
|
||||
for (std::size_t i = 0; sameBlocks && i < f.size(); ++i) {
|
||||
sameBlocks = f[i].size() == b[i].size();
|
||||
for (std::size_t j = 0; sameBlocks && j < f[i].size(); ++j) {
|
||||
sameBlocks = f[i][j].position == b[i][j].position && f[i][j].scale == b[i][j].scale &&
|
||||
f[i][j].rank == b[i][j].rank && f[i][j].nearSlot == b[i][j].nearSlot;
|
||||
}
|
||||
}
|
||||
std::printf(" (chemins differents, meme oeil : %zu plaques, %zu rochers dessines)\n", gravelSeen, stonesSeen);
|
||||
check(gravelSeen > 0 && stonesSeen > 0 && identical,
|
||||
"Determinisme : deux chemins differents -> MEMES instances dessinees au meme point, au bit");
|
||||
check(sameBlocks, "Determinisme : un bloc ne depend pas de l'ordre dans lequel les blocs sont semes");
|
||||
}
|
||||
|
||||
// --- LOD : la densite ajoutee s'eteint avec la distance, fondu sans saut -------
|
||||
{
|
||||
Rocks rocks(smooth, &bare, 1000.0f), witness(smooth, &bare, 1000.0f, phase30RockParams());
|
||||
std::vector<InstanceData> b, s, g, wb, ws, wg;
|
||||
const glm::vec3 eye(0.0f, smooth.heightAt(0.0f, 0.0f) + 1.7f, 0.0f);
|
||||
for (int i = 0; i < 80; ++i) {
|
||||
rocks.gather(eye, permissiveFrustum(), b, s, g);
|
||||
witness.gather(eye, permissiveFrustum(), wb, ws, wg);
|
||||
}
|
||||
const auto band = [&](const std::vector<InstanceData>& v, float lo, float hi) {
|
||||
uint32_t n = 0;
|
||||
for (const InstanceData& in : v) {
|
||||
const float d = glm::length(in.position - eye);
|
||||
n += (d >= lo && d < hi) ? 1u : 0u;
|
||||
}
|
||||
return n;
|
||||
};
|
||||
const uint32_t near0 = band(g, 0.0f, 12.0f), wnear0 = band(wg, 0.0f, 12.0f);
|
||||
const uint32_t far0 = band(g, defaults.gravelNearDistanceFar + 0.5f, 1e9f);
|
||||
const uint32_t wfar0 = band(wg, defaults.gravelNearDistanceFar + 0.5f, 1e9f);
|
||||
std::printf(" (plaques a < 12 m : %u contre %u sans proximite ; au-dela de %.0f m : %u contre %u)\n", near0, wnear0,
|
||||
defaults.gravelNearDistanceFar, far0, wfar0);
|
||||
check(near0 >= 2u * wnear0 && wnear0 > 0, "LOD : densite de plaques au moins doublee a < 12 m");
|
||||
check(far0 == wfar0, "LOD : au-dela de la portee de proximite, EXACTEMENT les instances d'origine (aucun surcout lointain)");
|
||||
// Fondu : continu (pas de saut a la limite), et enfonce la plaque qui rapetisse.
|
||||
bool fadeOk = true;
|
||||
for (const InstanceData& in : g) {
|
||||
fadeOk = fadeOk && in.fade >= 0.0f && in.fade <= 1.0f;
|
||||
}
|
||||
check(fadeOk, "LOD : attenuation dans [0,1]");
|
||||
checkNear(rockFadeSink(RockKind::Gravel, 1.2f, 1.0f), 0.0f, 1e-9f, "Fondu : aucun enfoncement a pleine echelle (assise inchangee)");
|
||||
check(rockFadeSink(RockKind::Gravel, 1.0f, 0.3f) > rockFadeSink(RockKind::Gravel, 1.0f, 0.6f) &&
|
||||
rockFadeSink(RockKind::Stone, 1.0f, 0.3f) == 0.0f && rockFadeSink(RockKind::Boulder, 1.0f, 0.3f) == 0.0f,
|
||||
"Fondu : la plaque s'enfonce en rapetissant ; blocs et rochers inchanges");
|
||||
// Pas de pop : une instance de proximite, vue par gather depuis un oeil place
|
||||
// juste EN DECA de sa portee, est presque nulle ; juste au-dela, absente ;
|
||||
// a mi-portee, entiere. Mesure sur le code, pas recalculee ici.
|
||||
RockInstance target;
|
||||
bool haveTarget = false;
|
||||
// Cherchee APRES le plafond (blockRocks) : c'est ce que gather lit.
|
||||
for (const RockInstance& r : rocks.blockRocks(0, 0, true)) {
|
||||
if (r.nearSlot && r.maxDistance > 20.0f) { target = r; haveTarget = true; break; }
|
||||
}
|
||||
const auto fadeSeenAt = [&](float fraction) {
|
||||
Rocks fresh(smooth, &bare, 1000.0f);
|
||||
const glm::vec3 eyeAt = target.position + glm::vec3(0.0f, 0.0f, fraction * target.maxDistance);
|
||||
std::vector<InstanceData> bb, ss, gg;
|
||||
for (int i = 0; i < 40; ++i) { fresh.gather(eyeAt, permissiveFrustum(), bb, ss, gg); }
|
||||
for (const InstanceData& in : gg) {
|
||||
if (in.position.x == target.position.x && in.position.z == target.position.z) { return in.fade; }
|
||||
}
|
||||
return -1.0f; // non dessinee
|
||||
};
|
||||
const float atHalf = fadeSeenAt(0.5f), atEdge = fadeSeenAt(0.995f), beyond = fadeSeenAt(1.005f);
|
||||
std::printf(" (fondu d'une plaque de proximite (portee %.1f m) : %.3f a mi-portee, %.3f a 99,5 %%, %s au-dela)\n",
|
||||
target.maxDistance, atHalf, atEdge, beyond < 0.0f ? "absente" : "PRESENTE");
|
||||
check(haveTarget && atHalf == 1.0f && atEdge >= 0.0f && atEdge < 0.02f && beyond < 0.0f,
|
||||
"Fondu : entiere a mi-portee, presque nulle a la limite, absente au-dela (pas de pop)");
|
||||
}
|
||||
|
||||
// --- Pose : aucun caillou ne flotte, a pleine echelle ET pendant le fondu --------
|
||||
{
|
||||
class WavySlope : public HeightSampler {
|
||||
public:
|
||||
float heightAt(float x, float z) const override {
|
||||
return 1500.0f + 0.72f * x + 0.10f * std::sin(x * 1.9f) * std::cos(z * 2.3f + 0.4f);
|
||||
}
|
||||
};
|
||||
WavySlope wavy;
|
||||
Rocks rocks(wavy, &bare, 1000.0f);
|
||||
const MeshData gravel = gravelMeshData();
|
||||
// Composantes (cailloux) : sommets relies par un triangle ou de meme position.
|
||||
const std::size_t nv = gravel.vertices.size();
|
||||
std::vector<std::size_t> part(nv);
|
||||
for (std::size_t i = 0; i < nv; ++i) { part[i] = i; }
|
||||
const auto root = [&](std::size_t i) {
|
||||
while (part[i] != i) { i = part[i] = part[part[i]]; }
|
||||
return i;
|
||||
};
|
||||
for (std::size_t t = 0; t + 2 < gravel.indices.size(); t += 3) {
|
||||
part[root(gravel.indices[t + 1])] = root(gravel.indices[t]);
|
||||
part[root(gravel.indices[t + 2])] = root(gravel.indices[t]);
|
||||
}
|
||||
for (std::size_t i = 0; i < nv; ++i) {
|
||||
for (std::size_t j = i + 1; j < nv; ++j) {
|
||||
if (gravel.vertices[i].pos == gravel.vertices[j].pos) { part[root(j)] = root(i); }
|
||||
}
|
||||
}
|
||||
for (std::size_t i = 0; i < nv; ++i) { part[i] = root(i); }
|
||||
uint32_t nearPlates = 0, floating = 0, checks = 0;
|
||||
for (int32_t cz = -6; cz <= 6; ++cz) {
|
||||
for (int32_t cx = -6; cx <= 6; ++cx) {
|
||||
for (const RockInstance& r : rocks.gravelCellRocks(cx, cz)) {
|
||||
if (!r.nearSlot) { continue; }
|
||||
++nearPlates;
|
||||
const glm::vec2 g = unpackRockGradient(r.variation);
|
||||
const glm::vec3 nrm = glm::normalize(glm::vec3(-g.x, 1.0f, -g.y));
|
||||
const glm::vec3 axis(nrm.z, 0.0f, -nrm.x);
|
||||
const float sine = glm::length(axis);
|
||||
glm::mat3 tilt(1.0f);
|
||||
if (sine > 1e-4f) {
|
||||
const glm::vec3 k = axis / sine;
|
||||
const glm::mat3 K(0.0f, k.z, -k.y, -k.z, 0.0f, k.x, k.y, -k.x, 0.0f);
|
||||
tilt = glm::mat3(nrm.y) + sine * K + (1.0f - nrm.y) * glm::outerProduct(k, k);
|
||||
}
|
||||
const float c = std::cos(r.yaw), sn = std::sin(r.yaw);
|
||||
for (const float fade : { 1.0f, 0.6f, 0.3f }) {
|
||||
const glm::vec3 base = r.position - glm::vec3(0.0f, rockFadeSink(r.kind, r.scale, fade), 0.0f);
|
||||
// Chaque CAILLOU doit avoir son point bas sous le sol.
|
||||
std::vector<float> lo(nv, 1e9f);
|
||||
for (std::size_t i = 0; i < nv; ++i) {
|
||||
const glm::vec3 l = gravel.vertices[i].pos * (r.scale * fade);
|
||||
const glm::vec3 w = base + tilt * glm::vec3(c * l.x + sn * l.z, l.y, -sn * l.x + c * l.z);
|
||||
lo[part[i]] = std::min(lo[part[i]], w.y - wavy.heightAt(w.x, w.z));
|
||||
}
|
||||
for (std::size_t i = 0; i < nv; ++i) {
|
||||
if (part[i] != i) { continue; }
|
||||
++checks;
|
||||
floating += lo[i] > 0.0f ? 1u : 0u;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
std::printf(" (pose : %u plaques de proximite, %u controles, %u flottantes)\n", nearPlates, checks, floating);
|
||||
check(nearPlates > 0 && floating == 0, "Pose : aucune plaque de proximite au-dessus du sol (pleine echelle et fondu)");
|
||||
}
|
||||
|
||||
// --- Trainees : la densite REELLE (proximite comprise) suit le bruit anisotrope --
|
||||
{
|
||||
Rocks rocks(smooth, &bare, 1000.0f);
|
||||
constexpr int N = 40; // 40 x 40 cellules de 8 m = 320 m
|
||||
std::vector<float> count(N * N, 0.0f), streak(N * N, 0.0f);
|
||||
for (int j = 0; j < N; ++j) {
|
||||
for (int i = 0; i < N; ++i) {
|
||||
const int32_t cx = i - N / 2, cz = j - N / 2;
|
||||
count[j * N + i] = static_cast<float>(rocks.gravelCellRocks(cx, cz).size());
|
||||
streak[j * N + i] = rocks.streakDensityAt((cx + 0.5f) * defaults.gravelCell, (cz + 0.5f) * defaults.gravelCell);
|
||||
}
|
||||
}
|
||||
double along = 0.0, across = 0.0, mc = 0.0, ms = 0.0;
|
||||
for (int j = 0; j < N; ++j) {
|
||||
for (int i = 0; i + 1 < N; ++i) {
|
||||
along += std::abs(count[j * N + i + 1] - count[j * N + i]); // le long de la pente (x)
|
||||
across += std::abs(count[(i + 1) * N + j] - count[i * N + j]); // en travers (z)
|
||||
}
|
||||
}
|
||||
for (int k = 0; k < N * N; ++k) { mc += count[k]; ms += streak[k]; }
|
||||
mc /= N * N; ms /= N * N;
|
||||
double cov = 0.0, vc = 0.0, vs = 0.0;
|
||||
for (int k = 0; k < N * N; ++k) {
|
||||
cov += (count[k] - mc) * (streak[k] - ms);
|
||||
vc += (count[k] - mc) * (count[k] - mc);
|
||||
vs += (streak[k] - ms) * (streak[k] - ms);
|
||||
}
|
||||
const double corr = cov / std::sqrt(std::max(vc * vs, 1e-12));
|
||||
// CONTRASTE : la correlation et l'anisotropie ne voient pas une densite
|
||||
// ajoutee UNIFORMEMENT (une constante ne change ni l'une ni l'autre ; temoin
|
||||
// negatif fait, build-phase31\agent2\journaux). On exige donc que les zones
|
||||
// de trainee faible restent nettement plus clairsemees que les fortes, et
|
||||
// qu'AUCUNE instance ne soit la ou la trainee est nulle.
|
||||
double lowSum = 0.0, highSum = 0.0;
|
||||
uint32_t lowN = 0, highN = 0, onZero = 0, all = 0;
|
||||
for (int k = 0; k < N * N; ++k) {
|
||||
if (streak[k] <= 0.25f) { lowSum += count[k]; ++lowN; }
|
||||
if (streak[k] >= 0.75f) { highSum += count[k]; ++highN; }
|
||||
}
|
||||
for (int j = 0; j < N; ++j) {
|
||||
for (int i = 0; i < N; ++i) {
|
||||
for (const RockInstance& r : rocks.gravelCellRocks(i - N / 2, j - N / 2)) {
|
||||
++all;
|
||||
onZero += rocks.streakDensityAt(r.position.x, r.position.z) <= 0.0f ? 1u : 0u;
|
||||
}
|
||||
}
|
||||
}
|
||||
const double contrast = (lowN && highN && lowSum > 0.0) ? (highSum / highN) / (lowSum / lowN) : 0.0;
|
||||
std::printf(" (densite reelle : variation le long %.0f, en travers %.0f ; correlation avec la trainee %.2f ; %.1f plaques/cellule ;"
|
||||
" contraste fort/faible %.1f (%u/%u cellules) ; %u instances sur trainee nulle)\n",
|
||||
along, across, corr, mc, contrast, highN, lowN, onZero);
|
||||
check(across > 1.5 * along, "Trainees : la densite REELLE (proximite comprise) reste allongee dans le sens de la pente");
|
||||
check(corr > 0.8, "Trainees : la densite reelle suit le bruit des trainees (pas un bruit blanc)");
|
||||
check(contrast >= 3.0, "Trainees : contraste de densite >= 3 entre trainee forte et faible (proximite comprise)");
|
||||
check(all > 0 && onZero == 0, "Trainees : aucune instance (proximite comprise) la ou la trainee est nulle");
|
||||
}
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// PHASE 29 (Agent 3) : buissons et petits arbres (classe 3 LiDAR)
|
||||
// ===========================================================================
|
||||
@@ -10159,6 +10931,10 @@ int main() {
|
||||
// PHASE 29 (Agent 2) : rochers et pierriers
|
||||
testRockMeshes();
|
||||
testRockPlacement();
|
||||
// PHASE 30 (Agent B) : rochers lisibles
|
||||
testRockReadability();
|
||||
// PHASE 31 (Agent 2) : densite pres du joueur
|
||||
testRockNearDensity();
|
||||
// PHASE 29 (Agent 3) : buissons et petits arbres
|
||||
testBushMeshes();
|
||||
testBushPlacement();
|
||||
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur