diff --git a/resource_management/src/asset/asset_handler.rs b/resource_management/src/asset/asset_handler.rs
new file mode 100644
index 00000000..28d4a774
--- /dev/null
+++ b/resource_management/src/asset/asset_handler.rs
@@ -0,0 +1,17 @@
+/// An asset handler is responsible for loading assets of a certain type from a url.
+pub trait AssetHandler {
+	/// Load an asset from a url.
+	/// # Arguments
+	/// * `url` - The absolute url of the source asset.
+	/// * `json` - The JSON asset description.
+	/// 	## Example
+	/// 	```json
+	/// 	{
+	/// 		"url": "/path/to/asset",
+	/// 	}
+	/// 	```
+	/// # Returns
+	/// Returns Some(...) if the asset was managed by this handler, None otherwise.
+	/// Returns Some(Ok(...)) if the asset was loaded successfully, Some(Err(...)) otherwise.
+	fn load(&self, url: &str, json: &json::JsonValue) -> utils::BoxedFuture<Option<Result<(), String>>>;
+}
\ No newline at end of file
diff --git a/resource_management/src/asset/asset_manager.rs b/resource_management/src/asset/asset_manager.rs
new file mode 100644
index 00000000..c1ba1208
--- /dev/null
+++ b/resource_management/src/asset/asset_manager.rs
@@ -0,0 +1,117 @@
+use super::asset_handler::AssetHandler;
+
+struct AssetManager {
+	asset_handlers: Vec<Box<dyn AssetHandler>>,
+}
+
+/// Enumeration of the possible messages that can be returned when loading an asset.
+#[derive(Debug, PartialEq, Eq)]
+pub enum LoadMessages {
+	/// The URL was missing in the asset JSON.
+	NoURL,
+	/// No asset handler was found for the asset.
+	NoAssetHandler,
+}
+
+impl AssetManager {
+	pub fn new() -> AssetManager {
+		AssetManager {
+			asset_handlers: Vec::new(),
+		}
+	}
+
+	pub fn add_asset_handler<T: AssetHandler + 'static>(&mut self, asset_handler: T) {
+		self.asset_handlers.push(Box::new(asset_handler));
+	}
+
+	/// Load a source asset from a JSON asset description.
+	pub async fn load(&self, json: &json::JsonValue) -> Result<(), LoadMessages> {
+		let url = json["url"].as_str().ok_or(LoadMessages::NoURL)?; // Source asset url
+
+		let asset_handler_loads = self.asset_handlers.iter().map(|asset_handler| asset_handler.load(url, &json));
+
+		let load_results = futures::future::join_all(asset_handler_loads).await;
+
+		let asset_handler_found = load_results.iter().any(|load_result| { if let Some(Ok(_)) = load_result { true } else { false } });
+
+		if !asset_handler_found {
+			return Err(LoadMessages::NoAssetHandler);
+		}
+
+		Ok(())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use smol::future::FutureExt;
+
+	use super::*;
+
+	struct TestAssetHandler {
+
+	}
+
+	impl TestAssetHandler {
+		fn new() -> TestAssetHandler {
+			TestAssetHandler {}
+		}
+	}
+
+	impl AssetHandler for TestAssetHandler {
+		fn load(&self, url: &str) -> utils::BoxedFuture<Option<Result<(), String>>> {
+			let res = if url == "http://example.com" {
+				Some(Ok(()))
+			} else {
+				None
+			};
+
+			async move { res }.boxed()
+		}
+	}
+	
+	#[test]
+	fn test_new() {
+		let asset_manager = AssetManager::new();
+	}
+
+	#[test]
+	fn test_add_asset_manager() {
+		let mut asset_manager = AssetManager::new();
+
+		let test_asset_handler = TestAssetHandler::new();
+
+		asset_manager.add_asset_handler(test_asset_handler);
+	}
+
+	#[test]
+	fn test_load_with_asset_manager() {
+		let mut asset_manager = AssetManager::new();
+
+		let test_asset_handler = TestAssetHandler::new();
+
+		asset_manager.add_asset_handler(test_asset_handler);
+
+		let json = json::parse(r#"{"url": "http://example.com"}"#).unwrap();
+
+		assert_eq!(smol::block_on(asset_manager.load(&json)), Ok(()));
+	}
+
+	#[test]
+	fn test_load_no_asset_handler() {
+		let asset_manager = AssetManager::new();
+
+		let json = json::parse(r#"{"url": "http://example.com"}"#).unwrap();
+
+		assert_eq!(smol::block_on(asset_manager.load(&json)), Err(LoadMessages::NoAssetHandler));
+	}
+
+	#[test]
+	fn test_load_no_asset_url() {
+		let asset_manager = AssetManager::new();
+
+		let json = json::parse(r#"{}"#).unwrap();
+
+		assert_eq!(smol::block_on(asset_manager.load(&json)), Err(LoadMessages::NoURL));
+	}
+}
\ No newline at end of file
diff --git a/resource_management/src/asset/audio_asset_handler.rs b/resource_management/src/asset/audio_asset_handler.rs
new file mode 100644
index 00000000..c0a98ff9
--- /dev/null
+++ b/resource_management/src/asset/audio_asset_handler.rs
@@ -0,0 +1,135 @@
+use smol::future::FutureExt;
+
+use crate::types::{Audio, BitDepths};
+
+use super::{asset_handler::AssetHandler, read_asset_from_source};
+
+struct AudioAssetHandler {
+
+}
+
+impl AudioAssetHandler {
+	fn new() -> AudioAssetHandler {
+		AudioAssetHandler {}
+	}
+}
+
+impl AssetHandler for AudioAssetHandler {
+	fn load(&self, url: &str, json: &json::JsonValue) -> utils::BoxedFuture<Option<Result<(), String>>> {
+		async move {
+			let (data, dt) = read_asset_from_source(url, None).await.unwrap();
+
+			let riff = &data[0..4];
+
+			if riff != b"RIFF" {
+				return Err("Invalid RIFF header".to_string());
+			}
+
+			let format = &data[8..12];
+
+			if format != b"WAVE" {
+				return Err("Invalid WAVE format".to_string());
+			}
+
+			let audio_format = &data[20..22];
+
+			if audio_format != b"\x01\x00" {
+				return Err("Invalid audio format".to_string());
+			}
+
+			let subchunk_1_size = &data[16..20];
+
+			let subchunk_1_size = u32::from_le_bytes([subchunk_1_size[0], subchunk_1_size[1], subchunk_1_size[2], subchunk_1_size[3]]);
+
+			if subchunk_1_size != 16 {
+				return Err("Invalid subchunk 1 size".to_string());
+			}
+
+			let num_channels = &data[22..24];
+
+			let num_channels = u16::from_le_bytes([num_channels[0], num_channels[1]]);
+
+			if num_channels != 1 && num_channels != 2 {
+				return Err("Invalid number of channels".to_string());
+			}
+
+			let sample_rate = &data[24..28];
+
+			let sample_rate = u32::from_le_bytes([sample_rate[0], sample_rate[1], sample_rate[2], sample_rate[3]]);
+
+			let bits_per_sample = &data[34..36];
+
+			let bits_per_sample = u16::from_le_bytes([bits_per_sample[0], bits_per_sample[1]]);
+
+			let bit_depth = match bits_per_sample {
+				8 => BitDepths::Eight,
+				16 => BitDepths::Sixteen,
+				24 => BitDepths::TwentyFour,
+				32 => BitDepths::ThirtyTwo,
+				_ => { return Err("Invalid bits per sample".to_string()); }
+			};
+
+			let data_header = &data[36..40];
+
+			if data_header != b"data" {
+				return Err("Invalid data header".to_string());
+			}
+
+			let data_size = &data[40..44];
+
+			let data_size = u32::from_le_bytes([data_size[0], data_size[1], data_size[2], data_size[3]]);
+
+			let sample_count = data_size / (bits_per_sample / 8) as u32 / num_channels as u32;
+
+			let data = &data[44..][..data_size as usize];
+
+			let audio_resource = Audio {
+				bit_depth,
+				channel_count: num_channels,
+				sample_rate,
+				sample_count,
+			};
+
+			// Ok(
+			// 	vec![
+			// 		ProcessedResources::Generated((
+			// 			GenericResourceSerialization::new(asset_url.to_string(), audio_resource),
+			// 			Vec::from(data),
+			// 		))
+			// 	]
+			
+			// )
+
+			Ok(Some(()))
+		}.boxed()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn test_audio_asset_handler() {
+		let audio_asset_handler = AudioAssetHandler::new();
+
+		let url = "gun";
+		let doc = json::object! {
+			"url": url,
+		};
+
+		smol::block_on(audio_asset_handler.load(url, &doc)).expect("Audio asset handler did not handle asset");
+
+		// assert_eq!(resource.url, "gun");
+		// assert_eq!(resource.class, "Audio");
+
+		// let audio = resource.resource.downcast_ref::<Audio>().unwrap();
+
+		// assert_eq!(audio.bit_depth, BitDepths::Sixteen);
+		// assert_eq!(audio.channel_count, 1);
+		// assert_eq!(audio.sample_rate, 48000);
+		// assert_eq!(audio.sample_count, 152456 / 1 / (16 / 8));
+
+		// assert_eq!(buffer.len(), audio.sample_count as usize * audio.channel_count as usize * (Into::<usize>::into(audio.bit_depth) / 8) as usize);
+	}
+}
\ No newline at end of file
diff --git a/resource_management/src/asset/image_asset_handler.rs b/resource_management/src/asset/image_asset_handler.rs
new file mode 100644
index 00000000..034bd284
--- /dev/null
+++ b/resource_management/src/asset/image_asset_handler.rs
@@ -0,0 +1,114 @@
+use utils::Extent;
+
+use crate::{types::{CompressionSchemes, Formats, Image}, GenericResourceSerialization};
+
+use super::{asset_handler::AssetHandler, read_asset_from_source};
+
+struct ImageAssetHandler {
+}
+
+impl ImageAssetHandler {
+	fn new() -> ImageAssetHandler {
+		ImageAssetHandler {}
+	}
+}
+
+impl AssetHandler for ImageAssetHandler {
+	fn load(&self, url: &str, json: &json::JsonValue) -> utils::BoxedFuture<Option<Result<(), String>>> {
+		async move {
+			let (data, dt) = read_asset_from_source(url, None).await.unwrap();
+
+			let mut decoder = png::Decoder::new(data.as_slice());
+			decoder.set_transformations(png::Transformations::normalize_to_color8());
+			let mut reader = decoder.read_info().unwrap();
+			let mut buffer = vec![0; reader.output_buffer_size()];
+			let info = reader.next_frame(&mut buffer).unwrap();
+
+			let extent = Extent::rectangle(info.width, info.height);
+
+			assert_eq!(extent.depth(), 1); // TODO: support 3D textures
+
+			let format = match info.color_type {
+				png::ColorType::Rgb => {
+					match info.bit_depth {
+						png::BitDepth::Eight => Formats::RGB8,
+						png::BitDepth::Sixteen => Formats::RGB16,
+						_ => { panic!("Unsupported bit depth") }
+					}
+				}
+				png::ColorType::Rgba => {
+					match info.bit_depth {
+						png::BitDepth::Eight => Formats::RGBA8,
+						png::BitDepth::Sixteen => Formats::RGBA16,
+						_ => { panic!("Unsupported bit depth") }
+					}
+				}
+				_ => { panic!("Unsupported color type") }
+			};
+			
+			let (data, compression) = match format {
+				Formats::RGB8 => {
+					let mut buf: Vec<u8> = Vec::with_capacity(extent.width() as usize * extent.height() as usize * 4);
+
+					for y in 0..extent.height() {
+						for x in 0..extent.width() {
+							let index = ((x + y * extent.width()) * 3) as usize;
+							buf.push(data[index + 0]);
+							buf.push(data[index + 1]);
+							buf.push(data[index + 2]);
+							buf.push(255);
+						}
+					}
+
+					let rgba_surface = intel_tex_2::RgbaSurface {
+						data: &buf,
+						width: extent.width(),
+						height: extent.height(),
+						stride: extent.width() * 4,
+					};
+		
+					let settings = intel_tex_2::bc7::opaque_ultra_fast_settings();
+
+					(intel_tex_2::bc7::compress_blocks(&settings, &rgba_surface), Some(CompressionSchemes::BC7))
+				}
+				Formats::RGB16 => {
+					let mut buf: Vec<u8> = Vec::with_capacity(extent.width() as usize * extent.height() as usize * 8);
+
+					for y in 0..extent.height() {
+						for x in 0..extent.width() {
+							let index = ((x + y * extent.width()) * 6) as usize;
+							buf.push(data[index + 0]); buf.push(data[index + 1]);
+							buf.push(data[index + 2]); buf.push(data[index + 3]);
+							buf.push(data[index + 4]); buf.push(data[index + 5]);
+							buf.push(255); buf.push(255);
+						}
+					}
+
+					let rgba_surface = intel_tex_2::RgbaSurface {
+						data: &buf,
+						width: extent.width(),
+						height: extent.height(),
+						stride: extent.width() * 8,
+					};
+		
+					let settings = intel_tex_2::bc7::opaque_ultra_fast_settings();
+
+					(intel_tex_2::bc7::compress_blocks(&settings, &rgba_surface), Some(CompressionSchemes::BC7))
+				}
+				_ => {
+					(data, None)
+				}
+			};
+
+			let resource_document = GenericResourceSerialization::new(url.to_string(), Image {
+				format,
+				extent: extent.as_array(),
+				compression,
+			});
+
+			// Ok(vec![ProcessedResources::Generated((resource_document, data))])
+
+			Ok(())
+		}.boxed()
+	}
+}
\ No newline at end of file
diff --git a/resource_management/src/asset/material_asset_handler.rs b/resource_management/src/asset/material_asset_handler.rs
new file mode 100644
index 00000000..ea4a96ef
--- /dev/null
+++ b/resource_management/src/asset/material_asset_handler.rs
@@ -0,0 +1,85 @@
+use crate::{types::{AlphaMode, Material, Model, Property, Value, Variant, VariantVariable}, GenericResourceSerialization, ProcessedResources};
+
+use super::{asset_handler::AssetHandler, read_asset_from_source};
+
+struct MaterialAssetHandler {
+}
+
+impl MaterialAssetHandler {
+	fn new() -> MaterialAssetHandler {
+		MaterialAssetHandler {}
+	}
+}
+
+impl AssetHandler for MaterialAssetHandler {
+	fn load(&self, url: &str, json: &json::JsonValue) -> utils::BoxedFuture<Option<Result<(), String>>> {
+		async move {
+			let (data, at) = read_asset_from_source(url, None).await.unwrap();
+
+			let asset_json = json::parse(std::str::from_utf8(&data).unwrap()).unwrap(); // False
+
+			let is_material = asset_json["parent"].is_null();
+
+			if is_material {
+				let material_domain = match &asset_json["domain"] {
+					json::JsonValue::Null => { "Common".to_string() }
+					json::JsonValue::Short(s) => { s.to_string() }
+					json::JsonValue::String(s) => { s.to_string() }
+					_ => { panic!("Invalid domain") }
+				};
+
+				let _material_type = match &asset_json["type"] {
+					json::JsonValue::Null => { "Raw".to_string() }
+					json::JsonValue::Short(s) => { s.to_string() }
+					json::JsonValue::String(s) => { s.to_string() }
+					_ => { panic!("Invalid type") }
+				};
+				
+				let mut required_resources = asset_json["shaders"].entries().filter_map(|(s_type, shader_json)| {
+					// smol::block_on(self.produce_shader(resource_manager, &material_domain, &asset_json, &shader_json, s_type))
+				}).collect::<Vec<_>>();
+
+				for variable in asset_json["variables"].members() {
+					if variable["data_type"].as_str().unwrap() == "Texture2D" {
+						let texture_url = variable["value"].as_str().unwrap();
+
+						required_resources.push(ProcessedResources::Reference(texture_url.to_string()));
+					}
+				}
+
+				Ok(vec![ProcessedResources::Generated((GenericResourceSerialization::new(url.to_string(), Material {
+					albedo: Property::Factor(Value::Vector3([1f32, 0f32, 0f32])),
+					normal: Property::Factor(Value::Vector3([0f32, 0f32, 1f32])),
+					roughness: Property::Factor(Value::Scalar(0.5f32)),
+					metallic: Property::Factor(Value::Scalar(0.0f32)),
+					emissive: Property::Factor(Value::Vector3([0f32, 0f32, 0f32])),
+					occlusion: Property::Factor(Value::Scalar(0f32)),
+					double_sided: false,
+					alpha_mode: AlphaMode::Opaque,
+					model: Model {
+						name: Self::RENDER_MODEL.to_string(),
+						pass: "MaterialEvaluation".to_string(),
+					},
+				}).required_resources(&required_resources), Vec::new()))])
+			} else {
+				let variant_json = asset_json;
+
+				let parent_material_url = variant_json["parent"].as_str().unwrap();
+
+				let material_resource_document = GenericResourceSerialization::new(url.to_string(), Variant{
+					parent: parent_material_url.to_string(),
+					variables: variant_json["variables"].members().map(|v| {
+						VariantVariable {
+							name: v["name"].to_string(),
+							value: v["value"].to_string(),
+						}
+					}).collect::<Vec<_>>()
+				}).required_resources(&[ProcessedResources::Reference(parent_material_url.to_string())]);
+
+				Ok(vec![ProcessedResources::Generated((material_resource_document.into(), Vec::new()))])
+			}
+
+			Ok(())
+		}.boxed()
+	}
+}
\ No newline at end of file
diff --git a/resource_management/src/asset/mesh_asset_handler.rs b/resource_management/src/asset/mesh_asset_handler.rs
new file mode 100644
index 00000000..229650e6
--- /dev/null
+++ b/resource_management/src/asset/mesh_asset_handler.rs
@@ -0,0 +1,270 @@
+use smol::future::FutureExt;
+
+use crate::{resource::resource_manager::ResourceManager, types::{AlphaMode, CompressionSchemes, CreateImage, Formats, IndexStream, IndexStreamTypes, IntegralTypes, Material, Mesh, MeshletStream, Primitive, Property, SubMesh, Value, VertexComponent, VertexSemantics}, GenericResourceSerialization, ProcessedResources};
+
+use super::asset_handler::AssetHandler;
+
+struct MeshAssetHandler {
+
+}
+
+impl MeshAssetHandler {
+	fn new() -> MeshAssetHandler {
+		MeshAssetHandler {}
+	}
+}
+
+impl AssetHandler for MeshAssetHandler {
+	fn load(&self, url: &str, json: &json::JsonValue) -> utils::BoxedFuture<Option<Result<(), String>>> {
+		async move {
+			let (gltf, buffers, images) = gltf::import(url).or(Err("Could not process GLTF file."))?;
+
+			const MESHLETIZE: bool = true;
+
+			let mut buffer = Vec::with_capacity(4096 * 1024 * 3);
+
+			let mut resources = Vec::with_capacity(8);
+
+			let mut sub_meshes = Vec::with_capacity(gltf.meshes().count());
+
+			for mesh in gltf.meshes() {
+				let mut primitives = Vec::with_capacity(mesh.primitives().count());
+
+				for primitive in mesh.primitives() {
+					let material = {
+						let material = primitive.material();
+
+						// Return the name of the texture
+						async fn manage_image<'x>(resource_manager: &'x ResourceManager, images: &'x [gltf::image::Data], texture: &'x gltf::Texture<'x>) -> Result<(String, ProcessedResources), String> {
+							let image = &images[texture.source().index()];
+
+							let format = match image.format {
+								gltf::image::Format::R8G8B8 => Formats::RGB8,
+								gltf::image::Format::R8G8B8A8 => Formats::RGBA8,
+								gltf::image::Format::R16G16B16 => Formats::RGB16,
+								gltf::image::Format::R16G16B16A16 => Formats::RGBA16,
+								_ => return Err("Unsupported image format".to_string()),
+							};
+
+							let name = texture.source().name().ok_or("No image name")?.to_string();
+
+							let create_image_info = CreateImage {
+								format,
+								extent: [image.width, image.height, 1],
+							};
+
+							let created_texture_resource = resource_manager.create_resource(&name, "Image", create_image_info, &image.pixels).await.ok_or("Failed to create texture")?;
+
+							Ok((name, created_texture_resource))
+						}
+
+						let pbr = material.pbr_metallic_roughness();
+
+						let albedo = if let Some(base_color_texture) = pbr.base_color_texture() {
+							let (name, resource) = manage_image(resource_manager, images.as_slice(), &base_color_texture.texture()).await?;
+							resources.push(resource);
+							Property::Texture(name)
+						} else {
+							let color = pbr.base_color_factor();
+							Property::Factor(Value::Vector4(color))
+						};
+
+						let (roughness, metallic) = if let Some(roughness_texture) = pbr.metallic_roughness_texture() {
+
+							({
+								let (name, resource) = manage_image(resource_manager, images.as_slice(), &roughness_texture.texture()).await?;
+								resources.push(resource);
+								Property::Texture(name)
+							}, {
+								let (name, resource) = manage_image(resource_manager, images.as_slice(), &roughness_texture.texture()).await?;
+								resources.push(resource);
+								Property::Texture(name)
+							})
+						} else {
+							(Property::Factor(Value::Scalar(pbr.roughness_factor())), Property::Factor(Value::Scalar(pbr.metallic_factor())))
+						};
+
+						let normal = if let Some(normal_texture) = material.normal_texture() {
+							let (name, resource) = manage_image(resource_manager, images.as_slice(), &normal_texture.texture()).await?;
+							resources.push(resource);
+							Property::Texture(name)
+						} else {
+							Property::Factor(Value::Vector3([0.0, 0.0, 1.0]))
+						};
+
+						let emissive = if let Some(emissive_texture) = material.emissive_texture() {
+							let (name, resource) = manage_image(resource_manager, images.as_slice(), &emissive_texture.texture()).await?;
+							resources.push(resource);
+							Property::Texture(name)
+						} else {
+							Property::Factor(Value::Vector3(material.emissive_factor()))
+						};
+
+						let occlusion = if let Some(occlusion_texture) = material.occlusion_texture() {
+							let (name, resource) = manage_image(resource_manager, images.as_slice(), &occlusion_texture.texture()).await?;
+							resources.push(resource);
+							Property::Texture(name)
+						} else {
+							Property::Factor(Value::Scalar(1.0))
+						};
+
+						Material {
+							albedo,
+							normal,
+							roughness,
+							metallic,
+							emissive,
+							occlusion,
+							double_sided: material.double_sided(),
+							alpha_mode: match material.alpha_mode() {
+								gltf::material::AlphaMode::Blend => AlphaMode::Blend,
+								gltf::material::AlphaMode::Mask => AlphaMode::Mask(material.alpha_cutoff().unwrap_or(0.5)),
+								gltf::material::AlphaMode::Opaque => AlphaMode::Opaque,
+							}
+						}
+					};
+
+					let mut vertex_components = Vec::new();
+
+					let bounding_box = Self::make_bounding_box(&primitive);
+
+					let reader = primitive.reader(|buffer| Some(&buffers[buffer.index()]));
+
+					let vertex_count = if let Some(positions) = reader.read_positions() {
+						let vertex_count = positions.clone().count();
+						positions.for_each(|mut position| {
+							position[2] = -position[2]; // Convert from right-handed(GLTF) to left-handed coordinate system
+							position.iter().for_each(|m| m.to_le_bytes().iter().for_each(|byte| buffer.push(*byte)))
+					});
+						vertex_components.push(VertexComponent { semantic: VertexSemantics::Position, format: "vec3f".to_string(), channel: 0 });
+						vertex_count
+					} else {
+						return Err("Mesh does not have positions".to_string());
+					};
+
+					let indices = reader.read_indices().expect("Cannot create mesh which does not have indices").into_u32().collect::<Vec<u32>>();
+
+					let optimized_indices = meshopt::optimize::optimize_vertex_cache(&indices, vertex_count);				
+		
+					if let Some(normals) = reader.read_normals() {
+						normals.for_each(|mut normal| {
+							normal[2] = -normal[2]; // Convert from right-handed(GLTF) to left-handed coordinate system
+							normal.iter().for_each(|m| m.to_le_bytes().iter().for_each(|byte| buffer.push(*byte)));
+						});
+
+						vertex_components.push(VertexComponent { semantic: VertexSemantics::Normal, format: "vec3f".to_string(), channel: 1 });
+					}
+		
+					if let Some(tangents) = reader.read_tangents() {
+						tangents.for_each(|tangent| tangent.iter().for_each(|m| m.to_le_bytes().iter().for_each(|byte| buffer.push(*byte))));
+						vertex_components.push(VertexComponent { semantic: VertexSemantics::Tangent, format: "vec4f".to_string(), channel: 2 });
+					}
+
+					for i in 0..8 {
+						if let Some(uv) = reader.read_tex_coords(i) {
+							assert_eq!(i, 0);
+							uv.into_f32().for_each(|uv| uv.iter().for_each(|m| m.to_le_bytes().iter().for_each(|byte| buffer.push(*byte))));
+							vertex_components.push(VertexComponent { semantic: VertexSemantics::Uv, format: "vec3f".to_string(), channel: 3 });
+						}
+					}
+		
+					// align buffer to 16 bytes for indices
+					while buffer.len() % 16 != 0 { buffer.push(0); }
+
+					let mut index_streams = Vec::with_capacity(2);
+
+					let meshlet_stream;
+
+					if MESHLETIZE {
+						let cone_weight = 0.0f32; // How much to prioritize cone culling over other forms of culling
+						let meshlets = meshopt::clusterize::build_meshlets(&optimized_indices, &meshopt::VertexDataAdapter::new(&buffer[0..12 * vertex_count], 12, 0).unwrap(), 64, 124, cone_weight);
+
+						let offset = buffer.len();
+
+						{
+							let index_type = IntegralTypes::U16;
+							
+							match index_type {
+								IntegralTypes::U16 => {
+									let mut index_count = 0usize;
+									for meshlet in meshlets.iter() {
+										index_count += meshlet.vertices.len();
+										for x in meshlet.vertices {
+											(*x as u16).to_le_bytes().iter().for_each(|byte| buffer.push(*byte));
+										}
+									}
+									index_streams.push(IndexStream{ data_type: IntegralTypes::U16, stream_type: IndexStreamTypes::Vertices, offset, count: index_count as u32 });
+								}
+								_ => panic!("Unsupported index type")
+							}
+						}
+		
+						let offset = buffer.len();
+
+						for meshlet in meshlets.iter() {
+							for x in meshlet.triangles {
+								assert!(*x <= 64u8, "Meshlet index out of bounds"); // Max vertices per meshlet
+								buffer.push(*x);
+							}
+						}
+
+						index_streams.push(IndexStream{ data_type: IntegralTypes::U8, stream_type: IndexStreamTypes::Meshlets, offset, count: optimized_indices.len() as u32 });
+
+						let offset = buffer.len();
+
+						meshlet_stream = Some(MeshletStream{ offset, count: meshlets.len() as u32 });
+
+						for meshlet in meshlets.iter() {
+							buffer.push(meshlet.vertices.len() as u8);
+							buffer.push((meshlet.triangles.len() / 3usize) as u8); // TODO: add tests for this
+						}
+					} else {
+						meshlet_stream = None;
+					}
+
+					let add_triangle_stream_even_if_using_meshlets = true;
+
+					if !MESHLETIZE || add_triangle_stream_even_if_using_meshlets {
+						let offset = buffer.len();
+
+						let index_type = IntegralTypes::U16;
+
+						match index_type {
+							IntegralTypes::U16 => {
+								optimized_indices.iter().map(|i| {
+									assert!(*i <= 0xFFFFu32, "Index out of bounds"); // Max vertices per meshlet
+									*i as u16
+								}).for_each(|i| i.to_le_bytes().iter().for_each(|byte| buffer.push(*byte)));
+								index_streams.push(IndexStream{ data_type: IntegralTypes::U16, stream_type: IndexStreamTypes::Triangles, offset, count: optimized_indices.len() as u32 });
+							}
+							_ => panic!("Unsupported index type")
+						}
+					}
+
+					primitives.push(Primitive {
+						material,
+						quantization: CompressionSchemes::None,
+						bounding_box,
+						vertex_components,
+						vertex_count: vertex_count as u32,
+						index_streams,
+						meshlet_stream,
+					});
+				}
+				
+				sub_meshes.push(SubMesh {
+					primitives,
+				});
+			}
+			
+			let mesh = Mesh {
+				sub_meshes,
+			};
+
+			let resource_document = GenericResourceSerialization::new(asset_url.to_string(), mesh);
+			resources.push(ProcessedResources::Generated((resource_document, buffer)));
+
+			Ok(resources)
+		}.boxed()
+	}
+}
\ No newline at end of file
diff --git a/resource_management/src/asset/mod.rs b/resource_management/src/asset/mod.rs
new file mode 100644
index 00000000..2abeb087
--- /dev/null
+++ b/resource_management/src/asset/mod.rs
@@ -0,0 +1,49 @@
+//! This module contains the asset management system.
+//! This system is responsible for loading assets from different sources (network, local, etc.) and generating the resources from them.
+
+pub mod asset_manager;
+pub mod asset_handler;
+
+pub mod audio_asset_handler;
+pub mod material_asset_handler;
+pub mod image_asset_handler;
+pub mod mesh_asset_handler;
+
+/// Loads an asset from source.\
+/// Expects an asset name in the form of a path relative to the assets directory, or a network address.\
+/// If the asset is not found it will return None.
+pub async fn read_asset_from_source(url: &str, base_path: Option<&std::path::Path>) -> Result<(Vec<u8>, String), ()> {
+	let resource_origin = if url.starts_with("http://") || url.starts_with("https://") { "network" } else { "local" };
+	let mut source_bytes;
+	let format;
+	match resource_origin {
+		"network" => {
+			let request = if let Ok(request) = ureq::get(url).call() { request } else { return Err(None); };
+			let content_type = if let Some(e) = request.header("content-type") { e.to_string() } else { return Err(None); };
+			format = content_type;
+
+			source_bytes = Vec::new();
+
+			request.into_reader().read_to_end(&mut source_bytes).or(Err(()))?;
+		},
+		"local" => {
+			let path = base_path.ok_or(None)?;
+
+			let mut file = smol::fs::File::open(&path).await.or(Err(()));
+
+			format = path.extension().unwrap().to_str().unwrap().to_string();
+
+			source_bytes = Vec::with_capacity(file.metadata().await.unwrap().len() as usize);
+
+			if let Err(_) = file.read_to_end(&mut source_bytes).await {
+				return Err(None);
+			}
+		},
+		_ => {
+			// Could not resolve how to get raw resource, return empty bytes
+			return Err(None);
+		}
+	}
+
+	Ok((source_bytes, format))
+}
\ No newline at end of file
diff --git a/resource_management/src/audio_resource_handler.rs b/resource_management/src/audio_resource_handler.rs
deleted file mode 100644
index 3cb7a487..00000000
--- a/resource_management/src/audio_resource_handler.rs
+++ /dev/null
@@ -1,192 +0,0 @@
-use serde::{Serialize, Deserialize};
-use smol::{fs::File, io::AsyncReadExt};
-
-use super::{resource_handler::ResourceHandler, Resource, ProcessedResources, GenericResourceSerialization, Stream};
-
-pub struct AudioResourceHandler {
-}
-
-impl AudioResourceHandler {
-	pub fn new() -> Self {
-		Self {
-		}
-	}
-}
-
-impl ResourceHandler for AudioResourceHandler {
-	fn can_handle_type(&self, resource_type: &str) -> bool {
-		return resource_type == "Audio" || resource_type == "wav";
-	}
-
-	fn get_deserializers(&self) -> Vec<(&'static str, Box<dyn Fn(&polodb_core::bson::Document) -> Box<dyn Resource> + Send>)> {
-		vec![("Audio", Box::new(|document| {
-			let audio = Audio::deserialize(polodb_core::bson::Deserializer::new(document.into())).unwrap();
-			Box::new(audio)
-		}))]
-	}
-
-	fn process<'a>(&'a self, resource_manager: &'a super::resource_manager::ResourceManager, asset_url: &'a str) -> utils::BoxedFuture<Result<Vec<ProcessedResources>, String>> {
-		Box::pin(async move {
-			let (bytes, _) = resource_manager.read_asset_from_source(asset_url).await.unwrap();
-
-			let riff = &bytes[0..4];
-
-			if riff != b"RIFF" {
-				return Err("Invalid RIFF header".to_string());
-			}
-
-			let format = &bytes[8..12];
-
-			if format != b"WAVE" {
-				return Err("Invalid WAVE format".to_string());
-			}
-
-			let audio_format = &bytes[20..22];
-
-			if audio_format != b"\x01\x00" {
-				return Err("Invalid audio format".to_string());
-			}
-
-			let subchunk_1_size = &bytes[16..20];
-
-			let subchunk_1_size = u32::from_le_bytes([subchunk_1_size[0], subchunk_1_size[1], subchunk_1_size[2], subchunk_1_size[3]]);
-
-			if subchunk_1_size != 16 {
-				return Err("Invalid subchunk 1 size".to_string());
-			}
-
-			let num_channels = &bytes[22..24];
-
-			let num_channels = u16::from_le_bytes([num_channels[0], num_channels[1]]);
-
-			if num_channels != 1 && num_channels != 2 {
-				return Err("Invalid number of channels".to_string());
-			}
-
-			let sample_rate = &bytes[24..28];
-
-			let sample_rate = u32::from_le_bytes([sample_rate[0], sample_rate[1], sample_rate[2], sample_rate[3]]);
-
-			let bits_per_sample = &bytes[34..36];
-
-			let bits_per_sample = u16::from_le_bytes([bits_per_sample[0], bits_per_sample[1]]);
-
-			let bit_depth = match bits_per_sample {
-				8 => BitDepths::Eight,
-				16 => BitDepths::Sixteen,
-				24 => BitDepths::TwentyFour,
-				32 => BitDepths::ThirtyTwo,
-				_ => { return Err("Invalid bits per sample".to_string()); }
-			};
-
-			let data_header = &bytes[36..40];
-
-			if data_header != b"data" {
-				return Err("Invalid data header".to_string());
-			}
-
-			let data_size = &bytes[40..44];
-
-			let data_size = u32::from_le_bytes([data_size[0], data_size[1], data_size[2], data_size[3]]);
-
-			let sample_count = data_size / (bits_per_sample / 8) as u32 / num_channels as u32;
-
-			let data = &bytes[44..][..data_size as usize];
-
-			let audio_resource = Audio {
-				bit_depth,
-				channel_count: num_channels,
-				sample_rate,
-				sample_count,
-			};
-
-			Ok(
-				vec![
-					ProcessedResources::Generated((
-						GenericResourceSerialization::new(asset_url.to_string(), audio_resource),
-						Vec::from(data),
-					))
-				]
-			
-			)
-		})
-	}
-
-	fn read<'a>(&'a self, _resource: &'a dyn Resource, file: &'a mut File, buffers: &'a mut [Stream<'a>]) -> utils::BoxedFuture<'a, ()> {
-		Box::pin(async move {
-			file.read_exact(buffers[0].buffer).await.unwrap();
-		})
-	}
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Copy)]
-pub enum BitDepths {
-	Eight,
-	Sixteen,
-	TwentyFour,
-	ThirtyTwo,
-}
-
-impl From<BitDepths> for usize {
-	fn from(bit_depth: BitDepths) -> Self {
-		match bit_depth {
-			BitDepths::Eight => 8,
-			BitDepths::Sixteen => 16,
-			BitDepths::TwentyFour => 24,
-			BitDepths::ThirtyTwo => 32,
-		}
-	}
-}
-
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
-pub struct Audio {
-	pub bit_depth: BitDepths,
-	pub channel_count: u16,
-	pub sample_rate: u32,
-	pub sample_count: u32,
-}
-
-impl Resource for Audio {
-	fn get_class(&self) -> &'static str { "Audio" }
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-
-	use crate::resource_manager::ResourceManager;
-
-	#[test]
-	fn test_audio_resource_handler() {
-		let audio_resource_handler = AudioResourceHandler::new();
-
-		let mut resource_manager = ResourceManager::new();
-
-		resource_manager.add_resource_handler(audio_resource_handler);
-
-		let (response, buffer) = smol::block_on(resource_manager.get("gun")).unwrap();
-
-		assert_eq!(response.resources.len(), 1);
-
-		// let (generic_resource_serialization, data) = match processed_resources[0] {
-		// 	ProcessedResources::Generated((ref generic_resource_serialization, ref data)) => (generic_resource_serialization, data),
-		// 	_ => { panic!("Unexpected processed resource type"); }
-		// };
-
-		let resource = &response.resources[0];
-
-		assert_eq!(resource.url, "gun");
-		assert_eq!(resource.class, "Audio");
-
-		// let audio_resource = (audio_resource_handler.get_deserializers().iter().find(|(class, _)| *class == "Audio").unwrap().1)(&resource.resource);
-
-		let audio = resource.resource.downcast_ref::<Audio>().unwrap();
-
-		assert_eq!(audio.bit_depth, BitDepths::Sixteen);
-		assert_eq!(audio.channel_count, 1);
-		assert_eq!(audio.sample_rate, 48000);
-		assert_eq!(audio.sample_count, 152456 / 1 / (16 / 8));
-
-		assert_eq!(buffer.len(), audio.sample_count as usize * audio.channel_count as usize * (Into::<usize>::into(audio.bit_depth) / 8) as usize);
-	}
-}
\ No newline at end of file
diff --git a/resource_management/src/lib.rs b/resource_management/src/lib.rs
index 59626ca6..63e5891c 100644
--- a/resource_management/src/lib.rs
+++ b/resource_management/src/lib.rs
@@ -5,13 +5,10 @@
 #![feature(async_closure)]
 #![feature(closure_lifetime_binder)]
 
