Fichiers
vercora/src/renderer/VertexFormat.hpp
T
Claude 7f2d538768 Phase 30 (2/n) : geometrie compacte, pool de sous-allocation, early-Z
- Formats GPU : le format de travail Vertex (68 o) n'est plus televerse.
  Objets et vegetation : ObjectVertex 44 o (conversion exacte). Terrain :
  TerrainVertex 16 o (deux altitudes f32 + deux normales snorm16) ; x/z,
  cible de morphing et UV sont recalcules par terrain.vert depuis
  gl_VertexIndex et DrawItem::grid, au bit pres (`precise`).
- Topologie des tuiles televersee UNE fois, en uint16 (96 Ko de moins par
  tuile). Indices des maillages d'objets en uint16.
- GpuBufferPool + RangeAllocator : toute la geometrie dans des blocs de
  4 Mo ; ecriture DIRECTE en memoire unifiee (GPU integre, lavapipe),
  staging conserve sur GPU discret (--force-staging pour l'eprouver),
  barriere ecriture-apres-lecture ajoutee devant les copies (validation
  de synchronisation a zero).
- Rendu : terrain dessine apres la vegetation (early-Z) et culling de ses
  faces arriere.
- Tests : +16 verifications (formats, positions recalculees, allocateur).

Survol 900 m/s (lavapipe) : pic GPU 286 -> 89 Mo, geometrie terrain
188 -> 33 Mo, ~17 000 -> 21 vkAllocateMemory, streaming 4,5 -> 1,6 ms
par image. Foret : 8,3 -> 12,4 images/s.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2
2026-10-13 23:08:23 +00:00

159 lignes
6.2 KiB
C++

#pragma once
#include "renderer/GpuVertex.hpp"
#include "renderer/InstanceData.hpp"
#include <vulkan/vulkan.h>
#include <array>
#include <cstddef>
namespace vercora {
// Description VULKAN du sommet : comment le lire dans le buffer, et quel attribut
// alimente quel location(...) du vertex shader.
//
// Volontairement separee de Vertex.hpp. Vertex/MeshData se presentent comme de la
// geometrie "cote CPU, independante de Vulkan", mais tant que ces deux fonctions
// vivaient dans la struct, le simple fait d'inclure MeshData.hpp tirait
// <vulkan/vulkan.h> : toute la logique de jeu (world/, core/) devenait donc
// incompilable sans le SDK Vulkan installe, alors qu'elle ne depend que de GLM.
// Ce fichier est le SEUL endroit du dossier renderer/ ou le format de sommet
// rencontre Vulkan, et seul Pipeline.cpp en a besoin.
//
// Consequence concrete : la logique de jeu se compile et se teste sans GPU (voir
// tests/logic_tests.cpp), y compris sur une machine ou le SDK n'est pas installe.
// PHASE 30 : DEUX formats de sommet, un par famille de shaders (voir
// renderer/GpuVertex.hpp) - le format de travail CPU `Vertex` n'est plus
// televerse tel quel. Un seul binding entrelace dans les deux cas.
// --- Objets et vegetation : ObjectVertex, 44 octets -------------------------
inline VkVertexInputBindingDescription objectBindingDescription() {
VkVertexInputBindingDescription binding{};
binding.binding = 0;
binding.stride = sizeof(ObjectVertex);
binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
return binding;
}
// Locations 0 a 3 : position, couleur, normale, UV - les memes que depuis la
// Phase 3, seul le stride a change (les 24 octets de morphing, qu'aucun de ces
// shaders ne lisait, ne sont plus dans le buffer).
inline std::array<VkVertexInputAttributeDescription, 4> objectAttributeDescriptions() {
std::array<VkVertexInputAttributeDescription, 4> attrs{};
attrs[0].binding = 0;
attrs[0].location = 0;
attrs[0].format = VK_FORMAT_R32G32B32_SFLOAT;
attrs[0].offset = offsetof(ObjectVertex, pos);
attrs[1].binding = 0;
attrs[1].location = 1;
attrs[1].format = VK_FORMAT_R32G32B32_SFLOAT;
attrs[1].offset = offsetof(ObjectVertex, color);
attrs[2].binding = 0;
attrs[2].location = 2;
attrs[2].format = VK_FORMAT_R32G32B32_SFLOAT;
attrs[2].offset = offsetof(ObjectVertex, normal);
// Deux composantes seulement -> format R32G32.
attrs[3].binding = 0;
attrs[3].location = 3;
attrs[3].format = VK_FORMAT_R32G32_SFLOAT;
attrs[3].offset = offsetof(ObjectVertex, uv);
return attrs;
}
// --- Terrain : TerrainVertex, 16 octets --------------------------------------
inline VkVertexInputBindingDescription terrainBindingDescription() {
VkVertexInputBindingDescription binding{};
binding.binding = 0;
binding.stride = sizeof(TerrainVertex);
binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
return binding;
}
// Deux altitudes en flottant, deux normales en snorm16 (x et z, y reconstruit
// par terrain.vert). Tout le reste se deduit de gl_VertexIndex.
inline std::array<VkVertexInputAttributeDescription, 4> terrainAttributeDescriptions() {
std::array<VkVertexInputAttributeDescription, 4> attrs{};
attrs[0].binding = 0;
attrs[0].location = 0;
attrs[0].format = VK_FORMAT_R32_SFLOAT;
attrs[0].offset = offsetof(TerrainVertex, height);
attrs[1].binding = 0;
attrs[1].location = 1;
attrs[1].format = VK_FORMAT_R32_SFLOAT;
attrs[1].offset = offsetof(TerrainVertex, morphHeight);
attrs[2].binding = 0;
attrs[2].location = 2;
attrs[2].format = VK_FORMAT_R16G16_SNORM;
attrs[2].offset = offsetof(TerrainVertex, normal);
attrs[3].binding = 0;
attrs[3].location = 3;
attrs[3].format = VK_FORMAT_R16G16_SNORM;
attrs[3].offset = offsetof(TerrainVertex, morphNormal);
return attrs;
}
// ---------------------------------------------------------------------------
// PHASE 11 : binding d'INSTANCES (binding 1)
// ---------------------------------------------------------------------------
// Second flux de sommets, cadence par INSTANCE et non par sommet. Le pipeline
// n'en est decrit que pour les materiaux instancies (ShaderSet::usesInstancing) :
// declarer un binding qu'aucun shader ne lit ferait echouer la validation, et
// surtout obligerait a lier un buffer d'instances au moment de dessiner un cube.
inline VkVertexInputBindingDescription instanceBindingDescription() {
VkVertexInputBindingDescription binding{};
binding.binding = 1;
binding.stride = sizeof(InstanceData);
binding.inputRate = VK_VERTEX_INPUT_RATE_INSTANCE;
return binding;
}
// Locations 6 a 8 : les locations basses appartiennent au sommet (voir plus haut),
// et un pipeline instancie decrit les deux flux dans le meme espace de numeros.
// Les trois flottants scalaires (scale, yaw, variation, fade) sont regroupes en
// deux attributs plutot qu'en quatre : moins d'attributs a decrire, et le shader
// les lit comme des vec2, ce qui se lit aussi bien.
inline std::array<VkVertexInputAttributeDescription, 3> instanceAttributeDescriptions() {
std::array<VkVertexInputAttributeDescription, 3> attrs{};
attrs[0].binding = 1;
attrs[0].location = 6;
attrs[0].format = VK_FORMAT_R32G32B32_SFLOAT;
attrs[0].offset = offsetof(InstanceData, position);
// scale et yaw sont contigus dans la struct : un seul vec2 les porte.
attrs[1].binding = 1;
attrs[1].location = 7;
attrs[1].format = VK_FORMAT_R32G32_SFLOAT;
attrs[1].offset = offsetof(InstanceData, scale);
// variation et fade, contigus de la meme facon.
attrs[2].binding = 1;
attrs[2].location = 8;
attrs[2].format = VK_FORMAT_R32G32_SFLOAT;
attrs[2].offset = offsetof(InstanceData, variation);
return attrs;
}
// Verifications que les regroupements ci-dessus supposent. Sans elles, un ajout
// de membre dans InstanceData decalerait silencieusement yaw ou fade.
static_assert(offsetof(InstanceData, yaw) == offsetof(InstanceData, scale) + sizeof(float),
"scale et yaw doivent rester contigus : ils sont lus comme un vec2.");
static_assert(offsetof(InstanceData, fade) == offsetof(InstanceData, variation) + sizeof(float),
"variation et fade doivent rester contigus : ils sont lus comme un vec2.");
} // namespace vercora