391 lignes
15 KiB
Rust
391 lignes
15 KiB
Rust
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());
|
|
}
|
|
}
|
|
}
|
|
}
|