Updated resource creation.

assets/solid.json

@@ -2,14 +2,20 @@
 	"domain": "World",
 	"type": "Surface",
 	"shaders": {
-		"Fragment": "shaders/fragment.besl"
+		"Fragment": "shaders/fragment"
 	},
 	"variables": [
 		{
 			"name": "color",
 			"data_type": "vec4f",
 			"type": "Static",
 			"value": "Purple"
+		},
+		{
+			"name": "texture",
+			"data_type": "Texture2D",
+			"type": "Static",
+			"value": "patterned_brick_floor_02_diff_2k"
 		}
 	]
 }

docs/Design/Resource Management/assets.md

@@ -0,0 +1,5 @@
+Assets are loaded in the following manner:
+- `get()` is called by a user on the resource manager.
+- The resource manager checks if the resource is already cached/processed.
+	- If it is, the resource document is fetched along with it's dependencies which are resolved recursivelly. In the end all resources will be provided to the user is such a manner that they are loaded in the correct order, that is all children will be loaded before their parents.
+	- If it is not, the resource manager will invoke all resource handlers so that they can handle the asset if needed.

docs/Design/Resource Management/index.yml

@@ -0,0 +1,2 @@
+order: 0
+icon: file

docs/Design/Resource Management/readme.md

@@ -0,0 +1,6 @@
+This section details who the asset processing and resource loading is approached in the engine. From the asset loading during development to the resource handling during runtime.
+
+Some terminology to keep in mind:
+* **Asset**: User provided file describing something that you want to consume in your application. (JPEG, PNG, GLTF, JSON, etc)
+* **Resource**: An asset that has been processed by the engine. Contains useful metadata such as binary size, format, hash and the actual resource info like texture extent, mesh vertex description, etc. Resources are usually comprised of both binary data and structured information such as a document where the metadata is stored.
+* **URL**: A URL is a reference to an asset or resource. The asset extension must not be named. The URL can be a filesystem path relative to the /assets folder or an internet URL.

src/render_domain.rs

@@ -3,7 +3,7 @@ use std::{collections::HashMap, hash::Hash};
 use log::{error, trace};
 use maths_rs::{prelude::MatTranslate, Mat4f};
 