-pub mod resource_manager;
+pub mod asset;
+pub mod resource;
 
-pub mod resource_handler;
-pub mod texture_resource_handler;
-pub mod mesh_resource_handler;
-pub mod material_resource_handler;
-pub mod audio_resource_handler;
+pub mod types;
 
 pub mod file_tracker;
 
diff --git a/resource_management/src/resource/audio_resource_handler.rs b/resource_management/src/resource/audio_resource_handler.rs
new file mode 100644
index 00000000..8377aa22
--- /dev/null
+++ b/resource_management/src/resource/audio_resource_handler.rs
@@ -0,0 +1,76 @@
+use serde::Deserialize;
+use smol::{fs::File, io::AsyncReadExt};
+
+use crate::{types::Audio, Resource, Stream};
+
+use super::resource_handler::ResourceHandler;
+
+pub struct AudioResourceHandler {
+}
+
+impl AudioResourceHandler {
+	pub fn new() -> Self {
+		Self {
+		}
+	}
+}
+
+impl ResourceHandler for AudioResourceHandler {
+	fn can_handle_type(&self, resource_type: &str) -> bool {
+		return resource_type == "Audio" || resource_type == "wav";
+	}
+
+	fn get_deserializers(&self) -> Vec<(&'static str, Box<dyn Fn(&polodb_core::bson::Document) -> Box<dyn Resource> + Send>)> {
+		vec![("Audio", Box::new(|document| {
+			let audio = Audio::deserialize(polodb_core::bson::Deserializer::new(document.into())).unwrap();
+			Box::new(audio)
+		}))]
+	}
+
+	fn read<'a>(&'a self, _resource: &'a dyn Resource, file: &'a mut File, buffers: &'a mut [Stream<'a>]) -> utils::BoxedFuture<'a, ()> {
+		Box::pin(async move {
+			file.read_exact(buffers[0].buffer).await.unwrap();
+		})
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use crate::{resource::resource_manager::ResourceManager, types::{Audio, BitDepths}};
+
+	use super::*;
+
+	#[test]
+	fn test_audio_resource_handler() {
+		let audio_resource_handler = AudioResourceHandler::new();
+
+		let mut resource_manager = ResourceManager::new();
+
+		resource_manager.add_resource_handler(audio_resource_handler);
+
+		let (response, buffer) = smol::block_on(resource_manager.get("gun")).unwrap();
+
+		assert_eq!(response.resources.len(), 1);
+
+		// let (generic_resource_serialization, data) = match processed_resources[0] {
+		// 	ProcessedResources::Generated((ref generic_resource_serialization, ref data)) => (generic_resource_serialization, data),
+		// 	_ => { panic!("Unexpected processed resource type"); }
+		// };
+
+		let resource = &response.resources[0];
+
+		assert_eq!(resource.url, "gun");
+		assert_eq!(resource.class, "Audio");
+
+		// let audio_resource = (audio_resource_handler.get_deserializers().iter().find(|(class, _)| *class == "Audio").unwrap().1)(&resource.resource);
+
+		let audio = resource.resource.downcast_ref::<Audio>().unwrap();
+
+		assert_eq!(audio.bit_depth, BitDepths::Sixteen);
+		assert_eq!(audio.channel_count, 1);
+		assert_eq!(audio.sample_rate, 48000);
+		assert_eq!(audio.sample_count, 152456 / 1 / (16 / 8));
+
+		assert_eq!(buffer.len(), audio.sample_count as usize * audio.channel_count as usize * (Into::<usize>::into(audio.bit_depth) / 8) as usize);
+	}
+}
\ No newline at end of file
diff --git a/resource_management/src/material_resource_handler.rs b/resource_management/src/resource/material_resource_handler.rs
similarity index 62%
rename from resource_management/src/material_resource_handler.rs
rename to resource_management/src/resource/material_resource_handler.rs
index 72016034..8feac101 100644
--- a/resource_management/src/material_resource_handler.rs
+++ b/resource_management/src/resource/material_resource_handler.rs
@@ -1,75 +1,14 @@
-use serde::{Serialize, Deserialize};
+use serde::Deserialize;
 use smol::{fs::File, io::AsyncReadExt};
 
