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, device: Arc, queue: Arc, render_pass: Arc, pipeline: Arc, line_pipeline: Arc, ui_pipeline: Arc, texture: VulkanTexture, chunk_meshes: HashMap<(i32, i32), MeshBuffers>, wireframe_mesh: MeshBuffers, memory_allocator: Arc, swapchain_bundle: SwapchainBundle, command_buffer_allocator: Arc, previous_frame_end: Option>, recreate_swapchain: bool, } impl VulkanRenderer { /// Initialise tous les composants Vulkan nécessaires au rendu 3D. pub fn new( window: Arc, display_handle: &impl HasDisplayHandle, ) -> Result> { 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> { 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, Vec)>, ) { 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()); } } } }