-use crate::{resource_manager::{self, mesh_resource_handler, material_resource_handler::{Shader, Material, Variant}}, rendering::{render_system::{RenderSystem, self}, directional_light::DirectionalLight, point_light::PointLight}, Extent, orchestrator::{Entity, System, self, OrchestratorReference}, Vector3, camera::{self, Camera}, math, window_system};
+use crate::{resource_manager::{self, mesh_resource_handler, material_resource_handler::{Shader, Material, Variant}, texture_resource_handler}, rendering::{render_system::{RenderSystem, self}, directional_light::DirectionalLight, point_light::PointLight}, Extent, orchestrator::{Entity, System, self, OrchestratorReference}, Vector3, camera::{self, Camera}, math, window_system};
 
 struct ToneMapPass {
 	pipeline_layout: render_system::PipelineLayoutHandle,
@@ -81,9 +81,11 @@ pub struct VisibilityWorldRenderDomain {
 	material_evaluation_materials: HashMap<String, (u32, render_system::PipelineHandle)>,
 
 	tone_map_pass: ToneMapPass,
-debug_position: render_system::TextureHandle,
-debug_normal: render_system::TextureHandle,
-light_data_buffer: render_system::BufferHandle,
+	debug_position: render_system::TextureHandle,
+	debug_normal: render_system::TextureHandle,
+	light_data_buffer: render_system::BufferHandle,
+
+	pending_texture_loads: Vec<render_system::TextureHandle>,
 }
 
 impl VisibilityWorldRenderDomain {
@@ -147,11 +149,11 @@ impl VisibilityWorldRenderDomain {
 
 			let indices_buffer_handle = render_system.create_buffer(Some("Visibility Index Buffer"), 1024 * 1024 * 16, render_system::Uses::Index | render_system::Uses::Storage, render_system::DeviceAccesses::CpuWrite | render_system::DeviceAccesses::GpuRead, render_system::UseCases::STATIC);
 
-			let debug_position = render_system.create_texture(Some("debug position"), Extent::new(1920, 1080, 1), render_system::TextureFormats::RGBAu16, render_system::Uses::RenderTarget | render_system::Uses::Storage | render_system::Uses::TransferDestination, render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
-			let debug_normal = render_system.create_texture(Some("debug normal"), Extent::new(1920, 1080, 1), render_system::TextureFormats::RGBAu16, render_system::Uses::RenderTarget | render_system::Uses::Storage | render_system::Uses::TransferDestination, render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
+			let debug_position = render_system.create_texture(Some("debug position"), Extent::new(1920, 1080, 1), render_system::TextureFormats::RGBAu16, None, render_system::Uses::RenderTarget | render_system::Uses::Storage | render_system::Uses::TransferDestination, render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
+			let debug_normal = render_system.create_texture(Some("debug normal"), Extent::new(1920, 1080, 1), render_system::TextureFormats::RGBAu16, None, render_system::Uses::RenderTarget | render_system::Uses::Storage | render_system::Uses::TransferDestination, render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
 
-			let albedo = render_system.create_texture(Some("albedo"), Extent::new(1920, 1080, 1), render_system::TextureFormats::RGBAu16, render_system::Uses::RenderTarget | render_system::Uses::Storage | render_system::Uses::TransferDestination, render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
-			let depth_target = render_system.create_texture(Some("depth_target"), Extent::new(1920, 1080, 1), render_system::TextureFormats::Depth32, render_system::Uses::DepthStencil, render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
+			let albedo = render_system.create_texture(Some("albedo"), Extent::new(1920, 1080, 1), render_system::TextureFormats::RGBAu16, None, render_system::Uses::RenderTarget | render_system::Uses::Storage | render_system::Uses::TransferDestination, render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
+			let depth_target = render_system.create_texture(Some("depth_target"), Extent::new(1920, 1080, 1), render_system::TextureFormats::Depth32, None, render_system::Uses::DepthStencil, render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
 
 			let render_finished_synchronizer = render_system.create_synchronizer(true);
 			let image_ready = render_system.create_synchronizer(false);
@@ -343,9 +345,9 @@ impl VisibilityWorldRenderDomain {
 				(&visibility_pass_fragment_shader, render_system::ShaderTypes::Fragment, vec![]),
 			];
 
-			let material_id = render_system.create_texture(Some("material_id"), crate::Extent::new(1920, 1080, 1), render_system::TextureFormats::U32, render_system::Uses::RenderTarget | render_system::Uses::Storage, render_system::DeviceAccesses::GpuWrite | render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
-			let primitive_index = render_system.create_texture(Some("primitive index"), crate::Extent::new(1920, 1080, 1), render_system::TextureFormats::U32, render_system::Uses::RenderTarget | render_system::Uses::Storage, render_system::DeviceAccesses::GpuWrite | render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
-			let instance_id = render_system.create_texture(Some("instance_id"), crate::Extent::new(1920, 1080, 1), render_system::TextureFormats::U32, render_system::Uses::RenderTarget | render_system::Uses::Storage, render_system::DeviceAccesses::GpuWrite | render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
+			let material_id = render_system.create_texture(Some("material_id"), crate::Extent::new(1920, 1080, 1), render_system::TextureFormats::U32, None, render_system::Uses::RenderTarget | render_system::Uses::Storage, render_system::DeviceAccesses::GpuWrite | render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
+			let primitive_index = render_system.create_texture(Some("primitive index"), crate::Extent::new(1920, 1080, 1), render_system::TextureFormats::U32, None, render_system::Uses::RenderTarget | render_system::Uses::Storage, render_system::DeviceAccesses::GpuWrite | render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
+			let instance_id = render_system.create_texture(Some("instance_id"), crate::Extent::new(1920, 1080, 1), render_system::TextureFormats::U32, None, render_system::Uses::RenderTarget | render_system::Uses::Storage, render_system::DeviceAccesses::GpuWrite | render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
 
 			let attachments = [
 				render_system::AttachmentInformation {
@@ -844,7 +846,7 @@ impl VisibilityWorldRenderDomain {
 			}
 			"#;
 
-			let result = render_system.create_texture(Some("result"), Extent::new(1920, 1080, 1), render_system::TextureFormats::RGBAu8, render_system::Uses::Storage | render_system::Uses::TransferDestination, render_system::DeviceAccesses::GpuWrite | render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
+			let result = render_system.create_texture(Some("result"), Extent::new(1920, 1080, 1), render_system::TextureFormats::RGBAu8, None, render_system::Uses::Storage | render_system::Uses::TransferDestination, render_system::DeviceAccesses::GpuWrite | render_system::DeviceAccesses::GpuRead, render_system::UseCases::DYNAMIC);
 
 			let tone_map_pass = {
 				let descriptor_set_layout = render_system.create_descriptor_set_layout(&[
@@ -983,6 +985,8 @@ impl VisibilityWorldRenderDomain {
 				material_evaluation_materials: HashMap::new(),
 
 				tone_map_pass,
+
+				pending_texture_loads: Vec::new(),
 			}
 		})
 			// .add_post_creation_function(Box::new(Self::load_needed_assets))
@@ -998,6 +1002,23 @@ impl VisibilityWorldRenderDomain {
 
 		for resource_document in &response.resources {
 			match resource_document.class.as_str() {
+				"Texture" => {
+					let texture: &texture_resource_handler::Texture = resource_document.resource.downcast_ref().unwrap();
+
+					let compression = if let Some(compression) = &texture.compression {
+						match compression {
+							texture_resource_handler::CompressionSchemes::BC7 => Some(render_system::CompressionSchemes::BC7)
+						}
+					} else {
+						None
+					};
+
+					let new_texture = render_system.create_texture(Some(&resource_document.url), texture.extent, render_system::TextureFormats::RGBAu8, compression, render_system::Uses::Texture | render_system::Uses::TransferDestination, render_system::DeviceAccesses::CpuWrite | render_system::DeviceAccesses::GpuRead, render_system::UseCases::STATIC);
+
+					render_system.get_texture_slice_mut(new_texture).copy_from_slice(&buffer[resource_document.offset as usize..(resource_document.offset + resource_document.size) as usize]);
+
+					self.pending_texture_loads.push(new_texture);
+				}
 				"Shader" => {
 					let shader: &Shader = resource_document.resource.downcast_ref().unwrap();
 
@@ -1194,7 +1215,9 @@ impl VisibilityWorldRenderDomain {
 		{
 			let mut command_buffer_recording = render_system.create_command_buffer_recording(self.transfer_command_buffer, None);
 
-			// TODO: Copy the data from the CPU to the GPU
+			command_buffer_recording.transfer_textures(&self.pending_texture_loads);
+
+			self.pending_texture_loads.clear();
 
 			command_buffer_recording.execute(&[], &[self.transfer_synchronizer], self.transfer_synchronizer);
 		}

src/rendering/render_system.rs

@@ -183,6 +183,8 @@ pub trait CommandBufferRecording {
 	fn clear_texture(&mut self, texture_handle: TextureHandle, clear_value: ClearValue);
 	fn clear_buffer(&mut self, buffer_handle: BufferHandle);
 
+	fn transfer_textures(&mut self, texture_handles: &[TextureHandle]);
+
 	/// Copies texture data from a CPU accessible buffer to a GPU accessible texture.
 	fn write_texture_data(&mut self, texture_handle: TextureHandle, data: &[RGBAu8]);
 
@@ -264,8 +266,10 @@ pub trait RenderSystem: orchestrator::System {
 	// Return a mutable slice to the buffer data.
 	fn get_mut_buffer_slice(&self, buffer_handle: BufferHandle) -> &mut [u8];
 
+	fn get_texture_slice_mut(&self, texture_handle: TextureHandle) -> &mut [u8];
+
 	/// Creates a texture.
-	fn create_texture(&mut self, name: Option<&str>, extent: crate::Extent, format: TextureFormats, resource_uses: Uses, device_accesses: DeviceAccesses, use_case: UseCases) -> TextureHandle;
+	fn create_texture(&mut self, name: Option<&str>, extent: crate::Extent, format: TextureFormats, compression: Option<CompressionSchemes>, resource_uses: Uses, device_accesses: DeviceAccesses, use_case: UseCases) -> TextureHandle;
 
 	fn create_sampler(&mut self) -> SamplerHandle;
 
@@ -390,7 +394,7 @@ pub(super) mod tests {
 		// Use and odd width to make sure there is a middle/center pixel
 		let extent = crate::Extent { width: 1920, height: 1080, depth: 1 };
 
-		let render_target = renderer.create_texture(None, extent, TextureFormats::RGBAu8, Uses::RenderTarget, DeviceAccesses::CpuRead | DeviceAccesses::GpuWrite, UseCases::STATIC);
+		let render_target = renderer.create_texture(None, extent, TextureFormats::RGBAu8, None, Uses::RenderTarget, DeviceAccesses::CpuRead | DeviceAccesses::GpuWrite, UseCases::STATIC);
 
 		let attachments = [
 			AttachmentInformation {
@@ -521,7 +525,7 @@ pub(super) mod tests {
 
 		let pipeline_layout = renderer.create_pipeline_layout(&[], &[]);
 
-		let render_target = renderer.create_texture(None, extent, TextureFormats::RGBAu8, Uses::RenderTarget, DeviceAccesses::GpuWrite, UseCases::STATIC);
+		let render_target = renderer.create_texture(None, extent, TextureFormats::RGBAu8, None, Uses::RenderTarget, DeviceAccesses::GpuWrite, UseCases::STATIC);
 
 		let attachments = [
 			AttachmentInformation {
@@ -646,7 +650,7 @@ pub(super) mod tests {
 
 		let pipeline_layout = renderer.create_pipeline_layout(&[], &[]);
 
-		let render_target = renderer.create_texture(None, extent, TextureFormats::RGBAu8, Uses::RenderTarget, DeviceAccesses::GpuWrite | DeviceAccesses::CpuRead, UseCases::DYNAMIC);
+		let render_target = renderer.create_texture(None, extent, TextureFormats::RGBAu8, None, Uses::RenderTarget, DeviceAccesses::GpuWrite | DeviceAccesses::CpuRead, UseCases::DYNAMIC);
 
 		let attachments = [
 			AttachmentInformation {
@@ -781,7 +785,7 @@ pub(super) mod tests {
 		// Use and odd width to make sure there is a middle/center pixel
 		let extent = crate::Extent { width: 1920, height: 1080, depth: 1 };
 
-		let render_target = renderer.create_texture(None, extent, TextureFormats::RGBAu8, Uses::RenderTarget, DeviceAccesses::CpuRead | DeviceAccesses::GpuWrite, UseCases::DYNAMIC);
+		let render_target = renderer.create_texture(None, extent, TextureFormats::RGBAu8, None, Uses::RenderTarget, DeviceAccesses::CpuRead | DeviceAccesses::GpuWrite, UseCases::DYNAMIC);
 
 		let attachments = [
 			AttachmentInformation {
@@ -919,7 +923,7 @@ pub(super) mod tests {
 		// Use and odd width to make sure there is a middle/center pixel
 		let extent = crate::Extent { width: 1920, height: 1080, depth: 1 };
 
-		let render_target = renderer.create_texture(None, extent, TextureFormats::RGBAu8, Uses::RenderTarget, DeviceAccesses::CpuRead | DeviceAccesses::GpuWrite, UseCases::DYNAMIC);
+		let render_target = renderer.create_texture(None, extent, TextureFormats::RGBAu8, None, Uses::RenderTarget, DeviceAccesses::CpuRead | DeviceAccesses::GpuWrite, UseCases::DYNAMIC);
 
 		let attachments = [
 			AttachmentInformation {
@@ -1083,7 +1087,7 @@ pub(super) mod tests {
 
 		let buffer = renderer.create_buffer(None, 64, Uses::Uniform | Uses::Storage, DeviceAccesses::CpuWrite | DeviceAccesses::GpuRead, UseCases::DYNAMIC);
 
-		let sampled_texture = renderer.create_texture(None, crate::Extent { width: 2, height: 2, depth: 1 }, TextureFormats::RGBAu8, Uses::Texture, DeviceAccesses::CpuWrite | DeviceAccesses::GpuRead, UseCases::STATIC);
+		let sampled_texture = renderer.create_texture(None, crate::Extent { width: 2, height: 2, depth: 1 }, TextureFormats::RGBAu8, None, Uses::Texture, DeviceAccesses::CpuWrite | DeviceAccesses::GpuRead, UseCases::STATIC);
 
 		let pixels = vec![
 			RGBAu8 { r: 255, g: 0, b: 0, a: 255 },
@@ -1138,7 +1142,7 @@ pub(super) mod tests {
 		// Use and odd width to make sure there is a middle/center pixel
 		let extent = crate::Extent { width: 1920, height: 1080, depth: 1 };
 
-		let render_target = renderer.create_texture(None, extent, TextureFormats::RGBAu8, Uses::RenderTarget, DeviceAccesses::CpuRead | DeviceAccesses::GpuWrite, UseCases::STATIC);
+		let render_target = renderer.create_texture(None, extent, TextureFormats::RGBAu8, None, Uses::RenderTarget, DeviceAccesses::CpuRead | DeviceAccesses::GpuWrite, UseCases::STATIC);
 
 		let attachments = [
 			AttachmentInformation {
@@ -1271,6 +1275,11 @@ pub enum TextureFormats {
 U32,
 }
 
+#[derive(Clone, Copy)]
+pub enum CompressionSchemes {
+	BC7,
+}
+
 #[derive(Clone, Copy)]
 /// Stores the information of a memory region.
 pub struct Memory<'a> {
@@ -1665,6 +1674,10 @@ impl RenderSystem for RenderSystemImplementation {
 		self.pointer.get_mut_buffer_slice(buffer_handle)
 	}
 
+	fn get_texture_slice_mut(&self, texture_handle: TextureHandle) -> &mut [u8] {
+		self.pointer.get_texture_slice_mut(texture_handle)
+	}
+
 	fn get_texture_data(&self, texture_copy_handle: TextureCopyHandle) -> &[u8] {
 		self.pointer.get_texture_data(texture_copy_handle)
 	}
@@ -1737,7 +1750,7 @@ impl RenderSystem for RenderSystemImplementation {
 		self.pointer.create_synchronizer(signaled)
 	}
 
-	fn create_texture(&mut self, name: Option<&str>, extent: crate::Extent, format: TextureFormats, resource_uses: Uses, device_accesses: DeviceAccesses, use_case: UseCases) -> TextureHandle {
-		self.pointer.create_texture(name, extent, format, resource_uses, device_accesses, use_case)
+	fn create_texture(&mut self, name: Option<&str>, extent: crate::Extent, format: TextureFormats, compression: Option<CompressionSchemes>, resource_uses: Uses, device_accesses: DeviceAccesses, use_case: UseCases) -> TextureHandle {
+		self.pointer.create_texture(name, extent, format, compression, resource_uses, device_accesses, use_case)
 	}
 }