-use super::{GenericResourceSerialization, Resource, ProcessedResources, resource_handler::ResourceHandler, resource_manager::ResourceManager, Stream};
+use crate::{types::{Material, Shader, ShaderTypes, Variant}, GenericResourceSerialization, ProcessedResources, Resource, Stream};
+
+use super::{resource_handler::ResourceHandler, resource_manager::ResourceManager,};
 
 pub struct MaterialResourcerHandler {
 	generator: Option<Box<dyn ShaderGenerator>>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Model {
-	/// The name of the model.
-	pub name: String,
-	/// The render pass of the model.
-	pub pass: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Material {
-	/// The render model this material is for.
-	pub model: Model,
-}
-
-impl Resource for Material {
-	fn get_class(&self) -> &'static str { "Material" }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct VariantVariable {
-	pub name: String,
-	pub value: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Variant {
-	/// Parent material asset url.
-	pub parent: String,
-	pub variables: Vec<VariantVariable>,
-}
-
-impl Resource for Variant {
-	fn get_class(&self) -> &'static str { "Variant" }
-}
-
-/// Enumerates the types of shaders that can be created.
-#[derive(Clone, Copy, Serialize, Deserialize, Debug)]
-pub enum ShaderTypes {
-	/// A vertex shader.
-	Vertex,
-	/// A fragment shader.
-	Fragment,
-	/// A compute shader.
-	Compute,
-	Task,
-	Mesh,
-	RayGen,
-	ClosestHit,
-	AnyHit,
-	Intersection,
-	Miss,
-	Callable,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Shader {
-	pub stage: ShaderTypes,
-}
-
-impl Resource for Shader {
-	fn get_class(&self) -> &'static str { "Shader" }
-}
-
 pub trait ShaderGenerator: Send {
 	fn process(&self, children: Vec<std::rc::Rc<jspd::Node>>) -> (&'static str, jspd::Node);
 	fn transform(&self, material: &json::JsonValue, shader_node: &jspd::lexer::Node, stage: &str) -> Option<String>;
@@ -109,67 +48,6 @@ impl ResourceHandler for MaterialResourcerHandler {
 		Box::pin(async move { file.read_exact(buffers[0].buffer).await.unwrap(); })
 	}
 
-	fn process<'a>(&'a self, resource_manager: &'a ResourceManager, asset_url: &'a str,) -> utils::BoxedFuture<Result<Vec<ProcessedResources>, String>> {
-		Box::pin(async move {
-			let (bytes, _) = resource_manager.read_asset_from_source(asset_url).await.unwrap();
-
-			let asset_json = json::parse(std::str::from_utf8(&bytes).unwrap()).unwrap();
-
-			let is_material = asset_json["parent"].is_null();
-
-			if is_material {
-				let material_domain = match &asset_json["domain"] {
-					json::JsonValue::Null => { "Common".to_string() }
-					json::JsonValue::Short(s) => { s.to_string() }
-					json::JsonValue::String(s) => { s.to_string() }
-					_ => { panic!("Invalid domain") }
-				};
-
-				let _material_type = match &asset_json["type"] {
-					json::JsonValue::Null => { "Raw".to_string() }
-					json::JsonValue::Short(s) => { s.to_string() }
-					json::JsonValue::String(s) => { s.to_string() }
-					_ => { panic!("Invalid type") }
-				};
-				
-				let mut required_resources = asset_json["shaders"].entries().filter_map(|(s_type, shader_json)| {
-					smol::block_on(self.produce_shader(resource_manager, &material_domain, &asset_json, &shader_json, s_type))
-				}).collect::<Vec<_>>();
-
-				for variable in asset_json["variables"].members() {
-					if variable["data_type"].as_str().unwrap() == "Texture2D" {
-						let texture_url = variable["value"].as_str().unwrap();
-
-						required_resources.push(ProcessedResources::Reference(texture_url.to_string()));
-					}
-				}
-
-				Ok(vec![ProcessedResources::Generated((GenericResourceSerialization::new(asset_url.to_string(), Material {
-					model: Model {
-						name: Self::RENDER_MODEL.to_string(),
-						pass: "MaterialEvaluation".to_string(),
-					},
-				}).required_resources(&required_resources), Vec::new()))])
-			} else {
-				let variant_json = asset_json;
-
-				let parent_material_url = variant_json["parent"].as_str().unwrap();
-
-				let material_resource_document = GenericResourceSerialization::new(asset_url.to_string(), Variant{
-					parent: parent_material_url.to_string(),
-					variables: variant_json["variables"].members().map(|v| {
-						VariantVariable {
-							name: v["name"].to_string(),
-							value: v["value"].to_string(),
-						}
-					}).collect::<Vec<_>>()
-				}).required_resources(&[ProcessedResources::Reference(parent_material_url.to_string())]);
-
-				Ok(vec![ProcessedResources::Generated((material_resource_document.into(), Vec::new()))])
-			}
-		})
-	}
-
 	fn get_deserializers(&self) -> Vec<(&'static str, Box<dyn Fn(&polodb_core::bson::Document) -> Box<dyn Resource> + Send>)> {
 		vec![("Material",
 			Box::new(|_document| {
@@ -302,7 +180,7 @@ impl MaterialResourcerHandler {
 
 #[cfg(test)]
 mod tests {
-    use crate::resource_manager::ResourceManager;
+    use crate::resource::resource_manager::ResourceManager;
 
 	#[test]
 	#[ignore] // We need to implement a shader generator to test this
diff --git a/resource_management/src/mesh_resource_handler.rs b/resource_management/src/resource/mesh_resource_handler.rs
similarity index 64%
rename from resource_management/src/mesh_resource_handler.rs
rename to resource_management/src/resource/mesh_resource_handler.rs
index d3aa51c3..bbbc0a03 100644
--- a/resource_management/src/mesh_resource_handler.rs
+++ b/resource_management/src/resource/mesh_resource_handler.rs
@@ -1,10 +1,9 @@
-use polodb_core::bson::doc;
-use serde::{Serialize, Deserialize};
+use serde::Deserialize;
 use smol::{fs::File, io::{AsyncReadExt, AsyncSeekExt}};
 
-use crate::{texture_resource_handler::{CreateImage, Formats}, CreateInfo};
+use crate::{types::{IndexStreamTypes, Mesh, VertexSemantics}, Resource, Stream};
 
-use super::{GenericResourceSerialization, Resource, ProcessedResources, resource_handler::ResourceHandler, resource_manager::ResourceManager, Stream};
+use super::resource_handler::ResourceHandler;
 
 pub struct MeshResourceHandler {
 
@@ -34,261 +33,6 @@ impl ResourceHandler for MeshResourceHandler {
 		}
 	}
 
-	fn process<'a>(&'a self, resource_manager: &'a ResourceManager, asset_url: &'a str) -> utils::BoxedFuture<Result<Vec<ProcessedResources>, String>> {
-		Box::pin(async move {
-			let result = gltf::import(resource_manager.realize_asset_path(asset_url).ok_or("Could not find asset file.")?);
-			let (gltf, buffers, images) = result.or(Err("Could not process GLTF file."))?;
-
-			const MESHLETIZE: bool = true;
-
-			let mut buffer = Vec::with_capacity(4096 * 1024 * 3);
-
-			let mut resources = Vec::with_capacity(8);
-
-			let mut sub_meshes = Vec::with_capacity(gltf.meshes().count());
-
-			for mesh in gltf.meshes() {
-				let mut primitives = Vec::with_capacity(mesh.primitives().count());
-
-				for primitive in mesh.primitives() {
-					let material = {
-						let material = primitive.material();
-
-						// Return the name of the texture
-						async fn manage_image<'x>(resource_manager: &'x ResourceManager, images: &'x [gltf::image::Data], texture: &'x gltf::Texture<'x>) -> Result<(String, ProcessedResources), String> {
-							let image = &images[texture.source().index()];
-
-							let format = match image.format {
-								gltf::image::Format::R8G8B8 => Formats::RGB8,
-								gltf::image::Format::R8G8B8A8 => Formats::RGBA8,
-								gltf::image::Format::R16G16B16 => Formats::RGB16,
-								gltf::image::Format::R16G16B16A16 => Formats::RGBA16,
-								_ => return Err("Unsupported image format".to_string()),
-							};
-
-							let name = texture.source().name().ok_or("No image name")?.to_string();
-
-							let create_image_info = CreateImage {
-								format,
-								extent: [image.width, image.height, 1],
-							};
-
-							let created_texture_resource = resource_manager.create_resource(&name, "Image", create_image_info, &image.pixels).await.ok_or("Failed to create texture")?;
-
-							Ok((name, created_texture_resource))
-						}
-
-						let pbr = material.pbr_metallic_roughness();
-
-						let albedo = if let Some(base_color_texture) = pbr.base_color_texture() {
-							let (name, resource) = manage_image(resource_manager, images.as_slice(), &base_color_texture.texture()).await?;
-							resources.push(resource);
-							Property::Texture(name)
-						} else {
-							let color = pbr.base_color_factor();
-							Property::Factor(Value::Vector4(color))
-						};
-
-						let (roughness, metallic) = if let Some(roughness_texture) = pbr.metallic_roughness_texture() {
-
-							({
-								let (name, resource) = manage_image(resource_manager, images.as_slice(), &roughness_texture.texture()).await?;
-								resources.push(resource);
-								Property::Texture(name)
-							}, {
-								let (name, resource) = manage_image(resource_manager, images.as_slice(), &roughness_texture.texture()).await?;
-								resources.push(resource);
-								Property::Texture(name)
-							})
-						} else {
-							(Property::Factor(Value::Scalar(pbr.roughness_factor())), Property::Factor(Value::Scalar(pbr.metallic_factor())))
-						};
-
-						let normal = if let Some(normal_texture) = material.normal_texture() {
-							let (name, resource) = manage_image(resource_manager, images.as_slice(), &normal_texture.texture()).await?;
-							resources.push(resource);
-							Property::Texture(name)
-						} else {
-							Property::Factor(Value::Vector3([0.0, 0.0, 1.0]))
-						};
-
-						let emissive = if let Some(emissive_texture) = material.emissive_texture() {
-							let (name, resource) = manage_image(resource_manager, images.as_slice(), &emissive_texture.texture()).await?;
-							resources.push(resource);
-							Property::Texture(name)
-						} else {
-							Property::Factor(Value::Vector3(material.emissive_factor()))
-						};
-
-						let occlusion = if let Some(occlusion_texture) = material.occlusion_texture() {
-							let (name, resource) = manage_image(resource_manager, images.as_slice(), &occlusion_texture.texture()).await?;
-							resources.push(resource);
-							Property::Texture(name)
-						} else {
-							Property::Factor(Value::Scalar(1.0))
-						};
-
-						Material {
-							name: material.name().unwrap_or("Unnamed").to_string(),
-							albedo,
-							normal,
-							roughness,
-							metallic,
-							emissive,
-							occlusion,
-							double_sided: material.double_sided(),
-							alpha_mode: match material.alpha_mode() {
-								gltf::material::AlphaMode::Blend => AlphaMode::Blend,
-								gltf::material::AlphaMode::Mask => AlphaMode::Mask(material.alpha_cutoff().unwrap_or(0.5)),
-								gltf::material::AlphaMode::Opaque => AlphaMode::Opaque,
-							}
-						}
-					};
-
-					let mut vertex_components = Vec::new();
-
-					let bounding_box = Self::make_bounding_box(&primitive);
-
-					let reader = primitive.reader(|buffer| Some(&buffers[buffer.index()]));
-
-					let vertex_count = if let Some(positions) = reader.read_positions() {
-						let vertex_count = positions.clone().count();
-						positions.for_each(|mut position| {
-							position[2] = -position[2]; // Convert from right-handed(GLTF) to left-handed coordinate system
-							position.iter().for_each(|m| m.to_le_bytes().iter().for_each(|byte| buffer.push(*byte)))
-					});
-						vertex_components.push(VertexComponent { semantic: VertexSemantics::Position, format: "vec3f".to_string(), channel: 0 });
-						vertex_count
-					} else {
-						return Err("Mesh does not have positions".to_string());
-					};
-
-					let indices = reader.read_indices().expect("Cannot create mesh which does not have indices").into_u32().collect::<Vec<u32>>();
-
-					let optimized_indices = meshopt::optimize::optimize_vertex_cache(&indices, vertex_count);				
-		
-					if let Some(normals) = reader.read_normals() {
-						normals.for_each(|mut normal| {
-							normal[2] = -normal[2]; // Convert from right-handed(GLTF) to left-handed coordinate system
-							normal.iter().for_each(|m| m.to_le_bytes().iter().for_each(|byte| buffer.push(*byte)));
-						});
-
-						vertex_components.push(VertexComponent { semantic: VertexSemantics::Normal, format: "vec3f".to_string(), channel: 1 });
-					}
-		
-					if let Some(tangents) = reader.read_tangents() {
-						tangents.for_each(|tangent| tangent.iter().for_each(|m| m.to_le_bytes().iter().for_each(|byte| buffer.push(*byte))));
-						vertex_components.push(VertexComponent { semantic: VertexSemantics::Tangent, format: "vec4f".to_string(), channel: 2 });
-					}
-
-					for i in 0..8 {
-						if let Some(uv) = reader.read_tex_coords(i) {
-							assert_eq!(i, 0);
-							uv.into_f32().for_each(|uv| uv.iter().for_each(|m| m.to_le_bytes().iter().for_each(|byte| buffer.push(*byte))));
-							vertex_components.push(VertexComponent { semantic: VertexSemantics::Uv, format: "vec3f".to_string(), channel: 3 });
-						}
-					}
-		
-					// align buffer to 16 bytes for indices
-					while buffer.len() % 16 != 0 { buffer.push(0); }
-
-					let mut index_streams = Vec::with_capacity(2);
-
-					let meshlet_stream;
-
-					if MESHLETIZE {
-						let cone_weight = 0.0f32; // How much to prioritize cone culling over other forms of culling
-						let meshlets = meshopt::clusterize::build_meshlets(&optimized_indices, &meshopt::VertexDataAdapter::new(&buffer[0..12 * vertex_count], 12, 0).unwrap(), 64, 124, cone_weight);
-
-						let offset = buffer.len();
-
-						{
-							let index_type = IntegralTypes::U16;
-							
-							match index_type {
-								IntegralTypes::U16 => {
-									let mut index_count = 0usize;
-									for meshlet in meshlets.iter() {
-										index_count += meshlet.vertices.len();
-										for x in meshlet.vertices {
-											(*x as u16).to_le_bytes().iter().for_each(|byte| buffer.push(*byte));
-										}
-									}
-									index_streams.push(IndexStream{ data_type: IntegralTypes::U16, stream_type: IndexStreamTypes::Vertices, offset, count: index_count as u32 });
-								}
-								_ => panic!("Unsupported index type")
-							}
-						}
-		
-						let offset = buffer.len();
-
-						for meshlet in meshlets.iter() {
-							for x in meshlet.triangles {
-								assert!(*x <= 64u8, "Meshlet index out of bounds"); // Max vertices per meshlet
-								buffer.push(*x);
-							}
-						}
-
-						index_streams.push(IndexStream{ data_type: IntegralTypes::U8, stream_type: IndexStreamTypes::Meshlets, offset, count: optimized_indices.len() as u32 });
-
-						let offset = buffer.len();
-
-						meshlet_stream = Some(MeshletStream{ offset, count: meshlets.len() as u32 });
-
-						for meshlet in meshlets.iter() {
-							buffer.push(meshlet.vertices.len() as u8);
-							buffer.push((meshlet.triangles.len() / 3usize) as u8); // TODO: add tests for this
-						}
-					} else {
-						meshlet_stream = None;
-					}
-
-					let add_triangle_stream_even_if_using_meshlets = true;
-
-					if !MESHLETIZE || add_triangle_stream_even_if_using_meshlets {
-						let offset = buffer.len();
-
-						let index_type = IntegralTypes::U16;
-
-						match index_type {
-							IntegralTypes::U16 => {
-								optimized_indices.iter().map(|i| {
-									assert!(*i <= 0xFFFFu32, "Index out of bounds"); // Max vertices per meshlet
-									*i as u16
-								}).for_each(|i| i.to_le_bytes().iter().for_each(|byte| buffer.push(*byte)));
-								index_streams.push(IndexStream{ data_type: IntegralTypes::U16, stream_type: IndexStreamTypes::Triangles, offset, count: optimized_indices.len() as u32 });
-							}
-							_ => panic!("Unsupported index type")
-						}
-					}
-
-					primitives.push(Primitive {
-						material,
-						compression: CompressionSchemes::None,
-						bounding_box,
-						vertex_components,
-						vertex_count: vertex_count as u32,
-						index_streams,
-						meshlet_stream,
-					});
-				}
-				
-				sub_meshes.push(SubMesh {
-					primitives,
-				});
-			}
-			
-			let mesh = Mesh {
-				sub_meshes,
-			};
-
-			let resource_document = GenericResourceSerialization::new(asset_url.to_string(), mesh);
-			resources.push(ProcessedResources::Generated((resource_document, buffer)));
-
-			Ok(resources)
-		})
-	}
-
 	fn get_deserializers(&self) -> Vec<(&'static str, Box<dyn Fn(&polodb_core::bson::Document) -> Box<dyn Resource> + Send>)> {
 		vec![("Mesh", Box::new(|document| {
 			let mesh = Mesh::deserialize(polodb_core::bson::Deserializer::new(document.into())).unwrap();
@@ -370,168 +114,6 @@ impl ResourceHandler for MeshResourceHandler {
 	}
 }
 
-#[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
-pub enum VertexSemantics {
-	Position,
-	Normal,
-	Tangent,
-	BiTangent,
-	Uv,
-	Color,
-}
-
-#[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
-pub enum IntegralTypes {
-	U8,
-	I8,
-	U16,
-	I16,
-	U32,
-	I32,
-	F16,
-	F32,
-	F64,
-}
-
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
-pub struct VertexComponent {
-	pub semantic: VertexSemantics,
-	pub format: String,
-	pub channel: u32,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub enum CompressionSchemes {
-	None,
-	Quantization,
-	Octahedral,
-	OctahedralQuantization,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-pub enum IndexStreamTypes {
-	Vertices,
-	Meshlets,
-	Triangles,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct IndexStream {
-	pub stream_type: IndexStreamTypes,
-	pub offset: usize,
-	pub count: u32,
-	pub data_type: IntegralTypes,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct MeshletStream {
-	pub offset: usize,
-	pub count: u32,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub enum Value {
-	Scalar(f32),
-	Vector3([f32; 3]),
-	Vector4([f32; 4]),
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub enum Property {
-	Factor(Value),
-	Texture(String),
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub enum AlphaMode {
-	Opaque,
-	Mask(f32),
-	Blend,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Material {
-	name: String,
-	albedo: Property,
-	normal: Property,
-	roughness: Property,
-	metallic: Property,
-	emissive: Property,
-	occlusion: Property,
-	double_sided: bool,
-	alpha_mode: AlphaMode,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Primitive {
-	pub material: Material,
-	pub compression: CompressionSchemes,
-	pub bounding_box: [[f32; 3]; 2],
-	pub vertex_components: Vec<VertexComponent>,
-	pub vertex_count: u32,
-	pub index_streams: Vec<IndexStream>,
-	pub meshlet_stream: Option<MeshletStream>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct SubMesh {
-	pub primitives: Vec<Primitive>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Mesh {
-	pub sub_meshes: Vec<SubMesh>,
-}
-
-impl Resource for Mesh {
-	fn get_class(&self) -> &'static str { "Mesh" }
-}
-
-pub trait Size {
-	fn size(&self) -> usize;
-}
-
-impl Size for VertexSemantics {
-	fn size(&self) -> usize {
-		match self {
-			VertexSemantics::Position => 3 * 4,
-			VertexSemantics::Normal => 3 * 4,
-			VertexSemantics::Tangent => 4 * 4,
-			VertexSemantics::BiTangent => 3 * 4,
-			VertexSemantics::Uv => 2 * 4,
-			VertexSemantics::Color => 4 * 4,
-		}
-	}
-}
-
-impl Size for Vec<VertexComponent> {
-	fn size(&self) -> usize {
-		let mut size = 0;
-
-		for component in self {
-			size += component.semantic.size();
-		}
-
-		size
-	}
-}
-
-impl Size for IntegralTypes {
-	fn size(&self) -> usize {
-		match self {
-			IntegralTypes::U8 => 1,
-			IntegralTypes::I8 => 1,
-			IntegralTypes::U16 => 2,
-			IntegralTypes::I16 => 2,
-			IntegralTypes::U32 => 4,
-			IntegralTypes::I32 => 4,
-			IntegralTypes::F16 => 2,
-			IntegralTypes::F32 => 4,
-			IntegralTypes::F64 => 8,
-		}
-	}
-}
-
 // fn qtangent(normal: Vector3<f32>, tangent: Vector3<f32>, bi_tangent: Vector3<f32>) -> Quaternion<f32> {
 // 	let tbn: Matrix3<f32> = Matrix3::from_cols(normal, tangent, bi_tangent);
 
@@ -570,7 +152,7 @@ impl Size for IntegralTypes {
 
 #[cfg(test)]
 mod tests {
-	use crate::{resource_manager::ResourceManager, Stream, LoadRequest, LoadResourceRequest};
+	use crate::{resource::{resource_manager::ResourceManager, texture_resource_handler::ImageResourceHandler}, types::{IndexStreamTypes, IntegralTypes, Mesh, VertexSemantics}, LoadRequest, LoadResourceRequest, Stream};
 
 	use super::*;
 
@@ -974,8 +556,6 @@ mod tests {
 	#[test]
 	#[ignore="This test is too heavy."]
 	fn load_glb() {
-		use crate::texture_resource_handler::ImageResourceHandler;
-
 		let mut resource_manager = ResourceManager::new();
 		let resource_handler = MeshResourceHandler::new();
 
diff --git a/resource_management/src/resource/mod.rs b/resource_management/src/resource/mod.rs
new file mode 100644
index 00000000..502b583c
--- /dev/null
+++ b/resource_management/src/resource/mod.rs
@@ -0,0 +1,9 @@
+//! The resource module contains the resource management system.
+
+pub mod resource_manager;
+
+pub mod resource_handler;
+pub mod texture_resource_handler;
+pub mod mesh_resource_handler;
+pub mod material_resource_handler;
+pub mod audio_resource_handler;
\ No newline at end of file
diff --git a/resource_management/src/resource/resource_handler.rs b/resource_management/src/resource/resource_handler.rs
new file mode 100644
index 00000000..38966bad
--- /dev/null
+++ b/resource_management/src/resource/resource_handler.rs
@@ -0,0 +1,13 @@
+use smol::{fs::File, future::FutureExt};
+
+use crate::{CreateInfo, CreateResource, ProcessedResources, Resource, Stream};
+
+use super::{resource_manager,};
+
+pub trait ResourceHandler {
+	fn can_handle_type(&self, resource_type: &str) -> bool;
+
+	fn get_deserializers(&self) -> Vec<(&'static str, Box<dyn Fn(&polodb_core::bson::Document) -> Box<dyn Resource> + Send>)>;
+
+	fn read<'a>(&'a self, _resource: &'a dyn Resource, file: &'a mut File, streams: &'a mut [Stream<'a>]) -> utils::BoxedFuture<()>;
+}
\ No newline at end of file
diff --git a/resource_management/src/resource_manager.rs b/resource_management/src/resource/resource_manager.rs
similarity index 100%
rename from resource_management/src/resource_manager.rs
rename to resource_management/src/resource/resource_manager.rs
diff --git a/resource_management/src/resource/texture_resource_handler.rs b/resource_management/src/resource/texture_resource_handler.rs
new file mode 100644
index 00000000..c84900bc
--- /dev/null
+++ b/resource_management/src/resource/texture_resource_handler.rs
@@ -0,0 +1,87 @@
+use serde::Deserialize;
+use smol::{fs::File, future::FutureExt, io::AsyncReadExt};
+
+use crate::{types::Image, Resource, Stream};
+
+use super::{resource_handler::ResourceHandler,};
+
+pub struct ImageResourceHandler {
+
+}
+
+impl ImageResourceHandler {
+	pub fn new() -> Self {
+		Self {}
+	}
+}
+
+impl ResourceHandler for ImageResourceHandler {
+	fn can_handle_type(&self, resource_type: &str) -> bool {
+		match resource_type {
+			"image/png" => true,
+			"png" => true,
+			"Image" => true,
+			_ => false
+		}
+	}
+
+	fn read<'a>(&'a self, _resource: &'a dyn Resource, file: &'a mut File, buffers: &'a mut [Stream<'a>]) -> utils::BoxedFuture<'_, ()> {
+		Box::pin(async move {
+			file.read_exact(buffers[0].buffer).await.unwrap()
+		})
+	}
+
+	fn get_deserializers(&self) -> Vec<(&'static str, Box<dyn Fn(&polodb_core::bson::Document) -> Box<dyn Resource> + Send>)> {
+		vec![("Image", Box::new(|document| {
+			let texture = Image::deserialize(polodb_core::bson::Deserializer::new(document.into())).unwrap();
+			Box::new(texture)
+		}))]
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use crate::{resource::resource_manager::ResourceManager, types::Image};
+
+use super::*;
+
+	#[test]
+	fn load_net_image() {
+		let mut resource_manager = ResourceManager::new();
+
+		resource_manager.add_resource_handler(ImageResourceHandler::new());
+
+		// smol::block_on(async {
+		// 	Timer::after(std::time::Duration::from_secs(60 * 3)).await;
+		// });
+
+		let (response, _) = smol::block_on(resource_manager.get("https://camo.githubusercontent.com/a49890a2fa4559f38b13e6427defe7579aee065a9a3f7ee37cf7cb86295bab79/68747470733a2f2f692e696d6775722e636f6d2f56525261434f702e706e67")).expect("Failed to load image");
+
+		assert_eq!(response.resources.len(), 1);
+
+		let resource_container = &response.resources[0];
+		let resource = &resource_container.resource;
+
+		let texture_info = resource.downcast_ref::<Image>().unwrap();
+
+		assert_eq!(texture_info.extent, [4096, 1024, 1]);
+	}
+
+	#[test]
+	fn load_local_image() {
+		let mut resource_manager = ResourceManager::new();
+
+		resource_manager.add_resource_handler(ImageResourceHandler::new());
+
+		let (response, _) = smol::block_on(resource_manager.get("patterned_brick_floor_02_diff_2k")).expect("Failed to load image");
+
+		assert_eq!(response.resources.len(), 1);
+
+		let resource_container = &response.resources[0];
+		let resource = &resource_container.resource;
+
+		let texture_info = resource.downcast_ref::<Image>().unwrap();
+
+		assert_eq!(texture_info.extent, [2048, 2048, 1]);
+	}
+}
\ No newline at end of file
diff --git a/resource_management/src/resource_handler.rs b/resource_management/src/resource_handler.rs
deleted file mode 100644
index dbf15d97..00000000
--- a/resource_management/src/resource_handler.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use smol::{fs::File, future::FutureExt};
-
-use crate::{CreateInfo, CreateResource};
-
-use super::{resource_manager, ProcessedResources, Stream, Resource};
-
-pub trait ResourceHandler {
-	fn can_handle_type(&self, resource_type: &str) -> bool;
-
-	/// Returns a tuple containing the resource description and it's associated binary data.\
-	/// 
-	/// The returned document is like the following:
-	/// ```json
-	/// { "class": "X", "resource": { ... }, "hash": 0, "required_resources":[{ "path": "..." }] }
-	/// ```
-	/// Fields:
-	/// - **class**: The resource class. This is used to identify the resource type. Needs to be meaningful and will be a public constant.
-	/// - **resource**: The resource data. Can look like anything.
-	/// - **hash**(optional): The resource hash. This is used to identify the resource data. If the resource handler wants to generate a hash for the resource it can do so else the resource manager will generate a hash for it. This is because some resources can generate hashes inteligently (EJ: code generators can output same hash for different looking code if the code is semantically identical).
-	/// - **required_resources**(optional): A list of resources that this resource depends on. This is used to load resources that depend on other resources.
-	fn process<'a>(&'a self, resource_manager: &'a resource_manager::ResourceManager, asset_url: &'a str) -> utils::BoxedFuture<Result<Vec<ProcessedResources>, String>>;
-
-	fn get_deserializers(&self) -> Vec<(&'static str, Box<dyn Fn(&polodb_core::bson::Document) -> Box<dyn Resource> + Send>)>;
-
-	fn read<'a>(&'a self, _resource: &'a dyn Resource, file: &'a mut File, streams: &'a mut [Stream<'a>]) -> utils::BoxedFuture<()>;
-
-	fn create_resource<'a>(&'a self, info: &'a CreateInfo, resource_manager: &'a resource_manager::ResourceManager) -> utils::BoxedFuture<Result<Vec<ProcessedResources>, String>> {
-		async move { Result::Ok(vec![]) }.boxed()
-	}
-}
\ No newline at end of file
diff --git a/resource_management/src/texture_resource_handler.rs b/resource_management/src/texture_resource_handler.rs
deleted file mode 100644
index be9bb1df..00000000
--- a/resource_management/src/texture_resource_handler.rs
+++ /dev/null
@@ -1,245 +0,0 @@
-use serde::{Serialize, Deserialize};
-use smol::{fs::File, future::FutureExt, io::AsyncReadExt};
-use utils::Extent;
-
-use crate::{CreateInfo, CreateResource, GenericResourceSerialization};
-
-use super::{Resource, ProcessedResources, resource_manager::ResourceManager, resource_handler::ResourceHandler, Stream};
-
-pub struct ImageResourceHandler {
-
-}
-
-impl ImageResourceHandler {
-	pub fn new() -> Self {
-		Self {}
-	}
-}
-
-impl ResourceHandler for ImageResourceHandler {
-	fn can_handle_type(&self, resource_type: &str) -> bool {
-		match resource_type {
-			"image/png" => true,
-			"png" => true,
-			"Image" => true,
-			"Texture" => true,
-			_ => false
-		}
-	}
-
-	fn process<'a>(&'a self, resource_manager: &'a ResourceManager, asset_url: &'a str,) -> utils::BoxedFuture<Result<Vec<ProcessedResources>, String>> {
-		Box::pin(async move {
-			let (bytes, _) = resource_manager.read_asset_from_source(asset_url).await.unwrap();
-			let mut decoder = png::Decoder::new(bytes.as_slice());
-			decoder.set_transformations(png::Transformations::normalize_to_color8());
-			let mut reader = decoder.read_info().unwrap();
-			let mut buffer = vec![0; reader.output_buffer_size()];
-			let info = reader.next_frame(&mut buffer).unwrap();
-	
-			let extent = Extent::rectangle(info.width, info.height,);
-	
-			assert_eq!(info.color_type, png::ColorType::Rgb);
-			assert_eq!(info.bit_depth, png::BitDepth::Eight);
-	
-			let mut buf: Vec<u8> = Vec::with_capacity(extent.width() as usize * extent.height() as usize * 4);
-	
-			// convert rgb to rgba
-			for y in 0..extent.height() {
-				for x in 0..extent.width() {
-					let index = ((x + y * extent.width()) * 3) as usize;
-					buf.push(buffer[index]);
-					buf.push(buffer[index + 1]);
-					buf.push(buffer[index + 2]);
-					buf.push(255);
-				}
-			}
-	
-			assert_eq!(extent.depth(), 1); // TODO: support 3D textures
-	
-			let rgba_surface = intel_tex_2::RgbaSurface {
-				data: &buf,
-				width: extent.width(),
-				height: extent.height(),
-				stride: extent.width() * 4,
-			};
-	
-			let settings = intel_tex_2::bc7::opaque_ultra_fast_settings();
-	
-			let resource_document = GenericResourceSerialization::new(asset_url.to_string(), Texture{
-				format: Formats::RGB8,
-				extent: extent.as_array(),
-				compression: Some(CompressionSchemes::BC7),
-			});
-	
-			Ok(vec![ProcessedResources::Generated((resource_document, intel_tex_2::bc7::compress_blocks(&settings, &rgba_surface)))])
-		})
-	}
-
-	fn read<'a>(&'a self, _resource: &'a dyn Resource, file: &'a mut File, buffers: &'a mut [Stream<'a>]) -> utils::BoxedFuture<'_, ()> {
-		Box::pin(async move {
-			file.read_exact(buffers[0].buffer).await.unwrap()
-		})
-	}
-
-	fn get_deserializers(&self) -> Vec<(&'static str, Box<dyn Fn(&polodb_core::bson::Document) -> Box<dyn Resource> + Send>)> {
-		vec![("Texture", Box::new(|document| {
-			let texture = Texture::deserialize(polodb_core::bson::Deserializer::new(document.into())).unwrap();
-			Box::new(texture)
-		}))]
-	}
-
-	fn create_resource<'a>(&'a self, resource: &'a CreateInfo, resource_manager: &'a crate::resource_manager::ResourceManager) -> utils::BoxedFuture<Result<Vec<ProcessedResources>, String>> {
-		async move {
-			let image_info = resource.info.downcast_ref::<CreateImage>().ok_or("Invalid resource info")?;
-
-			let bytes = resource.data;
-			let asset_url = resource.name;
-
-			let extent = Extent::rectangle(image_info.extent[0], image_info.extent[1]);
-
-			assert_eq!(extent.depth(), 1); // TODO: support 3D textures
-			
-			let (data, compression) = match image_info.format {
-				Formats::RGB8 => {
-					let mut buf: Vec<u8> = Vec::with_capacity(extent.width() as usize * extent.height() as usize * 4);
-
-					for y in 0..extent.height() {
-						for x in 0..extent.width() {
-							let index = ((x + y * extent.width()) * 3) as usize;
-							buf.push(bytes[index + 0]);
-							buf.push(bytes[index + 1]);
-							buf.push(bytes[index + 2]);
-							buf.push(255);
-						}
-					}
-
-					let rgba_surface = intel_tex_2::RgbaSurface {
-						data: &buf,
-						width: extent.width(),
-						height: extent.height(),
-						stride: extent.width() * 4,
-					};
-		
-					let settings = intel_tex_2::bc7::opaque_ultra_fast_settings();
-
-					(intel_tex_2::bc7::compress_blocks(&settings, &rgba_surface), Some(CompressionSchemes::BC7))
-				}
-				Formats::RGB16 => {
-					let mut buf: Vec<u8> = Vec::with_capacity(extent.width() as usize * extent.height() as usize * 8);
-
-					for y in 0..extent.height() {
-						for x in 0..extent.width() {
-							let index = ((x + y * extent.width()) * 6) as usize;
-							buf.push(bytes[index + 0]); buf.push(bytes[index + 1]);
-							buf.push(bytes[index + 2]); buf.push(bytes[index + 3]);
-							buf.push(bytes[index + 4]); buf.push(bytes[index + 5]);
-							buf.push(255); buf.push(255);
-						}
-					}
-
-					let rgba_surface = intel_tex_2::RgbaSurface {
-						data: &buf,
-						width: extent.width(),
-						height: extent.height(),
-						stride: extent.width() * 8,
-					};
-		
-					let settings = intel_tex_2::bc7::opaque_ultra_fast_settings();
-
-					(intel_tex_2::bc7::compress_blocks(&settings, &rgba_surface), Some(CompressionSchemes::BC7))
-				}
-				_ => {
-					(bytes.to_vec(), None)
-				}
-			};
-
-			let resource_document = GenericResourceSerialization::new(asset_url.to_string(), Texture{
-				format: image_info.format,
-				extent: extent.as_array(),
-				compression,
-			});
-
-			Ok(vec![ProcessedResources::Generated((resource_document, data))])
-		}.boxed()
-	}
-}
-
-pub struct CreateImage {
-	pub format: Formats,
-	pub extent: [u32; 3],
-}
-
-impl CreateResource for CreateImage {}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub enum CompressionSchemes {
-	BC7,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub enum Formats {
-	RGB8,
-	RGBA8,
-	RGB16,
-	RGBA16,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Texture {
-	pub compression: Option<CompressionSchemes>,
-	pub format: Formats,
-	pub extent: [u32; 3],
-}
-
-impl Resource for Texture {
-	fn get_class(&self) -> &'static str { "Texture"	}
-}
-
-#[cfg(test)]
-mod tests {
-	use std::any::Any;
-
-	use crate::resource_manager::ResourceManager;
-
-	use super::*;
-
-	#[test]
-	fn load_net_image() {
-		let mut resource_manager = ResourceManager::new();
-
-		resource_manager.add_resource_handler(ImageResourceHandler::new());
-
-		// smol::block_on(async {
-		// 	Timer::after(std::time::Duration::from_secs(60 * 3)).await;
-		// });
-
-		let (response, _) = smol::block_on(resource_manager.get("https://camo.githubusercontent.com/a49890a2fa4559f38b13e6427defe7579aee065a9a3f7ee37cf7cb86295bab79/68747470733a2f2f692e696d6775722e636f6d2f56525261434f702e706e67")).expect("Failed to load image");
-
-		assert_eq!(response.resources.len(), 1);
-
-		let resource_container = &response.resources[0];
-		let resource = &resource_container.resource;
-
-		let texture_info = resource.downcast_ref::<Texture>().unwrap();
-
-		assert_eq!(texture_info.extent, [4096, 1024, 1]);
-	}
-
-	#[test]
-	fn load_local_image() {
-		let mut resource_manager = ResourceManager::new();
-
-		resource_manager.add_resource_handler(ImageResourceHandler::new());
-
-		let (response, _) = smol::block_on(resource_manager.get("patterned_brick_floor_02_diff_2k")).expect("Failed to load image");
-
-		assert_eq!(response.resources.len(), 1);
-
-		let resource_container = &response.resources[0];
-		let resource = &resource_container.resource;
-
-		let texture_info = resource.downcast_ref::<Texture>().unwrap();
-
-		assert_eq!(texture_info.extent, [2048, 2048, 1]);
-	}
-}
\ No newline at end of file
diff --git a/resource_management/src/types.rs b/resource_management/src/types.rs
new file mode 100644
index 00000000..125dc7a5
--- /dev/null
+++ b/resource_management/src/types.rs
@@ -0,0 +1,293 @@
+use serde::{Deserialize, Serialize};
+
+use crate::{CreateResource, Resource};
+
+// Audio
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Copy)]
+pub enum BitDepths {
+	Eight,
+	Sixteen,
+	TwentyFour,
+	ThirtyTwo,
+}
+
+impl From<BitDepths> for usize {
+	fn from(bit_depth: BitDepths) -> Self {
+		match bit_depth {
+			BitDepths::Eight => 8,
+			BitDepths::Sixteen => 16,
+			BitDepths::TwentyFour => 24,
+			BitDepths::ThirtyTwo => 32,
+		}
+	}
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct Audio {
+	pub bit_depth: BitDepths,
+	pub channel_count: u16,
+	pub sample_rate: u32,
+	pub sample_count: u32,
+}
+
+impl Resource for Audio {
+	fn get_class(&self) -> &'static str { "Audio" }
+}
+
+// Material
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Model {
+	/// The name of the model.
+	pub name: String,
+	/// The render pass of the model.
+	pub pass: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum Value {
+	Scalar(f32),
+	Vector3([f32; 3]),
+	Vector4([f32; 4]),
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum Property {
+	Factor(Value),
+	Texture(String),
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum AlphaMode {
+	Opaque,
+	Mask(f32),
+	Blend,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Material {
+	pub(crate) albedo: Property,
+	pub(crate) normal: Property,
+	pub(crate) roughness: Property,
+	pub(crate) metallic: Property,
+	pub(crate) emissive: Property,
+	pub(crate) occlusion: Property,
+	pub(crate) double_sided: bool,
+	pub(crate) alpha_mode: AlphaMode,
+
+	/// The render model this material is for.
+	pub model: Model,
+}
+
+impl Resource for Material {
+	fn get_class(&self) -> &'static str { "Material" }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct VariantVariable {
+	pub name: String,
+	pub value: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Variant {
+	/// Parent material asset url.
+	pub parent: String,
+	pub variables: Vec<VariantVariable>,
+}
+
+impl Resource for Variant {
+	fn get_class(&self) -> &'static str { "Variant" }
+}
+
+/// Enumerates the types of shaders that can be created.
+#[derive(Clone, Copy, Serialize, Deserialize, Debug)]
+pub enum ShaderTypes {
+	/// A vertex shader.
+	Vertex,
+	/// A fragment shader.
+	Fragment,
+	/// A compute shader.
+	Compute,
+	Task,
+	Mesh,
+	RayGen,
+	ClosestHit,
+	AnyHit,
+	Intersection,
+	Miss,
+	Callable,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Shader {
+	pub stage: ShaderTypes,
+}
+
+impl Resource for Shader {
+	fn get_class(&self) -> &'static str { "Shader" }
+}
+
+// Mesh
+
+#[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub enum VertexSemantics {
+	Position,
+	Normal,
+	Tangent,
+	BiTangent,
+	Uv,
+	Color,
+}
+
+#[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub enum IntegralTypes {
+	U8,
+	I8,
+	U16,
+	I16,
+	U32,
+	I32,
+	F16,
+	F32,
+	F64,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+pub struct VertexComponent {
+	pub semantic: VertexSemantics,
+	pub format: String,
+	pub channel: u32,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum QuantizationSchemes {
+	Quantization,
+	Octahedral,
+	OctahedralQuantization,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+pub enum IndexStreamTypes {
+	Vertices,
+	Meshlets,
+	Triangles,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct IndexStream {
+	pub stream_type: IndexStreamTypes,
+	pub offset: usize,
+	pub count: u32,
+	pub data_type: IntegralTypes,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct MeshletStream {
+	pub offset: usize,
+	pub count: u32,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Primitive {
+	pub material: Material,
+	pub quantization: Option<QuantizationSchemes>,
+	pub bounding_box: [[f32; 3]; 2],
+	pub vertex_components: Vec<VertexComponent>,
+	pub vertex_count: u32,
+	pub index_streams: Vec<IndexStream>,
+	pub meshlet_stream: Option<MeshletStream>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SubMesh {
+	pub primitives: Vec<Primitive>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Mesh {
+	pub sub_meshes: Vec<SubMesh>,
+}
+
+impl Resource for Mesh {
+	fn get_class(&self) -> &'static str { "Mesh" }
+}
+
+pub trait Size {
+	fn size(&self) -> usize;
+}
+
+impl Size for VertexSemantics {
+	fn size(&self) -> usize {
+		match self {
+			VertexSemantics::Position => 3 * 4,
+			VertexSemantics::Normal => 3 * 4,
+			VertexSemantics::Tangent => 4 * 4,
+			VertexSemantics::BiTangent => 3 * 4,
+			VertexSemantics::Uv => 2 * 4,
+			VertexSemantics::Color => 4 * 4,
+		}
+	}
+}
+
+impl Size for Vec<VertexComponent> {
+	fn size(&self) -> usize {
+		let mut size = 0;
+
+		for component in self {
+			size += component.semantic.size();
+		}
+
+		size
+	}
+}
+
+impl Size for IntegralTypes {
+	fn size(&self) -> usize {
+		match self {
+			IntegralTypes::U8 => 1,
+			IntegralTypes::I8 => 1,
+			IntegralTypes::U16 => 2,
+			IntegralTypes::I16 => 2,
+			IntegralTypes::U32 => 4,
+			IntegralTypes::I32 => 4,
+			IntegralTypes::F16 => 2,
+			IntegralTypes::F32 => 4,
+			IntegralTypes::F64 => 8,
+		}
+	}
+}
+
+// Image
+
+pub struct CreateImage {
+	pub format: Formats,
+	pub extent: [u32; 3],
+}
+
+impl CreateResource for CreateImage {}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum CompressionSchemes {
+	BC7,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Formats {
+	RGB8,
+	RGBA8,
+	RGB16,
+	RGBA16,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Image {
+	pub compression: Option<CompressionSchemes>,
+	pub format: Formats,
+	pub extent: [u32; 3],
+}
+
+impl Resource for Image {
+	fn get_class(&self) -> &'static str { "Image" }
+}
\ No newline at end of file