Fusionne github/ccr-8fe70239-2xoxym (session cloud du 13-14/10) dans les phases 30-31 faites sur le PC (rochers visibles, builds separes, densite des rochers, demo candidate). La phase cloud, nommee "Phase 30" dans ses commits, devient la Phase 32 : - NOTES-PHASE30.md (add/add) : la version du PC (rochers) est gardee ; celle du cloud devient NOTES-PHASE32.md. - MEMORY.md : sections 30 (rochers), 31, puis 32 (optimisation) dans l'ordre chronologique ; etat verifie en tete renomme fin de Phase 32. - References a l'optimisation renommees Phase 32 dans README.md, NOTES-AUDIT-GLOBAL.md, les commentaires du code et les libelles de tests. Les references aux rochers (Phase 30 PC) sont inchangees. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
134 lignes
6.4 KiB
C++
134 lignes
6.4 KiB
C++
#pragma once
|
|
|
|
#include "renderer/InstanceData.hpp"
|
|
|
|
#include <glm/glm.hpp>
|
|
|
|
#include <cstdint>
|
|
|
|
namespace vercora {
|
|
|
|
// Identifie une geometrie enregistree aupres du Renderer (Renderer::addMesh).
|
|
// C'est un simple indice : le Renderer possede les Mesh, l'appelant ne manipule
|
|
// que des poignees, ce qui evite d'exposer Vulkan au code de gameplay.
|
|
using MeshHandle = uint32_t;
|
|
|
|
inline constexpr MeshHandle kInvalidMesh = static_cast<MeshHandle>(-1);
|
|
|
|
// Quel couple de shaders utiliser pour dessiner un objet.
|
|
// Volontairement un enum ferme et non un ShaderSet libre : le Renderer cree UN
|
|
// pipeline par valeur, et trie les draws par materiau pour limiter les
|
|
// changements de pipeline. Ajouter un materiau = ajouter une valeur ici et sa
|
|
// paire de shaders dans kMaterialShaders.
|
|
enum class Material : uint32_t {
|
|
// Couleur de sommet + Blinn-Phong (Phase 2). Cube, meshes .obj, arbres.
|
|
Object = 0,
|
|
// Coloration par altitude et par pente (Phase 4). Reserve au terrain.
|
|
Terrain = 1,
|
|
// PHASE 11. Vegetation INSTANCIEE : arbres de decor et touffes d'herbe.
|
|
// Un seul materiau pour les deux, et non deux : ils partagent exactement le
|
|
// meme besoin (une geometrie, N transformations reduites, un eclairage
|
|
// Blinn-Phong). Ce qui les distingue - l'ondulation, la teinte, la portee -
|
|
// tient dans le maillage et dans les push constants, pas dans le pipeline.
|
|
Foliage = 2,
|
|
};
|
|
|
|
inline constexpr uint32_t kMaterialCount = 3;
|
|
|
|
// Une instance a dessiner : une geometrie, une transformation, un materiau.
|
|
//
|
|
// La model matrix voyage par PUSH CONSTANT (et non plus par l'UBO comme en
|
|
// Phases 1 a 4) : elle change d'un objet a l'autre a l'interieur d'une meme
|
|
// frame, alors que l'UBO est ecrit une seule fois par frame. 64 octets, donc
|
|
// tres en dessous des 128 garantis par la spec Vulkan pour maxPushConstantsSize.
|
|
//
|
|
// CONTRAINTE : la partie lineaire de `model` doit rester une rotation
|
|
// eventuellement suivie d'une echelle UNIFORME. Le vertex shader utilise
|
|
// mat3(model) comme normal matrix, ce qui n'est exact que dans ce cas (une
|
|
// echelle uniforme ne change que la longueur de la normale, absorbee par le
|
|
// normalize() du fragment shader). Une echelle non uniforme imposerait de
|
|
// calculer transpose(inverse(mat3(model))) cote CPU et de la pousser en plus.
|
|
struct DrawItem {
|
|
MeshHandle mesh = kInvalidMesh;
|
|
glm::mat4 model{1.0f};
|
|
Material material = Material::Object;
|
|
|
|
// Parametres libres pousses au vertex shader a cote de la model matrix.
|
|
//
|
|
// ATTENTION : leur signification depend du MATERIAU. C'est le meme bloc de
|
|
// push constants pour tous les pipelines - c'est ce qui permet a un seul
|
|
// pipeline layout de les servir tous - mais chaque paire de shaders
|
|
// l'interprete a sa facon. Deux conventions coexistent aujourd'hui :
|
|
//
|
|
// Material::Terrain (PHASE 10, shaders/terrain.vert)
|
|
// x = debut de la bande de geomorphing, y = fin, en unites monde
|
|
// (metres) mesurees depuis la camera ; zw reserves.
|
|
// Une bande VIDE (y <= x, le defaut) desactive le morphing. C'est ce qui
|
|
// permet a toute geometrie qui n'est pas une tuile de quadtree - cube,
|
|
// arbres, terrain d'un seul bloc en --no-lod - de traverser le meme
|
|
// pipeline sans rien changer.
|
|
//
|
|
// Material::Object (PHASE 15, shaders/cube.vert et cube.frag)
|
|
// x = force de la teinte de temoin de l'editeur, 0 = aucune ;
|
|
// yzw = couleur de cette teinte.
|
|
// Sert a distinguer le fantome de pose et l'objet selectionne du meme
|
|
// modele pose normalement, SANS transparence donc sans tri en
|
|
// profondeur. Une force nulle - le cas de tous les DrawItem du jeu -
|
|
// laisse le rendu strictement identique a celui d'avant la Phase 15.
|
|
glm::vec4 params{0.0f, 0.0f, 0.0f, 0.0f};
|
|
|
|
// PHASE 32, Material::Terrain seulement : ou se trouve le maillage dans la
|
|
// grille de la heightmap, pour que terrain.vert y retrouve la position
|
|
// horizontale et l'UV de chaque sommet a partir de gl_VertexIndex au lieu
|
|
// de les lire dans le buffer (voir renderer/GpuVertex.hpp, TerrainVertex).
|
|
// x, y = indices de grille (ix, iz) du premier sommet
|
|
// z = pas, en echantillons de grille, entre deux sommets voisins
|
|
// w = sommets par rangee
|
|
// Une tuile de quadtree pousse (node.ix0, node.iz0, node.stride, 65) ; le
|
|
// terrain d'un seul bloc (--no-lod) pousse (0, 0, 1, resolution).
|
|
// Ignore par les autres materiaux.
|
|
glm::ivec4 grid{0, 0, 1, 1};
|
|
};
|
|
|
|
// Ce que le Renderer pousse REELLEMENT en push constant, dans cet ordre.
|
|
// Duplique volontairement les deux membres correspondants de DrawItem : ce type
|
|
// decrit le bloc `push_constant` des shaders (donc un layout impose de
|
|
// l'exterieur), la ou DrawItem decrit une intention de rendu cote gameplay. Les
|
|
// melanger obligerait a garder `mesh` et `material` - inutiles au GPU - dans un
|
|
// budget de push constants qui ne fait que 128 octets garantis.
|
|
//
|
|
// 96 octets depuis la Phase 32 (le bloc `grid` du terrain) : toujours en
|
|
// dessous des 128 garantis par la spec Vulkan pour maxPushConstantsSize.
|
|
struct DrawItemPush {
|
|
glm::mat4 model{1.0f};
|
|
glm::vec4 params{0.0f, 0.0f, 0.0f, 0.0f};
|
|
glm::ivec4 grid{0, 0, 1, 1};
|
|
};
|
|
static_assert(sizeof(DrawItemPush) == 96 && sizeof(DrawItemPush) <= 128,
|
|
"Le bloc de push constants doit tenir dans les 128 octets garantis.");
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// PHASE 11 : dessin INSTANCIE
|
|
// ---------------------------------------------------------------------------
|
|
// Une geometrie dessinee N fois en un seul appel, chaque exemplaire lisant sa
|
|
// transformation dans un tableau d'InstanceData (voir InstanceData.hpp).
|
|
//
|
|
// Les instances ne sont PAS possedees ici : le pointeur doit rester valide
|
|
// jusqu'au retour de drawFrame, qui les recopie dans un buffer de la frame. Ce
|
|
// choix evite une allocation par frame et par especes de vegetation, alors que
|
|
// l'appelant, lui, produit deja ses instances dans un vecteur qu'il reutilise.
|
|
struct InstancedDrawItem {
|
|
MeshHandle mesh = kInvalidMesh;
|
|
const InstanceData* instances = nullptr;
|
|
uint32_t count = 0;
|
|
Material material = Material::Foliage;
|
|
|
|
// Pousses au vertex shader comme pour un DrawItem.
|
|
// PHASE 11 : x = amplitude d'ondulation en metres (0 pour un arbre),
|
|
// y = temps en secondes, z = distance de rendu (pour information du shader),
|
|
// w = reserve.
|
|
glm::vec4 params{0.0f, 0.0f, 0.0f, 0.0f};
|
|
};
|
|
|
|
} // namespace vercora
|