Premier commit
Cette révision appartient à :
révision
13bc77fd6c
21 fichiers modifiés
+6169
Aucun fichier ne correspond à votre recherche
@@ -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());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur