Fichiers
vercora/src/renderer/VulkanContext.hpp
T
Claude 16775bf1ff Phase 30 (1/n) : build Linux, banc de mesure des ressources, plan
- Portabilite GCC/Clang : les constructeurs a argument par defaut `= {}`
  sur une struct imbriquee (Heightmap, TerrainQuadtree, TerrainStreamer)
  deviennent des surcharges qui deleguent (CWG 1397, refuse hors MSVC).
  GLFW_INCLUDE_NONE evite d'exiger <GL/gl.h> sous Linux.
- Comptabilite de la memoire GPU : toute allocation passe par
  VulkanContext::allocateMemory / freeMemory (octets vivants, pics, blocs,
  appels vkAllocateMemory). RAM du processus lue au systeme
  (core/ProcessMemory). Bilan "Ressources (PHASE 30)" au chargement,
  toutes les 10 s et en fin de partie.
- Outils de banc : --quit-after=S (fermeture propre), --freeze-anim
  (images comparables au pixel), tools/make_bench_zone.py (zone proxy
  5001x5001 a la vraie echelle quand les donnees LiDAR sont absentes).
- NOTES-PHASE30.md : mesure de reference, revue du noyau Vulkan, plan.

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

172 lignes
7.4 KiB
C++

#pragma once
#include <vulkan/vulkan.h>
#include <optional>
#include <string>
#include <vector>
namespace vercora {
class Window;
// Indices des familles de queues dont on a besoin.
struct QueueFamilyIndices {
std::optional<uint32_t> graphicsFamily;
std::optional<uint32_t> presentFamily;
// PHASE 12. Famille de transfert DEDIEE, c'est-a-dire une famille qui expose
// VK_QUEUE_TRANSFER_BIT sans VK_QUEUE_GRAPHICS_BIT. Renseignee seulement si
// le GPU en propose une : elle est OPTIONNELLE en Vulkan, et beaucoup de GPU
// integres n'exposent qu'une seule famille universelle.
//
// Elle n'est PAS utilisee pour les transferts du streaming (voir la note
// d'architecture dans NOTES-PHASE12.md et Renderer::enqueueCopy) : elle est
// detectee et journalisee parce que c'est cette detection qui justifie le
// choix fait, et parce qu'un futur portage sur GPU discret voudra la
// relire. Utiliser une famille differente pour ecrire un buffer puis le lire
// au rendu impose un TRANSFERT DE PROPRIETE de famille (barriere de release
// puis d'acquire) : du code qu'on ne peut pas eprouver sur une machine qui
// n'a qu'une famille, donc du code qu'on n'ecrit pas.
std::optional<uint32_t> dedicatedTransferFamily;
bool isComplete() const {
return graphicsFamily.has_value() && presentFamily.has_value();
}
};
// Capacites de la surface pour la construction de la swapchain.
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities{};
std::vector<VkSurfaceFormatKHR> formats;
std::vector<VkPresentModeKHR> presentModes;
};
// PHASE 30. Un bloc de memoire GPU, avec ce qu'il faut savoir pour le rendre
// et pour le COMPTER. Toute la memoire du moteur passe par
// VulkanContext::allocateMemory / freeMemory : c'est ce qui permet au journal
// de donner l'occupation GPU exacte, au lieu de la deduire de formules
// recopiees dans chaque classe (et dont une seule serait mise a jour).
struct GpuAllocation {
VkDeviceMemory memory = VK_NULL_HANDLE;
VkDeviceSize size = 0; // octets REELLEMENT alloues (memory requirements)
bool deviceLocal = false; // DEVICE_LOCAL demande par l'appelant
void* mapped = nullptr; // mappage persistant, si demande
};
// PHASE 30. Bilan de la memoire GPU allouee par le moteur. Les pics sont ceux
// de la session ; "appels" compte tous les vkAllocateMemory depuis le
// demarrage, y compris ceux deja liberes - c'est le chiffre qui dit combien de
// fois le pilote a ete sollicite, pas seulement combien de blocs vivent.
struct GpuMemoryStats {
uint64_t liveBytes = 0;
uint64_t peakBytes = 0;
uint64_t liveDeviceLocalBytes = 0;
uint64_t peakDeviceLocalBytes = 0;
uint64_t liveAllocations = 0;
uint64_t peakAllocations = 0;
uint64_t allocateCalls = 0;
};
// Regroupe l'etat "global" Vulkan qui ne change pas au resize :
// instance, debug messenger, surface, GPU physique, device logique, queues.
class VulkanContext {
public:
explicit VulkanContext(Window& window);
~VulkanContext();
VulkanContext(const VulkanContext&) = delete;
VulkanContext& operator=(const VulkanContext&) = delete;
VkInstance instance() const { return instance_; }
VkSurfaceKHR surface() const { return surface_; }
VkPhysicalDevice physicalDevice() const { return physicalDevice_; }
VkDevice device() const { return device_; }
VkQueue graphicsQueue() const { return graphicsQueue_; }
VkQueue presentQueue() const { return presentQueue_; }
const QueueFamilyIndices& queueFamilies() const { return queueIndices_; }
// PHASE 11. true si samplerAnisotropy a ete ACTIVEE sur le device logique.
// Un echantillonneur ne peut demander l'anisotropie que dans ce cas : la
// demander sans l'avoir activee est une erreur de validation immediate. La
// feature est optionnelle en Vulkan, donc le moteur s'en passe si le GPU ne
// la propose pas (le terrain est alors plus flou en vue rasante, rien de
// plus).
bool anisotropyEnabled() const { return anisotropyEnabled_; }
// (Re)interroge le support swapchain du GPU choisi. Appele au (re)build de
// la swapchain, car les capacites (extent courant) peuvent avoir change.
SwapChainSupportDetails querySwapChainSupport() const;
// Trouve un type de memoire satisfaisant a la fois un filtre (bits issus des
// memory requirements) et un jeu de proprietes (host-visible, device-local...).
uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) const;
// Premier format de la liste supporte par le GPU pour un tiling/feature donne.
VkFormat findSupportedFormat(const std::vector<VkFormat>& candidates,
VkImageTiling tiling,
VkFormatFeatureFlags features) const;
// Format de profondeur retenu (D32 de preference, avec fallbacks).
VkFormat findDepthFormat() const;
// PHASE 30. Alloue un bloc satisfaisant `requirements` dans un type de
// memoire qui porte `properties`, et le COMPTE. Lance std::runtime_error si
// le pilote refuse. `map` = true mappe le bloc en permanence (le type doit
// alors etre HOST_VISIBLE).
GpuAllocation allocateMemory(const VkMemoryRequirements& requirements,
VkMemoryPropertyFlags properties, bool map = false);
// Rend le bloc (demappe s'il l'etait) et le decompte. Sans effet sur une
// allocation vide ; remet `allocation` a zero.
void freeMemory(GpuAllocation& allocation);
const GpuMemoryStats& gpuMemoryStats() const { return gpuMemory_; }
// Ligne de journal lisible du bilan ci-dessus.
std::string gpuMemoryLine() const;
// PHASE 30. true si un type de memoire est a la fois DEVICE_LOCAL et
// HOST_VISIBLE | HOST_COHERENT : memoire unifiee (GPU integre, lavapipe), ou
// le CPU peut ecrire directement la ou le GPU lit, sans staging ni copie.
// Faux sur un GPU discret classique (hors BAR redimensionnable).
bool unifiedMemory() const { return unifiedMemory_; }
private:
void createInstance();
void setupDebugMessenger();
void createSurface(Window& window);
void pickPhysicalDevice();
void createLogicalDevice();
bool isDeviceSuitable(VkPhysicalDevice device) const;
bool checkDeviceExtensionSupport(VkPhysicalDevice device) const;
QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device) const;
SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device) const;
std::vector<const char*> getRequiredInstanceExtensions() const;
bool checkValidationLayerSupport() const;
VkInstance instance_ = VK_NULL_HANDLE;
VkDebugUtilsMessengerEXT debugMessenger_ = VK_NULL_HANDLE;
VkSurfaceKHR surface_ = VK_NULL_HANDLE;
VkPhysicalDevice physicalDevice_ = VK_NULL_HANDLE;
VkDevice device_ = VK_NULL_HANDLE;
VkQueue graphicsQueue_ = VK_NULL_HANDLE;
VkQueue presentQueue_ = VK_NULL_HANDLE;
QueueFamilyIndices queueIndices_;
bool anisotropyEnabled_ = false;
bool unifiedMemory_ = false;
// Proprietes memoire du GPU, lues une fois : findMemoryType les
// interrogeait a CHAQUE allocation (deux par tuile de terrain).
VkPhysicalDeviceMemoryProperties memoryProperties_{};
GpuMemoryStats gpuMemory_;
};
} // namespace vercora