Update resource manager module

src/application.rs

@@ -60,7 +60,7 @@ impl Application for BaseApplication {
 use log::{info, trace};
 use maths_rs::prelude::Base;
 
-use crate::{orchestrator::{self, EntityHandle}, window_system, input_manager, Vector2, rendering::{self}, resource_manager, file_tracker, audio::audio_system};
+use crate::{orchestrator::{self, EntityHandle}, window_system, input_manager, Vector2, rendering::{self}, resource_management, file_tracker, audio::audio_system};
 
 /// An orchestrated application is an application that uses the orchestrator to manage systems.
 /// It is the recommended way to create a simple application.
@@ -137,7 +137,7 @@ impl Application for GraphicsApplication {
 
 		let orchestrator = application.get_mut_orchestrator();
 
-		let resource_manager_handle = orchestrator.spawn_entity(resource_manager::resource_manager::ResourceManager::new_as_system()).unwrap();
+		let resource_manager_handle = orchestrator.spawn_entity(resource_management::resource_manager::ResourceManager::new_as_system()).unwrap();
 
 		let window_system_handle = orchestrator.spawn_entity(window_system::WindowSystem::new_as_system()).unwrap();
 		let input_system_handle = orchestrator.spawn_entity(input_manager::InputManager::new_as_system()).unwrap();

src/audio/audio_system.rs

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 use crate::{orchestrator::{System, Entity, EntityReturn}, ahi::{audio_hardware_interface::AudioHardwareInterface, self}};
 use crate::orchestrator::EntityHandle;
-use crate::resource_manager::audio_resource_handler;
-use crate::resource_manager::resource_manager::ResourceManager;
+use crate::resource_management::audio_resource_handler;
+use crate::resource_management::resource_manager::ResourceManager;
 
 pub trait AudioSystem: System {
 	/// Plays an audio asset.

src/lib.rs

@@ -15,7 +15,7 @@ pub mod application;
 pub mod orchestrator;
 pub mod window_system;
 pub mod render_debugger;
-pub mod resource_manager;
+pub mod resource_management;
 pub mod shader_generator;
 pub mod input_manager;
 pub mod file_tracker;

src/rendering/renderer.rs

@@ -1,6 +1,6 @@
 use std::{ops::{DerefMut, Deref}, rc::Rc, sync::RwLock};
 
-use crate::{orchestrator::{self, EntityHandle}, window_system::{self, WindowSystem}, Extent, resource_manager::resource_manager::ResourceManager, ghi::{self, GraphicsHardwareInterface}};
+use crate::{orchestrator::{self, EntityHandle}, window_system::{self, WindowSystem}, Extent, resource_management::resource_manager::ResourceManager, ghi::{self, GraphicsHardwareInterface}};
 
 use super::{visibility_model::render_domain::VisibilityWorldRenderDomain, aces_tonemap_render_pass::AcesToneMapPass, tonemap_render_pass::ToneMapRenderPass, world_render_domain::WorldRenderDomain};
 

src/rendering/visibility_model/render_domain.rs

@@ -11,8 +11,8 @@ use crate::ghi;
 use crate::orchestrator::EntityHandle;
 use crate::rendering::{mesh, directional_light, point_light};
 use crate::rendering::world_render_domain::WorldRenderDomain;
-use crate::resource_manager::resource_manager::ResourceManager;
-use crate::{resource_manager::{self, mesh_resource_handler, material_resource_handler::{Shader, Material, Variant}, texture_resource_handler}, Extent, orchestrator::{Entity, System, self, OrchestratorReference}, Vector3, camera::{self}, math};
+use crate::resource_management::resource_manager::ResourceManager;
+use crate::{resource_management::{self, mesh_resource_handler, material_resource_handler::{Shader, Material, Variant}, texture_resource_handler}, Extent, orchestrator::{Entity, System, self, OrchestratorReference}, Vector3, camera::{self}, math};
 
 struct VisibilityInfo {
 	instance_count: u32,
@@ -587,7 +587,7 @@ impl VisibilityWorldRenderDomain {
 			.add_listener::<point_light::PointLight>()
 	}
 
-	fn load_material(&mut self, resource_manager: &mut resource_manager::resource_manager::ResourceManager, asset_url: &str) {
+	fn load_material(&mut self, resource_manager: &mut resource_management::resource_manager::ResourceManager, asset_url: &str) {
 		let (response, buffer) = resource_manager.get(asset_url).unwrap();
 
 		let mut ghi = self.ghi.write().unwrap();
@@ -634,17 +634,17 @@ impl VisibilityWorldRenderDomain {
 					let size = resource_document.size as usize;
 
 					let stage = match shader.stage {
-						resource_manager::material_resource_handler::ShaderTypes::AnyHit => ghi::ShaderTypes::AnyHit,
-						resource_manager::material_resource_handler::ShaderTypes::ClosestHit => ghi::ShaderTypes::ClosestHit,
-						resource_manager::material_resource_handler::ShaderTypes::Compute => ghi::ShaderTypes::Compute,
-						resource_manager::material_resource_handler::ShaderTypes::Fragment => ghi::ShaderTypes::Fragment,
-						resource_manager::material_resource_handler::ShaderTypes::Intersection => ghi::ShaderTypes::Intersection,
-						resource_manager::material_resource_handler::ShaderTypes::Mesh => ghi::ShaderTypes::Mesh,
-						resource_manager::material_resource_handler::ShaderTypes::Miss => ghi::ShaderTypes::Miss,
-						resource_manager::material_resource_handler::ShaderTypes::RayGen => ghi::ShaderTypes::RayGen,
-						resource_manager::material_resource_handler::ShaderTypes::Callable => ghi::ShaderTypes::Callable,
-						resource_manager::material_resource_handler::ShaderTypes::Task => ghi::ShaderTypes::Task,
-						resource_manager::material_resource_handler::ShaderTypes::Vertex => ghi::ShaderTypes::Vertex,
+						resource_management::material_resource_handler::ShaderTypes::AnyHit => ghi::ShaderTypes::AnyHit,
+						resource_management::material_resource_handler::ShaderTypes::ClosestHit => ghi::ShaderTypes::ClosestHit,
+						resource_management::material_resource_handler::ShaderTypes::Compute => ghi::ShaderTypes::Compute,
+						resource_management::material_resource_handler::ShaderTypes::Fragment => ghi::ShaderTypes::Fragment,
+						resource_management::material_resource_handler::ShaderTypes::Intersection => ghi::ShaderTypes::Intersection,
+						resource_management::material_resource_handler::ShaderTypes::Mesh => ghi::ShaderTypes::Mesh,
+						resource_management::material_resource_handler::ShaderTypes::Miss => ghi::ShaderTypes::Miss,
+						resource_management::material_resource_handler::ShaderTypes::RayGen => ghi::ShaderTypes::RayGen,
+						resource_management::material_resource_handler::ShaderTypes::Callable => ghi::ShaderTypes::Callable,
+						resource_management::material_resource_handler::ShaderTypes::Task => ghi::ShaderTypes::Task,
+						resource_management::material_resource_handler::ShaderTypes::Vertex => ghi::ShaderTypes::Vertex,
 					};
 
 					let new_shader = ghi.create_shader(ghi::ShaderSource::SPIRV(&buffer[offset..(offset + size)]), stage, &[
@@ -977,7 +977,7 @@ impl orchestrator::EntitySubscriber<mesh::Mesh> for VisibilityWorldRenderDomain
 
 			let resource_request = if let Some(resource_info) = resource_request { resource_info } else { return; };
 
-			let mut options = resource_manager::Options { resources: Vec::new(), };
+			let mut options = resource_management::Options { resources: Vec::new(), };
 
 			let mut meshlet_stream_buffer = vec![0u8; 1024 * 8];
 
@@ -990,15 +990,15 @@ impl orchestrator::EntitySubscriber<mesh::Mesh> for VisibilityWorldRenderDomain
 						let primitive_indices_buffer = ghi.get_mut_buffer_slice(self.primitive_indices_buffer);
 						let triangle_indices_buffer = ghi.get_mut_buffer_slice(self.triangle_indices_buffer);
 
-						options.resources.push(resource_manager::OptionResource {
+						options.resources.push(resource_management::OptionResource {
 							url: resource.url.clone(),
 							streams: vec![
-								resource_manager::Stream{ buffer: &mut vertex_positions_buffer[(self.visibility_info.vertex_count as usize * std::mem::size_of::<Vector3>())..], name: "Vertex.Position".to_string() },
-								resource_manager::Stream{ buffer: &mut vertex_normals_buffer[(self.visibility_info.vertex_count as usize * std::mem::size_of::<Vector3>())..], name: "Vertex.Normal".to_string() },
-								resource_manager::Stream{ buffer: &mut triangle_indices_buffer[(self.visibility_info.triangle_count as usize * 3 * std::mem::size_of::<u16>())..], name: "TriangleIndices".to_string() },
-								resource_manager::Stream{ buffer: &mut vertex_indices_buffer[(self.visibility_info.vertex_count as usize * std::mem::size_of::<u16>())..], name: "VertexIndices".to_string() },
-								resource_manager::Stream{ buffer: &mut primitive_indices_buffer[(self.visibility_info.triangle_count as usize * 3 * std::mem::size_of::<u8>())..], name: "MeshletIndices".to_string() },
-								resource_manager::Stream{ buffer: meshlet_stream_buffer.as_mut_slice() , name: "Meshlets".to_string() },
+								resource_management::Stream{ buffer: &mut vertex_positions_buffer[(self.visibility_info.vertex_count as usize * std::mem::size_of::<Vector3>())..], name: "Vertex.Position".to_string() },
+								resource_management::Stream{ buffer: &mut vertex_normals_buffer[(self.visibility_info.vertex_count as usize * std::mem::size_of::<Vector3>())..], name: "Vertex.Normal".to_string() },
+								resource_management::Stream{ buffer: &mut triangle_indices_buffer[(self.visibility_info.triangle_count as usize * 3 * std::mem::size_of::<u16>())..], name: "TriangleIndices".to_string() },
+								resource_management::Stream{ buffer: &mut vertex_indices_buffer[(self.visibility_info.vertex_count as usize * std::mem::size_of::<u16>())..], name: "VertexIndices".to_string() },
+								resource_management::Stream{ buffer: &mut primitive_indices_buffer[(self.visibility_info.triangle_count as usize * 3 * std::mem::size_of::<u8>())..], name: "MeshletIndices".to_string() },
+								resource_management::Stream{ buffer: meshlet_stream_buffer.as_mut_slice() , name: "Meshlets".to_string() },
 							],
 						});
 

src/resource_manager/audio_resource_handler.rs → src/resource_management/audio_resource_handler.rs

@@ -151,7 +151,7 @@ impl Resource for Audio {
 mod tests {
 	use super::*;
 
-	use crate::resource_manager::resource_manager::ResourceManager;
+	use crate::resource_management::resource_manager::ResourceManager;
 
 	#[test]
 	fn test_audio_resource_handler() {

src/resource_manager/material_resource_handler.rs → src/resource_management/material_resource_handler.rs

@@ -295,7 +295,7 @@ impl MaterialResourcerHandler {
 
 #[cfg(test)]
 mod tests {
-    use crate::resource_manager::resource_manager::ResourceManager;
+    use crate::resource_management::resource_manager::ResourceManager;
 
 	#[test]
 	fn load_material() {

src/resource_manager/mesh_resource_handler.rs → src/resource_management/mesh_resource_handler.rs

@@ -407,7 +407,7 @@ impl Size for IntegralTypes {
 
 #[cfg(test)]
 mod tests {
-	use crate::{resource_manager::{resource_manager::ResourceManager, Options, OptionResource, Stream}, Vector3};
+	use crate::{resource_management::{resource_manager::ResourceManager, Options, OptionResource, Stream}, Vector3};
 
 	use super::*;
 

src/resource_manager/texture_resource_handler.rs → src/resource_management/texture_resource_handler.rs

@@ -2,7 +2,7 @@ use std::io::Read;
 
 use serde::{Serialize, Deserialize};
 
-use crate::resource_manager::GenericResourceSerialization;
+use crate::resource_management::GenericResourceSerialization;
 
 use super::{Resource, ProcessedResources, resource_manager::ResourceManager, resource_handler::ResourceHandler};
 
@@ -99,7 +99,7 @@ impl Resource for Texture {
 
 #[cfg(test)]
 mod tests {
-	use crate::resource_manager::resource_manager::ResourceManager;
+	use crate::resource_management::resource_manager::ResourceManager;
 
 	use super::*;