(&self) {
+ let type_id = TypeId::of::();
+ let pipeline = Arc::new(RwLock::new(P::default()));
+
+ let mut pipelines_id = self.pipelines_id.write().unwrap();
+ let mut pipelines_state = self.pipelines_state.write().unwrap();
+ let mut pipelines = self.pipelines.write().unwrap();
+
+ pipelines_id.push(type_id);
+ pipelines_state.push(Arc::new(RwLock::new(MaterialState::Loading)));
+ pipelines.push(pipeline.clone());
+ }
+
+ pub fn add_material(&self) -> Result<(), MaterialError> {
+ let pipeline_id = M::pipeline_type_id();
+
+ let pipeline_result = {
+ let pipelines_id = self.pipelines_id.read().unwrap();
+ let pipelines_state = self.pipelines_state.read().unwrap();
+ let pipelines = self.pipelines.read().unwrap();
+
+ pipelines_id
+ .iter()
+ .zip(pipelines.iter())
+ .zip(pipelines_state.iter())
+ .find(|((id, _), _)| *id == &pipeline_id)
+ .map(|((_, pipeline), state)| (pipeline.clone(), state.clone()))
+ };
+
+ let (pipeline, pipeline_state) = match pipeline_result {
+ Some(pipeline) => pipeline,
+ None => {
+ tracing::error!(
+ "Pipeline with id {pipeline_id:?} not found, please add it before adding a material"
+ );
+ return Err(MaterialError::PipelineNotFound);
+ }
+ };
+
+ let type_id = TypeId::of::();
+
+ let mut materials_id = self.materials_id.write().unwrap();
+ let mut materials_pipeline_id = self.materials_pipeline_id.write().unwrap();
+ let mut materials_pipeline = self.materials_pipeline.write().unwrap();
+ let mut materials_pipeline_state = self.materials_pipeline_state.write().unwrap();
+ let mut materials_state = self.materials_state.write().unwrap();
+ let mut materials = self.materials.write().unwrap();
+
+ materials_id.push(type_id);
+ materials_pipeline_id.push(pipeline_id);
+ materials_pipeline.push(pipeline);
+ materials_pipeline_state.push(pipeline_state);
+ materials_state.push(Arc::new(RwLock::new(MaterialState::Loading)));
+ materials.push(Arc::new(RwLock::new(M::default())));
+
+ Ok(())
+ }
+
+ pub fn update_swapchain_format(&mut self, swapchain_format: Format) {
+ if self.swapchain_format == swapchain_format {
+ return;
+ }
+
+ self.swapchain_format = swapchain_format;
+ self.mark_all_pipelines_as_loading();
+ }
+
+ fn mark_all_pipelines_as_loading(&self) {
+ let pipelines_state = self.pipelines_state.write().unwrap();
+
+ for state in pipelines_state.iter() {
+ let mut state = state.write().unwrap();
+ *state = MaterialState::Loading;
+ }
+ }
+
+ fn load_pipelines(&self) {
+ let pipelines_state = self.pipelines_state.read().unwrap();
+ let pipelines = self.pipelines.read().unwrap();
+
+ let iter = pipelines_state
+ .iter()
+ .zip(pipelines.iter())
+ .filter(|(state, _)| {
+ let state = state.read().unwrap();
+ matches!(*state, MaterialState::Loading)
+ });
+
+ for (state, pipeline) in iter {
+ let mut pipeline = pipeline.write().unwrap();
+ let result = pipeline.load(
+ &self.device,
+ &self.memory_allocator,
+ self.swapchain_format,
+ self.depth_format,
+ );
+
+ match result {
+ Ok(_) => {
+ let mut state = state.write().unwrap();
+ *state = MaterialState::Loaded;
+ }
+ Err(e) => {
+ tracing::error!("Failed to load pipeline: {e}");
+ }
+ }
+ }
+ }
+
+ fn load_materials(&self) {
+ let materials_state = self.materials_state.read().unwrap();
+ let materials = self.materials.read().unwrap();
+
+ let iter = materials_state
+ .iter()
+ .zip(materials.iter())
+ .filter(|(state, _)| {
+ let state = state.read().unwrap();
+ matches!(*state, MaterialState::Loading)
+ });
+
+ for (state, material) in iter {
+ let mut material = material.write().unwrap();
+ let result = material.load(&self.device, &self.memory_allocator);
+
+ match result {
+ Ok(_) => {
+ let mut state = state.write().unwrap();
+ *state = MaterialState::Loaded;
+ }
+ Err(e) => {
+ tracing::error!("Failed to load material: {e}");
+ }
+ }
+ }
+ }
+
+ fn render_materials(&self, f: F)
+ where
+ F: Fn(RwLockReadGuard<'_, dyn Material>, RwLockReadGuard<'_, dyn Pipeline>),
+ {
+ let materials = self.materials.read().unwrap();
+ let materials_state = self.materials_state.read().unwrap();
+ let materials_pipeline = self.materials_pipeline.read().unwrap();
+ let materials_pipeline_state = self.materials_pipeline_state.read().unwrap();
+
+ materials
+ .iter()
+ .zip(materials_state.iter())
+ .zip(materials_pipeline.iter())
+ .zip(materials_pipeline_state.iter())
+ .filter(|(((_, material_state), _), pipeline_state)| {
+ let material_state = material_state.read().unwrap();
+ let pipeline_state = pipeline_state.read().unwrap();
+ matches!(*material_state, MaterialState::Loaded)
+ && matches!(*pipeline_state, MaterialState::Loaded)
+ })
+ .for_each(|(((material, _), pipeline), _)| {
+ let material = material.read().unwrap();
+ let pipeline = pipeline.read().unwrap();
+
+ f(material, pipeline);
+ });
+ }
+}
diff --git a/src/core/render/mod.rs b/src/core/render/mod.rs
new file mode 100644
index 0000000..ec7ac54
--- /dev/null
+++ b/src/core/render/mod.rs
@@ -0,0 +1,5 @@
+pub mod material_manager;
+pub mod primitives;
+pub mod render_pass_manager;
+pub mod texture;
+pub mod vulkan_context;
diff --git a/src/core/render/primitives/buffer.rs b/src/core/render/primitives/buffer.rs
new file mode 100644
index 0000000..e01226f
--- /dev/null
+++ b/src/core/render/primitives/buffer.rs
@@ -0,0 +1,83 @@
+use std::{error::Error, sync::Arc};
+
+use vulkano::{
+ Validated,
+ buffer::{AllocateBufferError, Buffer, BufferContents, BufferCreateInfo, Subbuffer},
+ memory::allocator::{AllocationCreateInfo, StandardMemoryAllocator},
+};
+
+pub trait AsBindableBuffer {
+ type BufferData: BufferContents + Clone;
+
+ fn buffer_create_info() -> BufferCreateInfo;
+
+ fn allocation_create_info() -> AllocationCreateInfo;
+
+ fn to_buffer_data(data: &T) -> Self::BufferData;
+
+ fn create_buffer(
+ memory_allocator: &Arc,
+ data: &T,
+ ) -> Result, Validated> {
+ let buffer_data = Self::to_buffer_data(data);
+ Buffer::from_iter(
+ memory_allocator.clone(),
+ Self::buffer_create_info(),
+ Self::allocation_create_info(),
+ [buffer_data],
+ )
+ }
+
+ fn update_buffer(
+ buffer: &Subbuffer<[Self::BufferData]>,
+ data: &T,
+ ) -> Result<(), Box> {
+ let buffer_data = Self::to_buffer_data(data);
+ let mut write_guard = buffer.write()?;
+ write_guard[0] = buffer_data;
+ Ok(())
+ }
+}
+
+pub trait AsUniformBuffer: AsBindableBuffer {
+ fn create_uniform_buffer(
+ memory_allocator: &Arc,
+ data: &T,
+ ) -> Result, Validated> {
+ Self::create_buffer(memory_allocator, data)
+ }
+}
+
+pub trait AsVertexBuffer: AsBindableBuffer {
+ fn create_vertex_buffer(
+ memory_allocator: &Arc,
+ vertices: &[T],
+ ) -> Result, Validated> {
+ let buffer_data: Vec =
+ vertices.iter().map(|v| Self::to_buffer_data(v)).collect();
+
+ Buffer::from_iter(
+ memory_allocator.clone(),
+ Self::buffer_create_info(),
+ Self::allocation_create_info(),
+ buffer_data,
+ )
+ }
+}
+
+pub trait AsIndexBuffer: AsBindableBuffer {
+ fn create_index_buffer(
+ memory_allocator: &Arc,
+ indices: &[T],
+ ) -> Result, Validated> {
+ let buffer_data: Vec =
+ indices.iter().map(|i| Self::to_buffer_data(i)).collect();
+
+ Buffer::from_iter(
+ memory_allocator.clone(),
+ Self::buffer_create_info(),
+ Self::allocation_create_info(),
+ buffer_data,
+ )
+ }
+}
diff --git a/src/core/render/primitives/camera.rs b/src/core/render/primitives/camera.rs
new file mode 100644
index 0000000..4fdf1ae
--- /dev/null
+++ b/src/core/render/primitives/camera.rs
@@ -0,0 +1,123 @@
+use std::{f32::consts::FRAC_PI_2, sync::Arc};
+
+use glam::{Mat4, Vec3, Vec4};
+use vulkano::{
+ Validated,
+ buffer::{AllocateBufferError, Subbuffer},
+ memory::allocator::StandardMemoryAllocator,
+};
+
+use crate::core::{input::InputManager, timer::Timer};
+
+use super::{AsUniformBuffer, mvp::Mvp};
+
+// See docs/OPENGL_VULKAN_DIFF.md
+const OPENGL_TO_VULKAN_Y_AXIS_FLIP: Mat4 = Mat4 {
+ x_axis: Vec4::new(1.0, 0.0, 0.0, 0.0),
+ y_axis: Vec4::new(0.0, -1.0, 0.0, 0.0),
+ z_axis: Vec4::new(0.0, 0.0, 1.0, 0.0),
+ w_axis: Vec4::new(0.0, 0.0, 0.0, 1.0),
+};
+
+#[derive(Default)]
+pub struct Camera3D {
+ projection: Mat4,
+
+ position: Vec3,
+ rotation: Vec3,
+ aspect_ratio: f32,
+ fov: f32,
+ near: f32,
+ far: f32,
+}
+
+impl Camera3D {
+ pub fn new(aspect_ratio: f32, fov: f32, near: f32, far: f32) -> Self {
+ Self {
+ projection: Mat4::perspective_rh(fov, aspect_ratio, near, far),
+ position: Vec3::ZERO,
+ rotation: Vec3::ZERO,
+ aspect_ratio,
+ fov,
+ near,
+ far,
+ }
+ }
+
+ pub fn update(
+ &mut self,
+ input_manager: &InputManager,
+ timer: &Timer,
+ movement_speed: f32,
+ camera_sensitivity: f32,
+ window_aspect_ratio: f32,
+ ) {
+ // Process camera rotation
+ let camera_delta = camera_sensitivity * timer.delta_time();
+ self.rotation += Vec3::new(
+ (input_manager.get_virtual_input_state("mouse_y") * camera_delta).to_radians(),
+ (input_manager.get_virtual_input_state("mouse_x") * camera_delta).to_radians(),
+ 0.0,
+ );
+
+ if self.rotation.x > FRAC_PI_2 {
+ self.rotation = Vec3::new(FRAC_PI_2, self.rotation.y, 0.0);
+ }
+
+ if self.rotation.x < -FRAC_PI_2 {
+ self.rotation = Vec3::new(-FRAC_PI_2, self.rotation.y, 0.0);
+ }
+
+ let movement_delta = movement_speed * timer.delta_time();
+
+ let (yaw_sin, yaw_cos) = self.rotation.y.sin_cos();
+ let forward = Vec3::new(yaw_cos, 0.0, yaw_sin).normalize();
+ let right = Vec3::new(-yaw_sin, 0.0, yaw_cos).normalize();
+
+ let tx = input_manager.get_virtual_input_state("move_right") * movement_delta;
+ self.position += tx * right;
+
+ let tz = input_manager.get_virtual_input_state("move_forward") * movement_delta;
+ self.position += tz * forward;
+
+ if self.aspect_ratio != window_aspect_ratio {
+ self.aspect_ratio = window_aspect_ratio;
+ self.projection =
+ Mat4::perspective_rh(self.fov, self.aspect_ratio, self.near, self.far);
+ }
+ }
+
+ pub fn set_projection(&mut self, projection: Mat4) {
+ self.projection = projection;
+ }
+
+ pub fn get_position(&self) -> Vec3 {
+ self.position
+ }
+
+ pub fn get_rotation(&self) -> Vec3 {
+ self.rotation
+ }
+
+ pub fn create_buffer(
+ &self,
+ memory_allocator: &Arc,
+ ) -> Result, Validated> {
+ let (sin_pitch, cos_pitch) = self.rotation.x.sin_cos();
+ let (sin_yaw, cos_yaw) = self.rotation.y.sin_cos();
+
+ let view_matrix = Mat4::look_to_rh(
+ self.position,
+ Vec3::new(cos_pitch * cos_yaw, sin_pitch, cos_pitch * sin_yaw).normalize(),
+ Vec3::Y,
+ );
+
+ let mvp = Mvp {
+ model: OPENGL_TO_VULKAN_Y_AXIS_FLIP.to_cols_array_2d(),
+ view: view_matrix.to_cols_array_2d(),
+ projection: self.projection.to_cols_array_2d(),
+ };
+
+ Mvp::create_uniform_buffer(memory_allocator, &mvp)
+ }
+}
diff --git a/src/core/render/primitives/command.rs b/src/core/render/primitives/command.rs
new file mode 100644
index 0000000..37970a1
--- /dev/null
+++ b/src/core/render/primitives/command.rs
@@ -0,0 +1,110 @@
+use std::{error::Error, sync::Arc};
+
+use vulkano::{
+ command_buffer::{
+ AutoCommandBufferBuilder, PrimaryAutoCommandBuffer, RenderPassBeginInfo, SubpassBeginInfo,
+ SubpassEndInfo,
+ },
+ descriptor_set::DescriptorSet,
+ pipeline::{GraphicsPipeline, Pipeline},
+ render_pass::{Framebuffer, RenderPass},
+};
+
+pub trait AsRecordable {
+ fn record_render_commands(
+ builder: &mut AutoCommandBufferBuilder,
+ data: &T,
+ pipeline: &Arc,
+ descriptor_sets: &[Arc],
+ ) -> Result<(), Box>;
+}
+
+pub trait AsDrawable {
+ type VertexBuffer;
+ type IndexBuffer;
+
+ fn vertex_buffer(data: &T) -> &Self::VertexBuffer;
+
+ fn index_buffer(_data: &T) -> Option<&Self::IndexBuffer> {
+ None
+ }
+
+ fn vertex_count(data: &T) -> u32;
+
+ fn index_count(_data: &T) -> u32 {
+ 0
+ }
+
+ fn instance_count(_data: &T) -> u32 {
+ 1
+ }
+
+ fn first_vertex(_data: &T) -> u32 {
+ 0
+ }
+
+ fn first_index(_data: &T) -> u32 {
+ 0
+ }
+
+ fn first_instance(_data: &T) -> u32 {
+ 0
+ }
+}
+
+pub trait AsRenderPassRecordable {
+ fn begin_render_pass(
+ builder: &mut AutoCommandBufferBuilder,
+ _render_pass: &Arc,
+ framebuffer: &Arc,
+ clear_values: Vec>,
+ ) -> Result<(), Box> {
+ builder.begin_render_pass(
+ RenderPassBeginInfo {
+ clear_values,
+ ..RenderPassBeginInfo::framebuffer(framebuffer.clone())
+ },
+ SubpassBeginInfo {
+ contents: vulkano::command_buffer::SubpassContents::Inline,
+ ..Default::default()
+ },
+ )?;
+ Ok(())
+ }
+
+ fn end_render_pass(
+ builder: &mut AutoCommandBufferBuilder,
+ ) -> Result<(), Box> {
+ builder.end_render_pass(SubpassEndInfo::default())?;
+ Ok(())
+ }
+
+ fn record_render_pass_commands(
+ builder: &mut AutoCommandBufferBuilder,
+ data: &T,
+ ) -> Result<(), Box>;
+}
+
+pub trait AsRenderableObject: AsRecordable + AsDrawable {
+ fn record_complete_render(
+ builder: &mut AutoCommandBufferBuilder,
+ data: &T,
+ pipeline: &Arc,
+ descriptor_sets: &[Arc],
+ ) -> Result<(), Box> {
+ builder.bind_pipeline_graphics(pipeline.clone())?;
+
+ if !descriptor_sets.is_empty() {
+ builder.bind_descriptor_sets(
+ vulkano::pipeline::PipelineBindPoint::Graphics,
+ pipeline.layout().clone(),
+ 0,
+ descriptor_sets.iter().cloned().collect::>(),
+ )?;
+ }
+
+ Self::record_render_commands(builder, data, pipeline, descriptor_sets)?;
+
+ Ok(())
+ }
+}
diff --git a/src/core/render/primitives/mod.rs b/src/core/render/primitives/mod.rs
new file mode 100644
index 0000000..8ef9dd7
--- /dev/null
+++ b/src/core/render/primitives/mod.rs
@@ -0,0 +1,32 @@
+use std::{collections::BTreeMap, sync::Arc};
+
+use vulkano::{
+ Validated, VulkanError,
+ descriptor_set::{
+ DescriptorSet,
+ allocator::StandardDescriptorSetAllocator,
+ layout::{DescriptorSetLayout, DescriptorSetLayoutBinding},
+ },
+};
+
+pub mod camera;
+pub mod mvp;
+pub mod transform;
+pub mod vertex;
+
+pub mod buffer;
+pub mod command;
+pub mod resource;
+
+pub use buffer::{AsBindableBuffer, AsIndexBuffer, AsUniformBuffer, AsVertexBuffer};
+pub use command::{AsDrawable, AsRecordable};
+
+pub trait AsBindableDescriptorSet {
+ fn as_descriptor_set_layout_bindings() -> BTreeMap;
+
+ fn as_descriptor_set(
+ descriptor_set_allocator: &Arc,
+ layout: &Arc,
+ data: &T,
+ ) -> Result, Validated>;
+}
diff --git a/src/core/render/primitives/mvp.rs b/src/core/render/primitives/mvp.rs
new file mode 100644
index 0000000..0f47ce3
--- /dev/null
+++ b/src/core/render/primitives/mvp.rs
@@ -0,0 +1,83 @@
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use vulkano::buffer::{
+ AllocateBufferError, BufferContents, BufferCreateInfo, BufferUsage, Subbuffer,
+};
+use vulkano::descriptor_set::allocator::StandardDescriptorSetAllocator;
+use vulkano::descriptor_set::layout::{
+ DescriptorSetLayout, DescriptorSetLayoutBinding, DescriptorType,
+};
+use vulkano::descriptor_set::{DescriptorSet, WriteDescriptorSet};
+use vulkano::memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator};
+use vulkano::shader::ShaderStages;
+use vulkano::{Validated, VulkanError};
+
+use crate::core::render::primitives::{AsBindableBuffer, AsBindableDescriptorSet, AsUniformBuffer};
+
+#[derive(BufferContents, Clone, Copy)]
+#[repr(C)]
+pub struct Mvp {
+ pub model: [[f32; 4]; 4],
+ pub view: [[f32; 4]; 4],
+ pub projection: [[f32; 4]; 4],
+}
+
+impl Mvp {
+ pub fn into_buffer(
+ self,
+ memory_allocator: &Arc,
+ ) -> Result, Validated> {
+ Self::create_uniform_buffer(memory_allocator, &self)
+ }
+}
+
+impl AsBindableBuffer for Mvp {
+ type BufferData = Mvp;
+
+ fn buffer_create_info() -> BufferCreateInfo {
+ BufferCreateInfo {
+ usage: BufferUsage::UNIFORM_BUFFER,
+ ..Default::default()
+ }
+ }
+
+ fn allocation_create_info() -> AllocationCreateInfo {
+ AllocationCreateInfo {
+ memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
+ | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+ ..Default::default()
+ }
+ }
+
+ fn to_buffer_data(data: &Mvp) -> Self::BufferData {
+ *data
+ }
+}
+
+impl AsUniformBuffer for Mvp {}
+
+impl AsBindableDescriptorSet> for Mvp {
+ fn as_descriptor_set_layout_bindings() -> BTreeMap {
+ BTreeMap::::from_iter([(
+ 0,
+ DescriptorSetLayoutBinding {
+ stages: ShaderStages::VERTEX,
+ ..DescriptorSetLayoutBinding::descriptor_type(DescriptorType::UniformBuffer)
+ },
+ )])
+ }
+
+ fn as_descriptor_set(
+ descriptor_set_allocator: &Arc,
+ layout: &Arc,
+ data: &Subbuffer<[Mvp]>,
+ ) -> Result, Validated> {
+ DescriptorSet::new(
+ descriptor_set_allocator.clone(),
+ layout.clone(),
+ [WriteDescriptorSet::buffer(0, data.clone())],
+ [],
+ )
+ }
+}
diff --git a/src/core/render/primitives/resource.rs b/src/core/render/primitives/resource.rs
new file mode 100644
index 0000000..7ea75e7
--- /dev/null
+++ b/src/core/render/primitives/resource.rs
@@ -0,0 +1,208 @@
+use std::{
+ collections::HashMap,
+ error::Error,
+ fmt::{self, Debug, Display},
+ hash::Hash,
+ sync::Arc,
+};
+
+#[derive(Debug, Clone)]
+pub struct ResourceLoadError {
+ pub message: String,
+}
+
+impl Display for ResourceLoadError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "Resource load error: {}", self.message)
+ }
+}
+
+impl Error for ResourceLoadError {}
+
+impl ResourceLoadError {
+ pub fn new(message: impl Into) -> Self {
+ Self {
+ message: message.into(),
+ }
+ }
+}
+
+pub trait AsResourceManager
+where
+ THandle: Clone + Eq + Hash + Debug,
+{
+ /// Type d'erreur lors du chargement
+ type LoadError: Error;
+
+ /// Charge une ressource avec l'handle donné
+ fn load(&mut self, handle: THandle, resource: TResource) -> Result<(), Self::LoadError>;
+
+ /// Récupère une ressource par son handle
+ fn get(&self, handle: &THandle) -> Option<&TResource>;
+
+ /// Récupère une ressource mutable par son handle
+ fn get_mut(&mut self, handle: &THandle) -> Option<&mut TResource>;
+
+ /// Supprime une ressource
+ fn unload(&mut self, handle: &THandle) -> Option;
+
+ /// Vérifie si une ressource est chargée
+ fn is_loaded(&self, handle: &THandle) -> bool;
+
+ /// Retourne tous les handles chargés
+ fn loaded_handles(&self) -> Vec;
+
+ /// Nettoie toutes les ressources
+ fn clear(&mut self);
+}
+
+/// Implémentation basique d'un gestionnaire de ressources
+pub struct BasicResourceManager
+where
+ THandle: Clone + Eq + Hash + Debug,
+{
+ resources: HashMap,
+}
+
+impl BasicResourceManager
+where
+ THandle: Clone + Eq + Hash + Debug,
+{
+ pub fn new() -> Self {
+ Self {
+ resources: HashMap::new(),
+ }
+ }
+
+ pub fn with_capacity(capacity: usize) -> Self {
+ Self {
+ resources: HashMap::with_capacity(capacity),
+ }
+ }
+}
+
+impl Default for BasicResourceManager
+where
+ THandle: Clone + Eq + Hash + Debug,
+{
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl AsResourceManager
+ for BasicResourceManager
+where
+ THandle: Clone + Eq + Hash + Debug,
+{
+ type LoadError = ResourceLoadError;
+
+ fn load(&mut self, handle: THandle, resource: TResource) -> Result<(), Self::LoadError> {
+ self.resources.insert(handle, resource);
+ Ok(())
+ }
+
+ fn get(&self, handle: &THandle) -> Option<&TResource> {
+ self.resources.get(handle)
+ }
+
+ fn get_mut(&mut self, handle: &THandle) -> Option<&mut TResource> {
+ self.resources.get_mut(handle)
+ }
+
+ fn unload(&mut self, handle: &THandle) -> Option {
+ self.resources.remove(handle)
+ }
+
+ fn is_loaded(&self, handle: &THandle) -> bool {
+ self.resources.contains_key(handle)
+ }
+
+ fn loaded_handles(&self) -> Vec {
+ self.resources.keys().cloned().collect()
+ }
+
+ fn clear(&mut self) {
+ self.resources.clear();
+ }
+}
+
+pub struct ThreadSafeResourceManager
+where
+ THandle: Clone + Eq + Hash + Debug,
+{
+ resources: Arc>>>,
+}
+
+impl ThreadSafeResourceManager
+where
+ THandle: Clone + Eq + Hash + Debug,
+{
+ pub fn new() -> Self {
+ Self {
+ resources: Arc::new(std::sync::RwLock::new(HashMap::new())),
+ }
+ }
+
+ pub fn load(&self, handle: THandle, resource: TResource) -> Result<(), ResourceLoadError> {
+ let mut resources = self
+ .resources
+ .write()
+ .map_err(|_| ResourceLoadError::new("Failed to acquire write lock"))?;
+ resources.insert(handle, Arc::new(resource));
+ Ok(())
+ }
+
+ pub fn get(&self, handle: &THandle) -> Option> {
+ let resources = self.resources.read().ok()?;
+ resources.get(handle).cloned()
+ }
+
+ pub fn unload(&self, handle: &THandle) -> Option> {
+ let mut resources = self.resources.write().ok()?;
+ resources.remove(handle)
+ }
+
+ pub fn is_loaded(&self, handle: &THandle) -> bool {
+ if let Ok(resources) = self.resources.read() {
+ resources.contains_key(handle)
+ } else {
+ false
+ }
+ }
+
+ pub fn loaded_handles(&self) -> Vec {
+ if let Ok(resources) = self.resources.read() {
+ resources.keys().cloned().collect()
+ } else {
+ Vec::new()
+ }
+ }
+
+ pub fn clear(&self) {
+ if let Ok(mut resources) = self.resources.write() {
+ resources.clear();
+ }
+ }
+}
+
+impl Clone for ThreadSafeResourceManager
+where
+ THandle: Clone + Eq + Hash + Debug,
+{
+ fn clone(&self) -> Self {
+ Self {
+ resources: Arc::clone(&self.resources),
+ }
+ }
+}
+
+pub trait AsAsyncLoadable
+where
+ THandle: Clone + Eq + Hash + Debug + Send + Sync,
+{
+ type Resource: Send + Sync;
+ type LoadError: Error + Send + Sync;
+
+ async fn load_async(handle: THandle) -> Result;
+}
diff --git a/src/core/render/primitives/transform.rs b/src/core/render/primitives/transform.rs
new file mode 100644
index 0000000..d7c1249
--- /dev/null
+++ b/src/core/render/primitives/transform.rs
@@ -0,0 +1,163 @@
+use std::sync::Arc;
+
+use glam::{Mat4, Quat, Vec3};
+use vulkano::{
+ Validated,
+ buffer::{AllocateBufferError, BufferContents, BufferCreateInfo, BufferUsage, Subbuffer},
+ memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator},
+ pipeline::graphics::vertex_input::Vertex,
+};
+
+use crate::core::render::primitives::{AsBindableBuffer, AsVertexBuffer};
+
+#[derive(Debug, Clone)]
+pub struct Transform {
+ pub position: Vec3,
+ pub rotation: Quat,
+ pub scale: Vec3,
+ // Cache to avoid unnecessary recalculations
+ cached_matrix: Option,
+ dirty: bool,
+}
+
+#[derive(BufferContents, Vertex, Clone, Copy, Debug)]
+#[repr(C)]
+pub struct TransformRaw {
+ #[format(R32G32B32A32_SFLOAT)]
+ pub model: [[f32; 4]; 4],
+}
+
+impl Default for Transform {
+ fn default() -> Self {
+ Self {
+ position: Vec3::ZERO,
+ rotation: Quat::IDENTITY,
+ scale: Vec3::ONE,
+ cached_matrix: None,
+ dirty: true,
+ }
+ }
+}
+
+impl Transform {
+ pub fn new(position: Vec3, rotation: Quat, scale: Vec3) -> Self {
+ Self {
+ position,
+ rotation,
+ scale,
+ cached_matrix: None,
+ dirty: true,
+ }
+ }
+
+ pub fn rotate(&mut self, rotation: Quat) {
+ self.rotation *= rotation;
+ self.mark_dirty();
+ }
+
+ pub fn translate(&mut self, translation: Vec3) {
+ self.position += translation;
+ self.mark_dirty();
+ }
+
+ pub fn scale(&mut self, scale: Vec3) {
+ self.scale *= scale;
+ self.mark_dirty();
+ }
+
+ pub fn set_position(&mut self, position: Vec3) {
+ self.position = position;
+ self.mark_dirty();
+ }
+
+ pub fn set_rotation(&mut self, rotation: Quat) {
+ self.rotation = rotation;
+ self.mark_dirty();
+ }
+
+ pub fn set_scale(&mut self, scale: Vec3) {
+ self.scale = scale;
+ self.mark_dirty();
+ }
+
+ fn mark_dirty(&mut self) {
+ self.dirty = true;
+ self.cached_matrix = None;
+ }
+
+ /// Get the transformation matrix (immutable - recalculates each time)
+ pub fn matrix(&self) -> Mat4 {
+ Mat4::from_translation(self.position)
+ * Mat4::from_quat(self.rotation)
+ * Mat4::from_scale(self.scale)
+ }
+
+ /// Convert to GPU-ready format (immutable - recalculates each time)
+ pub fn to_raw(&self) -> TransformRaw {
+ TransformRaw {
+ model: self.matrix().to_cols_array_2d(),
+ }
+ }
+
+ /// Create a buffer from transforms (immutable - recalculates each time)
+ pub fn create_buffer(
+ memory_allocator: &Arc,
+ transforms: &[Transform],
+ ) -> Result, Validated> {
+ TransformRaw::create_vertex_buffer(
+ memory_allocator,
+ &transforms.iter().map(|t| t.to_raw()).collect::>(),
+ )
+ }
+}
+
+impl From<&Transform> for TransformRaw {
+ fn from(transform: &Transform) -> Self {
+ transform.to_raw()
+ }
+}
+
+impl From for TransformRaw {
+ fn from(matrix: Mat4) -> Self {
+ Self {
+ model: matrix.to_cols_array_2d(),
+ }
+ }
+}
+
+impl TransformRaw {
+ pub fn from_matrix(matrix: Mat4) -> Self {
+ Self {
+ model: matrix.to_cols_array_2d(),
+ }
+ }
+
+ pub fn to_matrix(&self) -> Mat4 {
+ Mat4::from_cols_array_2d(&self.model)
+ }
+}
+
+impl AsBindableBuffer for TransformRaw {
+ type BufferData = TransformRaw;
+
+ fn buffer_create_info() -> BufferCreateInfo {
+ BufferCreateInfo {
+ usage: BufferUsage::VERTEX_BUFFER,
+ ..Default::default()
+ }
+ }
+
+ fn allocation_create_info() -> AllocationCreateInfo {
+ AllocationCreateInfo {
+ memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
+ | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+ ..Default::default()
+ }
+ }
+
+ fn to_buffer_data(data: &TransformRaw) -> Self::BufferData {
+ *data
+ }
+}
+
+impl AsVertexBuffer for TransformRaw {}
diff --git a/src/core/render/primitives/vertex.rs b/src/core/render/primitives/vertex.rs
new file mode 100644
index 0000000..2a27b36
--- /dev/null
+++ b/src/core/render/primitives/vertex.rs
@@ -0,0 +1,101 @@
+use vulkano::buffer::BufferContents;
+use vulkano::buffer::{BufferCreateInfo, BufferUsage};
+use vulkano::memory::allocator::{AllocationCreateInfo, MemoryTypeFilter};
+use vulkano::pipeline::graphics::vertex_input::Vertex;
+
+use crate::core::render::primitives::{AsBindableBuffer, AsIndexBuffer, AsVertexBuffer};
+
+#[derive(BufferContents, Vertex, Clone, Copy)]
+#[repr(C)]
+pub struct Vertex2D {
+ #[format(R32G32_SFLOAT)]
+ pub position: [f32; 2],
+
+ #[format(R32G32_SFLOAT)]
+ pub uv: [f32; 2],
+}
+
+#[derive(BufferContents, Vertex, Clone, Copy)]
+#[repr(C)]
+pub struct Vertex3D {
+ #[format(R32G32B32_SFLOAT)]
+ pub position: [f32; 3],
+
+ #[format(R32G32_SFLOAT)]
+ pub uv: [f32; 2],
+}
+
+impl AsBindableBuffer for Vertex2D {
+ type BufferData = Vertex2D;
+
+ fn buffer_create_info() -> BufferCreateInfo {
+ BufferCreateInfo {
+ usage: BufferUsage::VERTEX_BUFFER,
+ ..Default::default()
+ }
+ }
+
+ fn allocation_create_info() -> AllocationCreateInfo {
+ AllocationCreateInfo {
+ memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
+ | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+ ..Default::default()
+ }
+ }
+
+ fn to_buffer_data(data: &Vertex2D) -> Self::BufferData {
+ *data
+ }
+}
+
+impl AsVertexBuffer for Vertex2D {}
+
+impl AsBindableBuffer for Vertex3D {
+ type BufferData = Vertex3D;
+
+ fn buffer_create_info() -> BufferCreateInfo {
+ BufferCreateInfo {
+ usage: BufferUsage::VERTEX_BUFFER,
+ ..Default::default()
+ }
+ }
+
+ fn allocation_create_info() -> AllocationCreateInfo {
+ AllocationCreateInfo {
+ memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
+ | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+ ..Default::default()
+ }
+ }
+
+ fn to_buffer_data(data: &Vertex3D) -> Self::BufferData {
+ *data
+ }
+}
+
+impl AsVertexBuffer for Vertex3D {}
+
+impl AsBindableBuffer for u32 {
+ type BufferData = u32;
+
+ fn buffer_create_info() -> BufferCreateInfo {
+ BufferCreateInfo {
+ usage: BufferUsage::INDEX_BUFFER,
+ ..Default::default()
+ }
+ }
+
+ fn allocation_create_info() -> AllocationCreateInfo {
+ AllocationCreateInfo {
+ memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
+ | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+ ..Default::default()
+ }
+ }
+
+ fn to_buffer_data(data: &u32) -> Self::BufferData {
+ *data
+ }
+}
+
+impl AsIndexBuffer for u32 {}
diff --git a/src/core/render/render_pass_manager.rs b/src/core/render/render_pass_manager.rs
new file mode 100644
index 0000000..02c3d7a
--- /dev/null
+++ b/src/core/render/render_pass_manager.rs
@@ -0,0 +1,113 @@
+use std::sync::Arc;
+use vulkano::{
+ command_buffer::{AutoCommandBufferBuilder, RenderingAttachmentInfo, RenderingInfo},
+ image::view::ImageView,
+ pipeline::graphics::viewport::Viewport,
+ render_pass::{AttachmentLoadOp, AttachmentStoreOp},
+};
+
+/// Types de render passes disponibles
+#[derive(Debug, Clone)]
+pub enum RenderPassType {
+ Standard,
+ ShadowMap,
+ PostProcess,
+}
+
+/// Configuration pour un render pass
+#[derive(Debug, Clone)]
+pub struct RenderPassConfig {
+ pub pass_type: RenderPassType,
+ pub clear_color: Option<[f32; 4]>,
+ pub clear_depth: Option,
+ pub load_op: AttachmentLoadOp,
+ pub store_op: AttachmentStoreOp,
+}
+
+impl Default for RenderPassConfig {
+ fn default() -> Self {
+ Self {
+ pass_type: RenderPassType::Standard,
+ clear_color: Some([0.0, 0.0, 0.0, 1.0]),
+ clear_depth: Some(1.0),
+ load_op: AttachmentLoadOp::Clear,
+ store_op: AttachmentStoreOp::Store,
+ }
+ }
+}
+
+/// Gestionnaire de render passes réutilisable
+pub struct RenderPassManager;
+
+impl RenderPassManager {
+ /// Commence un render pass standard avec les paramètres donnés
+ pub fn begin_standard_rendering(
+ builder: &mut AutoCommandBufferBuilder,
+ config: &RenderPassConfig,
+ color_attachment: Arc,
+ depth_attachment: Option>,
+ window_size: [f32; 2],
+ ) -> Result<(), Box> {
+ let viewport = Viewport {
+ offset: [0.0, 0.0],
+ extent: window_size,
+ depth_range: 0.0..=1.0,
+ };
+
+ let mut rendering_info = RenderingInfo {
+ color_attachments: vec![Some(RenderingAttachmentInfo {
+ load_op: config.load_op,
+ store_op: config.store_op,
+ clear_value: config.clear_color.map(|c| c.into()),
+ ..RenderingAttachmentInfo::image_view(color_attachment)
+ })],
+ depth_attachment: None,
+ ..Default::default()
+ };
+
+ if let Some(depth_view) = depth_attachment {
+ rendering_info.depth_attachment = Some(RenderingAttachmentInfo {
+ load_op: AttachmentLoadOp::Clear,
+ store_op: AttachmentStoreOp::DontCare,
+ clear_value: config.clear_depth.map(|d| [d].into()),
+ ..RenderingAttachmentInfo::image_view(depth_view)
+ });
+ }
+
+ builder
+ .begin_rendering(rendering_info)?
+ .set_viewport(0, [viewport].into_iter().collect())?;
+
+ Ok(())
+ }
+
+ /// Termine le render pass actuel
+ pub fn end_rendering(
+ builder: &mut AutoCommandBufferBuilder,
+ ) -> Result<(), Box> {
+ builder.end_rendering()?;
+ Ok(())
+ }
+
+ /// Crée une configuration pour un render pass shadow map
+ pub fn shadow_map_config() -> RenderPassConfig {
+ RenderPassConfig {
+ pass_type: RenderPassType::ShadowMap,
+ clear_color: None,
+ clear_depth: Some(1.0),
+ load_op: AttachmentLoadOp::Clear,
+ store_op: AttachmentStoreOp::Store,
+ }
+ }
+
+ /// Crée une configuration pour un render pass de post-processing
+ pub fn post_process_config() -> RenderPassConfig {
+ RenderPassConfig {
+ pass_type: RenderPassType::PostProcess,
+ clear_color: Some([0.0, 0.0, 0.0, 1.0]),
+ clear_depth: None,
+ load_op: AttachmentLoadOp::Load,
+ store_op: AttachmentStoreOp::Store,
+ }
+ }
+}
diff --git a/src/core/render/texture.rs b/src/core/render/texture.rs
new file mode 100644
index 0000000..db0bcc5
--- /dev/null
+++ b/src/core/render/texture.rs
@@ -0,0 +1,168 @@
+use std::{collections::BTreeMap, error::Error, sync::Arc};
+
+use image::DynamicImage;
+use vulkano::{
+ Validated, VulkanError,
+ buffer::{Buffer, BufferCreateInfo, BufferUsage},
+ command_buffer::{AutoCommandBufferBuilder, CopyBufferToImageInfo, PrimaryAutoCommandBuffer},
+ descriptor_set::{
+ DescriptorSet, WriteDescriptorSet,
+ allocator::StandardDescriptorSetAllocator,
+ layout::{DescriptorSetLayout, DescriptorSetLayoutBinding, DescriptorType},
+ },
+ device::Device,
+ format::Format,
+ image::{
+ Image, ImageCreateInfo, ImageType, ImageUsage,
+ sampler::{Filter, Sampler, SamplerAddressMode, SamplerCreateInfo},
+ view::ImageView,
+ },
+ memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator},
+ shader::ShaderStages,
+};
+
+use crate::core::render::primitives::AsBindableDescriptorSet;
+
+pub struct Texture {
+ texture: Arc,
+ sampler: Arc,
+}
+
+impl Texture {
+ fn new(texture: Arc, sampler: Arc) -> Self {
+ Self { texture, sampler }
+ }
+
+ pub fn from_file(
+ device: &Arc,
+ memory_allocator: &Arc,
+ builder: &mut AutoCommandBufferBuilder,
+ path: &str,
+ ) -> Result> {
+ let _span = tracing::info_span!("texture_load_from_file", path = path);
+
+ let bytes = std::fs::read(path)?;
+ Self::from_bytes(device, memory_allocator, builder, &bytes)
+ }
+
+ pub fn from_bytes(
+ device: &Arc,
+ memory_allocator: &Arc,
+ builder: &mut AutoCommandBufferBuilder,
+ bytes: &[u8],
+ ) -> Result> {
+ let image = image::load_from_memory(bytes)?;
+ Self::from_dynamic_image(device, memory_allocator, builder, image)
+ }
+
+ pub fn from_dynamic_image(
+ device: &Arc,
+ memory_allocator: &Arc,
+ builder: &mut AutoCommandBufferBuilder,
+ image: DynamicImage,
+ ) -> Result> {
+ let _span = tracing::info_span!("texture_from_dynamic_image");
+
+ let image_data = image.to_rgba8();
+ let image_dimensions = image_data.dimensions();
+ let image_data = image_data.into_raw();
+
+ let upload_buffer = Buffer::new_slice(
+ memory_allocator.clone(),
+ BufferCreateInfo {
+ usage: BufferUsage::TRANSFER_SRC,
+ ..Default::default()
+ },
+ AllocationCreateInfo {
+ memory_type_filter: MemoryTypeFilter::PREFER_HOST
+ | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+ ..Default::default()
+ },
+ image_data.len() as u64,
+ )?;
+
+ {
+ let buffer_data = &mut *upload_buffer.write()?;
+ buffer_data.copy_from_slice(&image_data);
+ }
+
+ let image = Image::new(
+ memory_allocator.clone(),
+ ImageCreateInfo {
+ image_type: ImageType::Dim2d,
+ format: Format::R8G8B8A8_SRGB,
+ extent: [image_dimensions.0, image_dimensions.1, 1],
+ array_layers: 1,
+ usage: ImageUsage::TRANSFER_DST | ImageUsage::SAMPLED,
+ ..Default::default()
+ },
+ AllocationCreateInfo::default(),
+ )?;
+
+ builder.copy_buffer_to_image(CopyBufferToImageInfo::buffer_image(
+ upload_buffer,
+ image.clone(),
+ ))?;
+
+ let sampler = Sampler::new(
+ device.clone(),
+ SamplerCreateInfo {
+ mag_filter: Filter::Linear,
+ min_filter: Filter::Linear,
+ address_mode: [SamplerAddressMode::Repeat; 3],
+ ..Default::default()
+ },
+ )?;
+
+ let image_view = ImageView::new_default(image)?;
+
+ tracing::trace!("Texture loaded with dimensions {:?}", image_dimensions);
+
+ Ok(Self::new(image_view, sampler))
+ }
+
+ pub fn get_texture(&self) -> &Arc {
+ &self.texture
+ }
+
+ pub fn get_sampler(&self) -> &Arc {
+ &self.sampler
+ }
+}
+
+impl AsBindableDescriptorSet for Texture {
+ fn as_descriptor_set_layout_bindings() -> BTreeMap {
+ BTreeMap::::from_iter([
+ (
+ 0,
+ DescriptorSetLayoutBinding {
+ stages: ShaderStages::FRAGMENT,
+ ..DescriptorSetLayoutBinding::descriptor_type(DescriptorType::Sampler)
+ },
+ ),
+ (
+ 1,
+ DescriptorSetLayoutBinding {
+ stages: ShaderStages::FRAGMENT,
+ ..DescriptorSetLayoutBinding::descriptor_type(DescriptorType::SampledImage)
+ },
+ ),
+ ])
+ }
+
+ fn as_descriptor_set(
+ descriptor_set_allocator: &Arc,
+ layout: &Arc,
+ data: &Texture,
+ ) -> Result, Validated> {
+ DescriptorSet::new(
+ descriptor_set_allocator.clone(),
+ layout.clone(),
+ [
+ WriteDescriptorSet::sampler(0, data.sampler.clone()),
+ WriteDescriptorSet::image_view(1, data.texture.clone()),
+ ],
+ [],
+ )
+ }
+}
diff --git a/src/core/render/vulkan_context.rs b/src/core/render/vulkan_context.rs
new file mode 100644
index 0000000..3d91ec3
--- /dev/null
+++ b/src/core/render/vulkan_context.rs
@@ -0,0 +1,45 @@
+use std::sync::Arc;
+
+use vulkano::{
+ command_buffer::allocator::StandardCommandBufferAllocator,
+ descriptor_set::allocator::StandardDescriptorSetAllocator,
+};
+use vulkano_util::context::VulkanoContext;
+
+pub struct VulkanContext {
+ vulkano_context: VulkanoContext,
+ command_buffer_allocator: Arc,
+ descriptor_set_allocator: Arc,
+}
+
+impl VulkanContext {
+ pub fn new(vulkano_context: VulkanoContext) -> Self {
+ let command_buffer_allocator = Arc::new(StandardCommandBufferAllocator::new(
+ vulkano_context.device().clone(),
+ Default::default(),
+ ));
+
+ let descriptor_set_allocator = Arc::new(StandardDescriptorSetAllocator::new(
+ vulkano_context.device().clone(),
+ Default::default(),
+ ));
+
+ Self {
+ vulkano_context,
+ command_buffer_allocator,
+ descriptor_set_allocator,
+ }
+ }
+
+ pub fn vulkano_context(&self) -> &VulkanoContext {
+ &self.vulkano_context
+ }
+
+ pub fn command_buffer_allocator(&self) -> &Arc {
+ &self.command_buffer_allocator
+ }
+
+ pub fn descriptor_set_allocator(&self) -> &Arc {
+ &self.descriptor_set_allocator
+ }
+}
diff --git a/src/core/scene/manager.rs b/src/core/scene/manager.rs
new file mode 100644
index 0000000..cf07ebc
--- /dev/null
+++ b/src/core/scene/manager.rs
@@ -0,0 +1,65 @@
+use std::error::Error;
+
+use crate::core::app::context::WindowContext;
+
+use super::Scene;
+
+pub struct SceneManager {
+ scenes: Vec>,
+ current_scene_index: Option,
+}
+
+impl SceneManager {
+ pub fn new() -> Self {
+ Self {
+ scenes: Vec::new(),
+ current_scene_index: None,
+ }
+ }
+
+ pub fn load_scene(&mut self, scene: Box) {
+ self.scenes.push(scene);
+ self.current_scene_index = Some(self.scenes.len() - 1);
+ }
+
+ pub fn replace_current_scene(&mut self, scene: Box) {
+ if let Some(index) = self.current_scene_index {
+ if index < self.scenes.len() {
+ self.scenes[index].unload();
+ self.scenes[index] = scene;
+ }
+ } else {
+ self.load_scene(scene);
+ }
+ }
+
+ pub fn current_scene(&self) -> Option<&Box> {
+ if let Some(index) = self.current_scene_index {
+ self.scenes.get(index)
+ } else {
+ None
+ }
+ }
+
+ pub fn current_scene_mut(&mut self) -> Option<&mut Box> {
+ if let Some(index) = self.current_scene_index {
+ self.scenes.get_mut(index)
+ } else {
+ None
+ }
+ }
+
+ pub fn load_scene_if_not_loaded(
+ &mut self,
+ app_context: &mut WindowContext,
+ ) -> Result<(), Box> {
+ if let Some(scene) = self.current_scene_mut() {
+ if !scene.loaded() {
+ scene.load(app_context)?;
+ }
+ } else {
+ tracing::warn!("No scene found in SceneManager!");
+ }
+ Ok(())
+ }
+}
diff --git a/src/core/scene/mod.rs b/src/core/scene/mod.rs
new file mode 100644
index 0000000..5dd8a57
--- /dev/null
+++ b/src/core/scene/mod.rs
@@ -0,0 +1,19 @@
+use std::error::Error;
+
+use vulkano::sync::GpuFuture;
+
+use crate::core::app::context::WindowContext;
+
+pub mod manager;
+
+pub trait Scene {
+ fn loaded(&self) -> bool;
+ fn load(&mut self, app_context: &mut WindowContext) -> Result<(), Box>;
+ fn update(&mut self, app_context: &mut WindowContext) -> Result<(), Box>;
+ fn render(
+ &mut self,
+ acquire_future: Box,
+ app_context: &mut WindowContext,
+ ) -> Result, Box>;
+ fn unload(&mut self);
+}
diff --git a/src/core/timer.rs b/src/core/timer.rs
new file mode 100644
index 0000000..3245a4c
--- /dev/null
+++ b/src/core/timer.rs
@@ -0,0 +1,34 @@
+pub struct Timer {
+ start_time: std::time::Instant,
+ last_time: std::time::Instant,
+ current_time: std::time::Instant,
+ delta_time: f32,
+}
+
+impl Timer {
+ pub fn new() -> Self {
+ Self {
+ start_time: std::time::Instant::now(),
+ last_time: std::time::Instant::now(),
+ current_time: std::time::Instant::now(),
+ delta_time: 0.0,
+ }
+ }
+
+ pub fn update(&mut self) {
+ self.current_time = std::time::Instant::now();
+ self.delta_time = self
+ .current_time
+ .duration_since(self.last_time)
+ .as_secs_f32();
+ self.last_time = self.current_time;
+ }
+
+ pub fn delta_time(&self) -> f32 {
+ self.delta_time
+ }
+
+ pub fn start_time(&self) -> std::time::Instant {
+ self.start_time
+ }
+}
diff --git a/src/game/assets/mod.rs b/src/game/assets/mod.rs
new file mode 100644
index 0000000..d793a66
--- /dev/null
+++ b/src/game/assets/mod.rs
@@ -0,0 +1 @@
+pub mod square;
diff --git a/src/game/assets/square.rs b/src/game/assets/square.rs
new file mode 100644
index 0000000..57e4138
--- /dev/null
+++ b/src/game/assets/square.rs
@@ -0,0 +1,285 @@
+use std::{error::Error, sync::Arc};
+
+use vulkano::{
+ buffer::Subbuffer,
+ command_buffer::{AutoCommandBufferBuilder, PrimaryAutoCommandBuffer},
+ descriptor_set::{
+ DescriptorSet, allocator::StandardDescriptorSetAllocator,
+ layout::DescriptorSetLayoutCreateInfo,
+ },
+ device::Device,
+ format::Format,
+ memory::allocator::StandardMemoryAllocator,
+ pipeline::{
+ DynamicState, GraphicsPipeline, Pipeline, PipelineBindPoint, PipelineLayout,
+ PipelineShaderStageCreateInfo,
+ graphics::{
+ GraphicsPipelineCreateInfo,
+ color_blend::{ColorBlendAttachmentState, ColorBlendState},
+ depth_stencil::{DepthState, DepthStencilState},
+ input_assembly::InputAssemblyState,
+ multisample::MultisampleState,
+ rasterization::RasterizationState,
+ subpass::PipelineRenderingCreateInfo,
+ vertex_input::{Vertex, VertexDefinition},
+ viewport::ViewportState,
+ },
+ layout::{PipelineDescriptorSetLayoutCreateInfo, PipelineLayoutCreateFlags},
+ },
+};
+
+use crate::core::render::{
+ primitives::{
+ AsBindableDescriptorSet, AsDrawable, AsIndexBuffer, AsRecordable, AsVertexBuffer, mvp::Mvp,
+ transform::TransformRaw, vertex::Vertex3D,
+ },
+ texture::Texture,
+};
+
+const VERTICES: [Vertex3D; 4] = [
+ Vertex3D {
+ position: [-0.5, -0.5, 0.0],
+ uv: [0.0, 0.0],
+ },
+ Vertex3D {
+ position: [-0.5, 0.5, 0.0],
+ uv: [0.0, 1.0],
+ },
+ Vertex3D {
+ position: [0.5, -0.5, 0.0],
+ uv: [1.0, 0.0],
+ },
+ Vertex3D {
+ position: [0.5, 0.5, 0.0],
+ uv: [1.0, 1.0],
+ },
+];
+
+const INDICES: [u32; 6] = [0, 2, 1, 2, 3, 1];
+
+pub mod shaders {
+ pub mod vs {
+ vulkano_shaders::shader! {
+ ty: "vertex",
+ path: r"res/shaders/vertex.vert",
+ generate_structs: false,
+ }
+ }
+
+ pub mod fs {
+ vulkano_shaders::shader! {
+ ty: "fragment",
+ path: r"res/shaders/vertex.frag",
+ generate_structs: false,
+ }
+ }
+}
+
+pub struct Square {
+ vertex_buffer: Subbuffer<[Vertex3D]>,
+ index_buffer: Subbuffer<[u32]>,
+ pipeline: Arc,
+}
+
+/// Structure pour encapsuler les données de rendu du Square
+pub struct SquareRenderData<'a> {
+ pub square: &'a Square,
+ pub mvp_uniform: &'a Subbuffer<[Mvp]>,
+ pub transform_uniform: &'a Subbuffer<[TransformRaw]>,
+ pub texture: &'a Texture,
+}
+
+impl Square {
+ pub fn new(
+ device: &Arc,
+ memory_allocator: &Arc,
+ swapchain_format: Format,
+ depth_format: Format,
+ ) -> Result> {
+ let vertex_buffer = Vertex3D::create_vertex_buffer(memory_allocator, &VERTICES)?;
+
+ let index_buffer = u32::create_index_buffer(memory_allocator, &INDICES)?;
+
+ let vs = shaders::vs::load(device.clone())?
+ .entry_point("main")
+ .ok_or("Failed find main entry point of vertex shader".to_string())?;
+
+ let fs = shaders::fs::load(device.clone())?
+ .entry_point("main")
+ .ok_or("Failed find main entry point of fragment shader".to_string())?;
+
+ let vertex_input_state =
+ [Vertex3D::per_vertex(), TransformRaw::per_instance()].definition(&vs)?;
+
+ let stages = [
+ PipelineShaderStageCreateInfo::new(vs),
+ PipelineShaderStageCreateInfo::new(fs),
+ ];
+
+ let vertex_bindings = Mvp::as_descriptor_set_layout_bindings();
+ let texture_bindings = Texture::as_descriptor_set_layout_bindings();
+
+ let vertex_descriptor_set_layout = DescriptorSetLayoutCreateInfo {
+ bindings: vertex_bindings,
+ ..Default::default()
+ };
+
+ let fragment_descriptor_set_layout = DescriptorSetLayoutCreateInfo {
+ bindings: texture_bindings,
+ ..Default::default()
+ };
+
+ let create_info = PipelineDescriptorSetLayoutCreateInfo {
+ set_layouts: vec![vertex_descriptor_set_layout, fragment_descriptor_set_layout],
+ flags: PipelineLayoutCreateFlags::default(),
+ push_constant_ranges: vec![],
+ }
+ .into_pipeline_layout_create_info(device.clone())?;
+
+ let layout = PipelineLayout::new(device.clone(), create_info)?;
+
+ let subpass = PipelineRenderingCreateInfo {
+ color_attachment_formats: vec![Some(swapchain_format)],
+ depth_attachment_format: Some(depth_format),
+ ..Default::default()
+ };
+
+ let pipeline = GraphicsPipeline::new(
+ device.clone(),
+ None,
+ GraphicsPipelineCreateInfo {
+ stages: stages.into_iter().collect(),
+ vertex_input_state: Some(vertex_input_state),
+ input_assembly_state: Some(InputAssemblyState::default()),
+ viewport_state: Some(ViewportState::default()),
+ rasterization_state: Some(RasterizationState::default()),
+ multisample_state: Some(MultisampleState::default()),
+ color_blend_state: Some(ColorBlendState::with_attachment_states(
+ subpass.color_attachment_formats.len() as u32,
+ ColorBlendAttachmentState::default(),
+ )),
+ depth_stencil_state: Some(DepthStencilState {
+ depth: Some(DepthState::simple()),
+ ..Default::default()
+ }),
+ dynamic_state: [DynamicState::Viewport].into_iter().collect(),
+ subpass: Some(subpass.into()),
+ ..GraphicsPipelineCreateInfo::layout(layout)
+ },
+ )?;
+
+ Ok(Self {
+ vertex_buffer,
+ index_buffer,
+ pipeline,
+ })
+ }
+
+ pub fn render(
+ &self,
+ command_buffer: &mut AutoCommandBufferBuilder,
+ descriptor_set_allocator: &Arc,
+ mvp_uniform: &Subbuffer<[Mvp]>,
+ transform_uniform: &Subbuffer<[TransformRaw]>,
+ texture: &Texture,
+ ) -> Result<(), Box