(&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
deleted file mode 100644
index ec7ac54..0000000
--- a/src/core/render/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-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
deleted file mode 100644
index e01226f..0000000
--- a/src/core/render/primitives/buffer.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-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
deleted file mode 100644
index 4fdf1ae..0000000
--- a/src/core/render/primitives/camera.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-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
deleted file mode 100644
index 37970a1..0000000
--- a/src/core/render/primitives/command.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-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
deleted file mode 100644
index 8ef9dd7..0000000
--- a/src/core/render/primitives/mod.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-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
deleted file mode 100644
index 0f47ce3..0000000
--- a/src/core/render/primitives/mvp.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-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
deleted file mode 100644
index 7ea75e7..0000000
--- a/src/core/render/primitives/resource.rs
+++ /dev/null
@@ -1,208 +0,0 @@
-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
deleted file mode 100644
index d7c1249..0000000
--- a/src/core/render/primitives/transform.rs
+++ /dev/null
@@ -1,163 +0,0 @@
-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
deleted file mode 100644
index 2a27b36..0000000
--- a/src/core/render/primitives/vertex.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-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
deleted file mode 100644
index 02c3d7a..0000000
--- a/src/core/render/render_pass_manager.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-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
deleted file mode 100644
index db0bcc5..0000000
--- a/src/core/render/texture.rs
+++ /dev/null
@@ -1,168 +0,0 @@
-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
deleted file mode 100644
index 3d91ec3..0000000
--- a/src/core/render/vulkan_context.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-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
deleted file mode 100644
index cf07ebc..0000000
--- a/src/core/scene/manager.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-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
deleted file mode 100644
index 5dd8a57..0000000
--- a/src/core/scene/mod.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index 3245a4c..0000000
--- a/src/core/timer.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-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
deleted file mode 100644
index d793a66..0000000
--- a/src/game/assets/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub mod square;
diff --git a/src/game/assets/square.rs b/src/game/assets/square.rs
deleted file mode 100644
index 57e4138..0000000
--- a/src/game/assets/square.rs
+++ /dev/null
@@ -1,285 +0,0 @@
-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