Premier commit

Cette révision appartient à :
Théo Gastinel a révisé 2026-10-11 01:55:43 +02:00
révision 13bc77fd6c
21 fichiers modifiés
+6169

Aucun fichier ne correspond à votre recherche

+390
Voir le fichier
@@ -0,0 +1,390 @@
pub mod device;
pub mod mesh;
pub mod pipeline;
pub mod render_pass;
pub mod swapchain;
pub mod texture;
use std::collections::HashMap;
use std::sync::Arc;
use vulkano::command_buffer::allocator::StandardCommandBufferAllocator;
use vulkano::command_buffer::{
AutoCommandBufferBuilder, CommandBufferUsage, RenderPassBeginInfo, SubpassBeginInfo,
SubpassContents,
};
use vulkano::device::{Device, Queue};
use vulkano::format::Format;
use vulkano::memory::allocator::StandardMemoryAllocator;
use vulkano::pipeline::graphics::viewport::Viewport;
use vulkano::pipeline::{GraphicsPipeline, Pipeline, PipelineBindPoint};
use vulkano::render_pass::RenderPass;
use vulkano::swapchain::{acquire_next_image, SwapchainPresentInfo};
use vulkano::sync::{self, GpuFuture};
use vulkano::{Validated, VulkanError};
use winit::raw_window_handle::HasDisplayHandle;
use winit::window::Window;
use crate::math::Mat4;
use self::device::init_device;
use self::mesh::{create_wireframe_cube_mesh, MeshBuffers};
use self::pipeline::{create_graphics_pipeline, create_line_pipeline, create_ui_pipeline, vs};
use self::render_pass::create_render_pass;
use self::swapchain::{create_swapchain_bundle, recreate_swapchain_bundle, SwapchainBundle};
use self::texture::{create_texture_atlas_bundle, VulkanTexture};
/// Le gestionnaire principal du moteur de rendu Vulkan.
pub struct VulkanRenderer {
_instance: Arc<vulkano::instance::Instance>,
device: Arc<Device>,
queue: Arc<Queue>,
render_pass: Arc<RenderPass>,
pipeline: Arc<GraphicsPipeline>,
line_pipeline: Arc<GraphicsPipeline>,
ui_pipeline: Arc<GraphicsPipeline>,
texture: VulkanTexture,
chunk_meshes: HashMap<(i32, i32), MeshBuffers>,
wireframe_mesh: MeshBuffers,
memory_allocator: Arc<StandardMemoryAllocator>,
swapchain_bundle: SwapchainBundle,
command_buffer_allocator: Arc<StandardCommandBufferAllocator>,
previous_frame_end: Option<Box<dyn GpuFuture>>,
recreate_swapchain: bool,
}
impl VulkanRenderer {
/// Initialise tous les composants Vulkan nécessaires au rendu 3D.
pub fn new(
window: Arc<Window>,
display_handle: &impl HasDisplayHandle,
) -> Result<Self, Box<dyn std::error::Error>> {
let dimensions = window.inner_size().into();
// 1. Initialisation de l'instance, de la surface et du GPU
let dev_ctx = init_device(window, display_handle)?;
// 2. Allocateur de mémoire GPU standard
let memory_allocator = Arc::new(StandardMemoryAllocator::new_default(dev_ctx.device.clone()));
// 3. Détection des formats (couleur sRGB et profondeur D32_SFLOAT)
let surface_formats = dev_ctx
.device
.physical_device()
.surface_formats(&dev_ctx.surface, Default::default())?;
let (color_format, _) = surface_formats
.iter()
.cloned()
.find(|(format, _)| {
*format == Format::B8G8R8A8_SRGB || *format == Format::R8G8B8A8_SRGB
})
.unwrap_or_else(|| surface_formats[0]);
// Format de profondeur standard optimal
let depth_format = Format::D32_SFLOAT;
// 4. Création de la RenderPass avec Color + Depth Buffer
let render_pass = create_render_pass(dev_ctx.device.clone(), color_format, depth_format)?;
// 5. Création de la Swapchain et des Framebuffers
let swapchain_bundle = create_swapchain_bundle(
dev_ctx.device.clone(),
memory_allocator.clone(),
dev_ctx.surface.clone(),
dimensions,
render_pass.clone(),
depth_format,
)?;
// 6. Création des pipelines graphiques (3D opaque, wireframe de sélection et 2D UI hotbar)
let subpass = render_pass.clone().first_subpass();
let pipeline = create_graphics_pipeline(dev_ctx.device.clone(), subpass.clone())?;
let line_pipeline = create_line_pipeline(dev_ctx.device.clone(), subpass.clone())?;
let ui_pipeline = create_ui_pipeline(dev_ctx.device.clone(), subpass)?;
// 7. Génération du maillage filaire pour la sélection
let wireframe_mesh = create_wireframe_cube_mesh(memory_allocator.clone())?;
// 8. Allocateur de Command Buffers
let command_buffer_allocator = Arc::new(StandardCommandBufferAllocator::new(
dev_ctx.device.clone(),
Default::default(),
));
// 9. Génération et upload de l'atlas de textures procédurales (Nearest Sampler, Set 0 Binding 0)
let texture = create_texture_atlas_bundle(
memory_allocator.clone(),
command_buffer_allocator.clone(),
dev_ctx.device.clone(),
dev_ctx.queue.clone(),
pipeline.layout().clone(),
)?;
// 10. Initialisation de la synchronisation GPU
let previous_frame_end = Some(sync::now(dev_ctx.device.clone()).boxed());
Ok(Self {
_instance: dev_ctx.instance,
device: dev_ctx.device,
queue: dev_ctx.queue,
render_pass,
pipeline,
line_pipeline,
ui_pipeline,
texture,
chunk_meshes: HashMap::new(),
wireframe_mesh,
memory_allocator,
swapchain_bundle,
command_buffer_allocator,
previous_frame_end,
recreate_swapchain: false,
})
}
/// Met à jour ou insère les buffers GPU d'un chunk spécifique.
pub fn set_chunk_mesh(
&mut self,
chunk_pos: (i32, i32),
data: crate::world::ChunkMeshData,
) -> Result<(), Box<dyn std::error::Error>> {
let buffers = MeshBuffers::from_data(
self.memory_allocator.clone(),
data.vertices,
data.indices,
)?;
self.chunk_meshes.insert(chunk_pos, buffers);
Ok(())
}
/// Supprime le maillage GPU d'un chunk déchargé.
#[allow(dead_code)]
pub fn remove_chunk_mesh(&mut self, chunk_pos: &(i32, i32)) {
self.chunk_meshes.remove(chunk_pos);
}
/// Signale que la fenêtre a été redimensionnée.
pub fn notify_resized(&mut self) {
self.recreate_swapchain = true;
}
/// Exécute une frame complète de rendu : chunks 3D, contour de sélection et 2D Hotbar d'inventaire.
pub fn render(
&mut self,
window_dimensions: [u32; 2],
view_matrix: Mat4,
selected_block: Option<(i32, i32, i32)>,
ui_mesh: Option<(Vec<crate::renderer::mesh::CubeVertex>, Vec<u32>)>,
) {
if window_dimensions[0] == 0 || window_dimensions[1] == 0 {
return;
}
// Nettoyage régulier des ressources désallouées sur le GPU
if let Some(future) = &mut self.previous_frame_end {
future.cleanup_finished();
}
// Recréation de la swapchain et du depth buffer lors d'un resize
if self.recreate_swapchain {
if let Err(err) = recreate_swapchain_bundle(
&mut self.swapchain_bundle,
self.memory_allocator.clone(),
window_dimensions,
self.render_pass.clone(),
) {
eprintln!("Erreur lors de la recréation de la swapchain : {err}");
return;
}
self.recreate_swapchain = false;
}
// Calcul de la matrice MVP (Model-View-Projection)
let aspect = window_dimensions[0] as f32 / window_dimensions[1] as f32;
let fov = 60.0f32.to_radians();
let projection = Mat4::perspective(fov, aspect, 0.1, 100.0);
let model = Mat4::identity(); // Le cube est positionné à l'origine (0, 0, 0)
let mvp = projection * view_matrix * model;
// 1. Acquisition de la prochaine image de la swapchain
let (image_index, suboptimal, acquire_future) = match acquire_next_image(
self.swapchain_bundle.swapchain.clone(),
None,
)
.map_err(Validated::unwrap)
{
Ok(r) => r,
Err(VulkanError::OutOfDate) => {
self.recreate_swapchain = true;
return;
}
Err(e) => {
eprintln!("Échec de l'acquisition de l'image suivante : {e}");
return;
}
};
if suboptimal {
self.recreate_swapchain = true;
}
// 2. Enregistrement des commandes GPU
let mut builder = AutoCommandBufferBuilder::primary(
self.command_buffer_allocator.clone(),
self.queue.queue_family_index(),
CommandBufferUsage::OneTimeSubmit,
)
.expect("Échec de la création du command buffer builder");
// Fond bleu ciel et effacement du depth buffer à 1.0
let clear_color = [0.25f32, 0.50f32, 0.85f32, 1.0f32];
let clear_depth = 1.0f32;
let viewport = Viewport {
offset: [0.0, 0.0],
extent: [window_dimensions[0] as f32, window_dimensions[1] as f32],
depth_range: 0.0..=1.0,
};
let push_constants = vs::PushConstants { mvp: mvp.cols };
builder
.begin_render_pass(
RenderPassBeginInfo {
clear_values: vec![Some(clear_color.into()), Some(clear_depth.into())],
..RenderPassBeginInfo::framebuffer(
self.swapchain_bundle.framebuffers[image_index as usize].clone(),
)
},
SubpassBeginInfo {
contents: SubpassContents::Inline,
..Default::default()
},
)
.expect("Échec du début de la render pass")
.bind_pipeline_graphics(self.pipeline.clone())
.expect("Échec du bind pipeline")
.bind_descriptor_sets(
PipelineBindPoint::Graphics,
self.pipeline.layout().clone(),
0,
self.texture.descriptor_set.clone(),
)
.expect("Échec du bind descriptor set")
.set_viewport(0, [viewport].into_iter().collect())
.expect("Échec du set viewport")
.push_constants(self.pipeline.layout().clone(), 0, push_constants)
.expect("Échec de l'envoi des push constants");
// Rendu de chaque chunk du monde (1 draw call par chunk)
for mesh in self.chunk_meshes.values() {
if mesh.index_count > 0 {
builder
.bind_vertex_buffers(0, mesh.vertex_buffer.clone())
.expect("Échec du bind vertex buffer")
.bind_index_buffer(mesh.index_buffer.clone())
.expect("Échec du bind index buffer");
unsafe {
builder
.draw_indexed(mesh.index_count, 1, 0, 0, 0)
.expect("Échec du draw_indexed");
}
}
}
// 2.bis Rendu du contour filaire (wireframe) autour du bloc visé
if let Some((bx, by, bz)) = selected_block {
let wireframe_model = Mat4::from_translation(crate::math::Vec3::new(
bx as f32, by as f32, bz as f32,
));
let wireframe_mvp = projection * view_matrix * wireframe_model;
builder
.bind_pipeline_graphics(self.line_pipeline.clone())
.expect("Échec du bind line pipeline")
.bind_vertex_buffers(0, self.wireframe_mesh.vertex_buffer.clone())
.expect("Échec du bind wireframe vertex buffer")
.bind_index_buffer(self.wireframe_mesh.index_buffer.clone())
.expect("Échec du bind wireframe index buffer")
.push_constants(
self.line_pipeline.layout().clone(),
0,
vs::PushConstants {
mvp: wireframe_mvp.cols,
},
)
.expect("Échec de l'envoi des push constants wireframe");
unsafe {
builder
.draw_indexed(self.wireframe_mesh.index_count, 1, 0, 0, 0)
.expect("Échec du draw_indexed wireframe");
}
}
// 2.ter Rendu de l'interface 2D (Hotbar d'inventaire)
if let Some((ui_vertices, ui_indices)) = ui_mesh {
if !ui_indices.is_empty() {
if let Ok(ui_buf) = MeshBuffers::from_data(
self.memory_allocator.clone(),
ui_vertices,
ui_indices,
) {
builder
.bind_pipeline_graphics(self.ui_pipeline.clone())
.expect("Échec du bind UI pipeline")
.bind_vertex_buffers(0, ui_buf.vertex_buffer.clone())
.expect("Échec du bind UI vertex buffer")
.bind_index_buffer(ui_buf.index_buffer.clone())
.expect("Échec du bind UI index buffer");
unsafe {
builder
.draw_indexed(ui_buf.index_count, 1, 0, 0, 0)
.expect("Échec du draw_indexed UI");
}
}
}
}
builder
.end_render_pass(Default::default())
.expect("Échec de la fin de la render pass");
let command_buffer = builder
.build()
.expect("Échec de la construction du command buffer");
// 3. Soumission et présentation
let prev_future = self
.previous_frame_end
.take()
.unwrap_or_else(|| sync::now(self.device.clone()).boxed());
let execution = prev_future
.join(acquire_future)
.then_execute(self.queue.clone(), command_buffer)
.expect("Échec de la soumission du command buffer")
.then_swapchain_present(
self.queue.clone(),
SwapchainPresentInfo::swapchain_image_index(
self.swapchain_bundle.swapchain.clone(),
image_index,
),
)
.then_signal_fence_and_flush();
match execution.map_err(Validated::unwrap) {
Ok(future) => {
self.previous_frame_end = Some(future.boxed());
}
Err(VulkanError::OutOfDate) => {
self.recreate_swapchain = true;
self.previous_frame_end = Some(sync::now(self.device.clone()).boxed());
}
Err(e) => {
eprintln!("Erreur lors de la synchronisation GPU/présentation : {e}");
self.previous_frame_end = Some(sync::now(self.device.clone()).boxed());
}
}
}
}