From edc34ebe261b768d63a09c3b50e5a9b2c057a975 Mon Sep 17 00:00:00 2001 From: Facundo Villa Date: Sun, 21 Jul 2024 16:17:23 -0300 Subject: [PATCH] update dependencies, fix tests --- Cargo.lock | 66 ++++++++++++-- Cargo.toml | 2 - ghi/src/graphics_hardware_interface.rs | 76 ++++------------ ghi/src/vulkan/mod.rs | 80 +++++++++++------ resource_management/Cargo.toml | 5 +- .../src/asset/asset_manager.rs | 10 ++- .../src/asset/audio_asset_handler.rs | 4 +- .../src/asset/image_asset_handler.rs | 88 +++++++++---------- .../src/asset/material_asset_handler.rs | 82 ++++++++++------- .../src/asset/mesh_asset_handler.rs | 16 ++-- resource_management/src/asset/mod.rs | 6 +- resource_management/src/lib.rs | 6 +- src/input/input_manager.rs | 6 +- src/rendering/common_shader_generator.rs | 3 +- src/rendering/pipeline_manager.rs | 4 +- src/rendering/shadow_render_pass.rs | 5 +- src/rendering/ssao_render_pass.rs | 6 +- src/rendering/ssgi_render_pass.rs | 7 +- src/rendering/texture_manager.rs | 4 +- .../visibility_model/render_domain.rs | 4 +- src/rendering/visibility_shader_generator.rs | 5 +- src/window_system.rs | 6 +- utils/Cargo.toml | 3 +- utils/src/async.rs | 3 +- utils/src/lib.rs | 3 + 25 files changed, 280 insertions(+), 220 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index d7c972ba..4edc2c94 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -132,6 +132,12 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "arrayref" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545" + [[package]] name = "ash" version = "0.38.0+1.3.281" @@ -275,8 +281,6 @@ dependencies = [ "core", "dual_quaternion", "ghi", - "gxhash", - "json", "log", "machineid-rs", "maths-rs", @@ -564,6 +568,17 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "faststr" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f375fcf41ec4dac873a8028fba4210dbda5c86bba13d2d741e651b474f7c05a4" +dependencies = [ + "bytes", + "serde", + "simdutf8", +] + [[package]] name = "fdeflate" version = "0.3.4" @@ -982,9 +997,9 @@ dependencies = [ [[package]] name = "intel_tex_2" -version = "0.3.0" +version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "410e8e64fd296f11254dba8fccdc2ed35d8df41592fa96785ffc9877b6a9aaa5" +checksum = "bd699c0e6adcac28c06db24a220c834c8ec811e0d2d80f0261bb14e01737b4dc" dependencies = [ "ispc_rt", ] @@ -1170,9 +1185,9 @@ dependencies = [ [[package]] name = "meshopt" -version = "0.2.1" +version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa19b93af545a6bb30e8105b2a1450aa6b23e877f2131c9fb692dca6ec5bd80f" +checksum = "a0cad96c96b1c198160517f5dc7c247ef36ebb9d49015c0cfca0c0ee8d7d1bbc" dependencies = [ "bitflags 2.5.0", "cc", @@ -1324,6 +1339,16 @@ version = "1.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" +[[package]] +name = "page_size" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da" +dependencies = [ + "libc", + "winapi", +] + [[package]] name = "parking_lot" version = "0.12.1" @@ -1612,7 +1637,6 @@ dependencies = [ "gxhash", "half", "intel_tex_2", - "json", "libdeflater", "log", "maths-rs", @@ -1834,6 +1858,12 @@ version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe" +[[package]] +name = "simdutf8" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f27f6278552951f1f2b8cf9da965d10969b2efdea95a6ec47987ab46edfe263a" + [[package]] name = "simple_logger" version = "4.3.3" @@ -1873,6 +1903,27 @@ version = "1.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" +[[package]] +name = "sonic-rs" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e683c86e3ea4a72446733ca7f7dc5acadc70d5a37f272f32a87fe975e90afa9" +dependencies = [ + "arrayref", + "bumpalo", + "bytes", + "cfg-if", + "faststr", + "itoa", + "page_size", + "parking_lot", + "ryu", + "serde", + "simdutf8", + "smallvec", + "thiserror", +] + [[package]] name = "spin" version = "0.9.8" @@ -2138,6 +2189,7 @@ dependencies = [ "futures", "gxhash", "parking_lot", + "sonic-rs", "tokio", ] diff --git a/Cargo.toml b/Cargo.toml index 3892057f..dd63954b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -21,7 +21,6 @@ resource_management = { path = "resource_management" } component_derive = { path = "component_derive" } -json = "0.12.4" serde_json = "1.0.105" dual_quaternion = "0.2.0" maths-rs = "0.2.4" @@ -29,7 +28,6 @@ serde = "1.0.187" log = "0.4.20" simple_logger = "4.2.0" colored = "2.0.4" -gxhash = "3.4.1" machineid-rs = "1.2.4" [profile.dev] diff --git a/ghi/src/graphics_hardware_interface.rs b/ghi/src/graphics_hardware_interface.rs index 71c79a18..3a9faa7c 100644 --- a/ghi/src/graphics_hardware_interface.rs +++ b/ghi/src/graphics_hardware_interface.rs @@ -371,6 +371,7 @@ pub enum Descriptor { }, Swapchain(SwapchainHandle), Sampler(SamplerHandle), + StaticSamplers, } #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] @@ -547,7 +548,7 @@ pub trait GraphicsHardwareInterface where Self: Sized { fn create_acceleration_structure_instance_buffer(&mut self, name: Option<&str>, max_instance_count: u32) -> BaseBufferHandle; - fn create_top_level_acceleration_structure(&mut self, name: Option<&str>,) -> TopLevelAccelerationStructureHandle; + fn create_top_level_acceleration_structure(&mut self, name: Option<&str>, max_instance_count: u32) -> TopLevelAccelerationStructureHandle; fn create_bottom_level_acceleration_structure(&mut self, description: &BottomLevelAccelerationStructure) -> BottomLevelAccelerationStructureHandle; fn write_instance(&mut self, instances_buffer_handle: BaseBufferHandle, instance_index: usize, transform: [[f32; 4]; 3], custom_index: u16, mask: u8, sbt_record_offset: usize, acceleration_structure: BottomLevelAccelerationStructureHandle); @@ -1113,14 +1114,13 @@ impl <'a> BindingConstructor<'a> { } } - pub fn sampler_with_immutable_samplers(descriptor_set_binding_template: &'a DescriptorSetBindingTemplate, samplers: Option>) -> Self { - todo!(); - // Self { - // descriptor_set_binding_template, - // array_element: 0, - // descriptor: Descriptor::Sampler, - // frame_offset: None, - // } + pub fn sampler_with_immutable_samplers(descriptor_set_binding_template: &'a DescriptorSetBindingTemplate) -> Self { + Self { + descriptor_set_binding_template, + array_element: 0, + descriptor: Descriptor::StaticSamplers, + frame_offset: None, + } } fn acceleration_structure(bindings: &'a DescriptorSetBindingTemplate, top_level_acceleration_structure: TopLevelAccelerationStructureHandle) -> Self { @@ -1259,15 +1259,15 @@ impl DescriptorWrite { /// Describes the details of the memory layout of a particular image. pub struct ImageSubresourceLayout { /// The offset inside a memory region where the texture will read it's first texel from. - pub(super) offset: u64, + pub(super) offset: usize, /// The size of the texture in bytes. - pub(super) size: u64, + pub(super) size: usize, /// The row pitch of the texture. - pub(super) row_pitch: u64, + pub(super) row_pitch: usize, /// The array pitch of the texture. - pub(super) array_pitch: u64, + pub(super) array_pitch: usize, /// The depth pitch of the texture. - pub(super) depth_pitch: u64, + pub(super) depth_pitch: usize, } /// Describes the properties of a particular surface. @@ -1822,8 +1822,6 @@ use super::*; command_buffer_recording.copy_to_swapchain(render_target, image_index, swapchain); - let texure_copy_handles = command_buffer_recording.sync_textures(&[render_target]); - command_buffer_recording.execute(&[image_ready], &[render_finished_synchronizer], render_finished_synchronizer); renderer.present(modulo_frame_index, image_index, &[swapchain], render_finished_synchronizer); @@ -2330,7 +2328,7 @@ use super::*; let descriptor_set = renderer.create_descriptor_set(None, &descriptor_set_layout_handle,); - let sampler_binding = renderer.create_descriptor_binding(descriptor_set, BindingConstructor::sampler_with_immutable_samplers(&DescriptorSetBindingTemplate::new_with_immutable_samplers(0, Stages::FRAGMENT, Some(vec![sampler])), None)); // TODO: fix this + let sampler_binding = renderer.create_descriptor_binding(descriptor_set, BindingConstructor::sampler(&DescriptorSetBindingTemplate::new(0, DescriptorType::Sampler, Stages::FRAGMENT,), sampler)); let ubo_binding = renderer.create_descriptor_binding(descriptor_set, BindingConstructor::buffer(&DescriptorSetBindingTemplate::new(1, DescriptorType::StorageBuffer,Stages::VERTEX), buffer)); let tex_binding = renderer.create_descriptor_binding(descriptor_set, BindingConstructor::image(&DescriptorSetBindingTemplate::new(2, DescriptorType::SampledImage, Stages::FRAGMENT), sampled_texture, Layouts::Read)); @@ -2527,7 +2525,7 @@ void main() { let closest_hit_shader = renderer.create_shader(None, ShaderSource::GLSL(closest_hit_shader_code.to_string()), ShaderTypes::ClosestHit, &[ShaderBindingDescriptor::new(0, 2, AccessPolicies::READ), ShaderBindingDescriptor::new(0, 3, AccessPolicies::READ), ShaderBindingDescriptor::new(0, 4, AccessPolicies::READ)]).expect("Failed to create closest hit shader"); let miss_shader = renderer.create_shader(None, ShaderSource::GLSL(miss_shader_code.to_string()), ShaderTypes::Miss, &[]).expect("Failed to create miss shader"); - let top_level_acceleration_structure = renderer.create_top_level_acceleration_structure(Some("Top Level")); + let top_level_acceleration_structure = renderer.create_top_level_acceleration_structure(Some("Top Level"), 1); let bottom_level_acceleration_structure = renderer.create_bottom_level_acceleration_structure(&BottomLevelAccelerationStructure{ description: BottomLevelAccelerationStructureDescriptions::Mesh { vertex_count: 3, @@ -2564,7 +2562,6 @@ void main() { &[ShaderParameter::new(&raygen_shader, ShaderTypes::RayGen,), ShaderParameter::new(&closest_hit_shader, ShaderTypes::ClosestHit,), ShaderParameter::new(&miss_shader, ShaderTypes::Miss,)], ); - let building_command_buffer_handle = renderer.create_command_buffer(None); let rendering_command_buffer_handle = renderer.create_command_buffer(None); let render_finished_synchronizer = renderer.create_synchronizer(None, false); @@ -2574,8 +2571,6 @@ void main() { renderer.write_instance(instances_buffer, 0, [[1f32, 0f32, 0f32, 0f32], [0f32, 1f32, 0f32, 0f32], [0f32, 0f32, 1f32, 0f32]], 0, 0xFF, 0, bottom_level_acceleration_structure); - let build_sync = renderer.create_synchronizer(None, true); - let scratch_buffer = renderer.create_buffer(None, 1024 * 1024, Uses::AccelerationStructureBuildScratch, DeviceAccesses::GpuWrite, UseCases::STATIC); let raygen_sbt_buffer = renderer.create_buffer(None, 64, Uses::ShaderBindingTable, DeviceAccesses::CpuWrite | DeviceAccesses::GpuRead, UseCases::STATIC); @@ -2588,47 +2583,12 @@ void main() { for i in 0..FRAMES_IN_FLIGHT * 10 { let modulo_frame_index = (i % FRAMES_IN_FLIGHT) as u32; - // { - // renderer.wait(build_sync); - - // let mut command_buffer_recording = renderer.create_command_buffer_recording(building_command_buffer_handle, Some(i as u32)); - - // command_buffer_recording.build_bottom_level_acceleration_structures(&[BottomLevelAccelerationStructureBuild { - // acceleration_structure: bottom_level_acceleration_structure, - // description: BottomLevelAccelerationStructureBuildDescriptions::Mesh { - // vertex_buffer: BufferStridedRange { buffer: vertex_positions_buffer, offset: 0, stride: 12, size: 12 * 3 }, - // vertex_count: 3, - // index_buffer: BufferStridedRange { buffer: index_buffer, offset: 0, stride: 2, size: 2 * 3 }, - // vertex_position_encoding: Encodings::IEEE754, - // index_format: DataTypes::U16, - // triangle_count: 1, - // }, - // scratch_buffer: BufferDescriptor { buffer: scratch_buffer, offset: 0, range: 1024 * 512, slot: 0 }, - // }]); - - // command_buffer_recording.build_top_level_acceleration_structure(&TopLevelAccelerationStructureBuild { - // acceleration_structure: top_level_acceleration_structure, - // description: TopLevelAccelerationStructureBuildDescriptions::Instance { - // instances_buffer, - // instance_count: 1, - // }, - // scratch_buffer: BufferDescriptor { buffer: scratch_buffer, offset: 1024 * 512, range: 1024 * 512, slot: 0 }, - // }); - - // command_buffer_recording.execute(&[], &[build_sync], build_sync); - // } - - // renderer.wait(render_finished_synchronizer); renderer.start_frame_capture(); let mut command_buffer_recording = renderer.create_command_buffer_recording(rendering_command_buffer_handle, Some(i as u32)); { - // renderer.wait(build_sync); - - // let mut command_buffer_recording = renderer.create_command_buffer_recording(building_command_buffer_handle, Some(i as u32)); - command_buffer_recording.build_bottom_level_acceleration_structures(&[BottomLevelAccelerationStructureBuild { acceleration_structure: bottom_level_acceleration_structure, description: BottomLevelAccelerationStructureBuildDescriptions::Mesh { @@ -2659,8 +2619,6 @@ void main() { }, scratch_buffer: BufferDescriptor { buffer: scratch_buffer, offset: 1024 * 512, range: 1024 * 512, slot: 0 }, }); - - // command_buffer_recording.execute(&[], &[build_sync], build_sync); } let ray_tracing_pipeline_command = command_buffer_recording.bind_ray_tracing_pipeline(&pipeline); @@ -2709,7 +2667,7 @@ void main() { let texure_copy_handles = command_buffer_recording.sync_textures(&[render_target]); - command_buffer_recording.execute(&[/*build_sync,*/], &[], render_finished_synchronizer); + command_buffer_recording.execute(&[], &[], render_finished_synchronizer); renderer.end_frame_capture(); diff --git a/ghi/src/vulkan/mod.rs b/ghi/src/vulkan/mod.rs index 7eb5864c..fb105a33 100644 --- a/ghi/src/vulkan/mod.rs +++ b/ghi/src/vulkan/mod.rs @@ -785,7 +785,7 @@ impl graphics_hardware_interface::GraphicsHardwareInterface for VulkanGHI { let texture_handle = ImageHandle(self.images.len() as u64); if extent.width != 0 && extent.height != 0 && extent.depth != 0 { - let m_device_accesses = if device_accesses.contains(graphics_hardware_interface::DeviceAccesses::CpuWrite) { + let m_device_accesses = if device_accesses.intersects(graphics_hardware_interface::DeviceAccesses::CpuWrite | graphics_hardware_interface::DeviceAccesses::CpuRead) { graphics_hardware_interface::DeviceAccesses::GpuRead | graphics_hardware_interface::DeviceAccesses::GpuWrite } else { device_accesses @@ -802,7 +802,7 @@ impl graphics_hardware_interface::GraphicsHardwareInterface for VulkanGHI { let (staging_buffer, pointer) = if device_accesses.contains(graphics_hardware_interface::DeviceAccesses::CpuRead) { let staging_buffer_creation_result = self.create_vulkan_buffer(name, size, vk::BufferUsageFlags::TRANSFER_DST | vk::BufferUsageFlags::SHADER_DEVICE_ADDRESS); - let (allocation_handle, _) = self.create_allocation_internal(staging_buffer_creation_result.size, texture_creation_result.memory_flags.into(), graphics_hardware_interface::DeviceAccesses::CpuRead); + let (allocation_handle, _) = self.create_allocation_internal(staging_buffer_creation_result.size, staging_buffer_creation_result.memory_flags.into(), graphics_hardware_interface::DeviceAccesses::CpuRead); let (address, pointer) = self.bind_vulkan_buffer_memory(&staging_buffer_creation_result, allocation_handle, 0); @@ -944,7 +944,7 @@ impl graphics_hardware_interface::GraphicsHardwareInterface for VulkanGHI { buffer_handle } - fn create_top_level_acceleration_structure(&mut self, name: Option<&str>,) -> graphics_hardware_interface::TopLevelAccelerationStructureHandle { + fn create_top_level_acceleration_structure(&mut self, name: Option<&str>, max_instance_count: u32) -> graphics_hardware_interface::TopLevelAccelerationStructureHandle { let geometry = vk::AccelerationStructureGeometryKHR::default() .geometry_type(vk::GeometryTypeKHR::INSTANCES) .geometry(vk::AccelerationStructureGeometryDataKHR { instances: vk::AccelerationStructureGeometryInstancesDataKHR::default() }) @@ -960,7 +960,7 @@ impl graphics_hardware_interface::GraphicsHardwareInterface for VulkanGHI { let mut size_info = vk::AccelerationStructureBuildSizesInfoKHR::default(); unsafe { - self.acceleration_structure.get_acceleration_structure_build_sizes(vk::AccelerationStructureBuildTypeKHR::DEVICE, &build_info, &[0], &mut size_info); + self.acceleration_structure.get_acceleration_structure_build_sizes(vk::AccelerationStructureBuildTypeKHR::DEVICE, &build_info, &[max_instance_count], &mut size_info); } let acceleration_structure_size = size_info.acceleration_structure_size as usize; @@ -2717,14 +2717,23 @@ impl VulkanGHI { let texture = self.images.get(texture.0 as usize).expect("No texture with that handle."); - let image_subresource_layout = unsafe { self.device.get_image_subresource_layout(texture.image, image_subresource) }; - - graphics_hardware_interface::ImageSubresourceLayout { - offset: image_subresource_layout.offset, - size: image_subresource_layout.size, - row_pitch: image_subresource_layout.row_pitch, - array_pitch: image_subresource_layout.array_pitch, - depth_pitch: image_subresource_layout.depth_pitch, + if true /* TILING_OPTIMAL */ { + graphics_hardware_interface::ImageSubresourceLayout { + offset: 0, + size: texture.size, + row_pitch: texture.extent.width as usize * texture.format_.size(), + array_pitch: texture.extent.width as usize * texture.extent.height as usize * texture.format_.size(), + depth_pitch: texture.extent.width as usize * texture.extent.height as usize * texture.extent.depth as usize * texture.format_.size(), + } + } else { + let image_subresource_layout = unsafe { self.device.get_image_subresource_layout(texture.image, image_subresource) }; + graphics_hardware_interface::ImageSubresourceLayout { + offset: image_subresource_layout.offset as usize, + size: image_subresource_layout.size as usize, + row_pitch: image_subresource_layout.row_pitch as usize, + array_pitch: image_subresource_layout.array_pitch as usize, + depth_pitch: image_subresource_layout.depth_pitch as usize, + } } } @@ -2863,18 +2872,22 @@ impl VulkanGHI { fn create_allocation_internal(&mut self, size: usize, memory_bits: Option, device_accesses: graphics_hardware_interface::DeviceAccesses) -> (graphics_hardware_interface::AllocationHandle, Option<*mut u8>) { let memory_properties = unsafe { self.instance.get_physical_device_memory_properties(self.physical_device) }; + let memory_property_flags = { + let mut memory_property_flags = vk::MemoryPropertyFlags::empty(); + + memory_property_flags |= if device_accesses.contains(graphics_hardware_interface::DeviceAccesses::CpuRead) { vk::MemoryPropertyFlags::HOST_VISIBLE } else { vk::MemoryPropertyFlags::empty() }; + memory_property_flags |= if device_accesses.contains(graphics_hardware_interface::DeviceAccesses::CpuWrite) { vk::MemoryPropertyFlags::HOST_COHERENT } else { vk::MemoryPropertyFlags::empty() }; + memory_property_flags |= if device_accesses.contains(graphics_hardware_interface::DeviceAccesses::GpuRead) { vk::MemoryPropertyFlags::DEVICE_LOCAL } else { vk::MemoryPropertyFlags::empty() }; + memory_property_flags |= if device_accesses.contains(graphics_hardware_interface::DeviceAccesses::GpuWrite) { vk::MemoryPropertyFlags::DEVICE_LOCAL } else { vk::MemoryPropertyFlags::empty() }; + + memory_property_flags + }; + let memory_type_index = memory_properties .memory_types .iter() .enumerate() .find_map(|(index, memory_type)| { - let mut memory_property_flags = vk::MemoryPropertyFlags::empty(); - - memory_property_flags |= if device_accesses.contains(graphics_hardware_interface::DeviceAccesses::CpuRead) { vk::MemoryPropertyFlags::HOST_VISIBLE } else { vk::MemoryPropertyFlags::empty() }; - memory_property_flags |= if device_accesses.contains(graphics_hardware_interface::DeviceAccesses::CpuWrite) { vk::MemoryPropertyFlags::HOST_COHERENT } else { vk::MemoryPropertyFlags::empty() }; - memory_property_flags |= if device_accesses.contains(graphics_hardware_interface::DeviceAccesses::GpuRead) { vk::MemoryPropertyFlags::DEVICE_LOCAL } else { vk::MemoryPropertyFlags::empty() }; - memory_property_flags |= if device_accesses.contains(graphics_hardware_interface::DeviceAccesses::GpuWrite) { vk::MemoryPropertyFlags::DEVICE_LOCAL } else { vk::MemoryPropertyFlags::empty() }; - let memory_type = memory_type.property_flags.contains(memory_property_flags); if (memory_bits.unwrap_or(0) & (1 << index)) != 0 && memory_type { @@ -3085,6 +3098,7 @@ impl VulkanGHI { unsafe { self.device.update_descriptor_sets(&[write_info], &[]) }; } }, + graphics_hardware_interface::Descriptor::StaticSamplers => {} graphics_hardware_interface::Descriptor::Swapchain(_) => { unimplemented!() } @@ -4203,20 +4217,32 @@ impl graphics_hardware_interface::CommandBufferRecording for VulkanCommandBuffer } fn sync_textures(&mut self, image_handles: &[graphics_hardware_interface::ImageHandle]) -> Vec { - unsafe { self.consume_resources(&image_handles.iter().map(|image_handle| Consumption { - handle: Handle::Image(self.get_internal_image_handle(*image_handle)), - stages: graphics_hardware_interface::Stages::TRANSFER, - access: graphics_hardware_interface::AccessPolicies::READ, - layout: graphics_hardware_interface::Layouts::Transfer, - }).collect::>()) }; + unsafe { + self.consume_resources(&image_handles.iter().map(|image_handle| Consumption { + handle: Handle::Image(self.get_internal_image_handle(*image_handle)), + stages: graphics_hardware_interface::Stages::TRANSFER, + access: graphics_hardware_interface::AccessPolicies::READ, + layout: graphics_hardware_interface::Layouts::Transfer, + }).collect::>()); + + let buffer_handles = image_handles.iter().filter_map(|image_handle| self.get_image(self.get_internal_image_handle(*image_handle)).staging_buffer).collect::>(); + + self.consume_resources(&buffer_handles.iter().map(|buffer_handle| Consumption { + handle: Handle::Buffer(*buffer_handle), + stages: graphics_hardware_interface::Stages::TRANSFER, + access: graphics_hardware_interface::AccessPolicies::WRITE, + layout: graphics_hardware_interface::Layouts::Transfer, + }).collect::>()); + }; let command_buffer = self.get_command_buffer(); + let command_buffer = command_buffer.command_buffer; for image_handle in image_handles { let image = self.get_image(self.get_internal_image_handle(*image_handle)); // If texture has an associated staging_buffer_handle, copy texture data to staging buffer if let Some(staging_buffer_handle) = image.staging_buffer { - let staging_buffer = &self.ghi.buffers[staging_buffer_handle.0 as usize]; + let staging_buffer = self.get_buffer(staging_buffer_handle); let regions = [vk::BufferImageCopy2KHR::default() .buffer_offset(0) @@ -4235,7 +4261,7 @@ impl graphics_hardware_interface::CommandBufferRecording for VulkanCommandBuffer ; unsafe { - self.ghi.device.cmd_copy_image_to_buffer2(command_buffer.command_buffer, ©_image_to_buffer_info); + self.ghi.device.cmd_copy_image_to_buffer2(command_buffer, ©_image_to_buffer_info); } } } diff --git a/resource_management/Cargo.toml b/resource_management/Cargo.toml index 2af373d3..413f414a 100644 --- a/resource_management/Cargo.toml +++ b/resource_management/Cargo.toml @@ -13,12 +13,11 @@ shaderc = "0.8.2" png = "0.17.10" polodb_core = "4.4.0" notify-debouncer-full = { version = "0.3.1", default-features = false } -intel_tex_2 = "0.3.0" +intel_tex_2 = "0.4.0" gltf = { version = "1.3.0", features = ["image"] } ureq = "2.7.1" libdeflater = "1.19.0" -meshopt = "0.2.0" -json = "0.12.4" +meshopt = "0.3.0" serde = "1.0.187" log = "0.4.20" futures = "0.3.30" diff --git a/resource_management/src/asset/asset_manager.rs b/resource_management/src/asset/asset_manager.rs index 024b35b2..e72510dc 100644 --- a/resource_management/src/asset/asset_manager.rs +++ b/resource_management/src/asset/asset_manager.rs @@ -243,7 +243,9 @@ fn assets_path() -> std::path::PathBuf { #[cfg(test)] pub mod tests { - use crate::asset::asset_handler::Asset; + use utils::json; + +use crate::asset::asset_handler::Asset; use super::*; @@ -315,7 +317,7 @@ pub mod tests { asset_manager.add_asset_handler(test_asset_handler); - let _ = json::parse(r#"{"url": "http://example.com"}"#).unwrap(); + let _: json::Value = json::from_str(r#"{"url": "http://example.com"}"#).unwrap(); // assert_eq!(smol::block_on(asset_manager.load("example", &json)), Ok(())); } @@ -325,7 +327,7 @@ pub mod tests { fn test_load_no_asset_handler() { let asset_manager = AssetManager::new(std::path::PathBuf::from("../assets"),); - let _ = json::parse(r#"{"url": "http://example.com"}"#).unwrap(); + let _: json::Value = json::from_str(r#"{"url": "http://example.com"}"#).unwrap(); // assert_eq!(smol::block_on(asset_manager.load("example", &json)), Err(LoadMessages::NoAssetHandler)); } @@ -335,7 +337,7 @@ pub mod tests { fn test_load_no_asset_url() { let asset_manager = AssetManager::new(std::path::PathBuf::from("../assets"),); - let _ = json::parse(r#"{}"#).unwrap(); + let _: json::Value = json::from_str(r#"{}"#).unwrap(); // assert_eq!(smol::block_on(asset_manager.load("example", &json)), Err(LoadMessages::NoURL)); } diff --git a/resource_management/src/asset/audio_asset_handler.rs b/resource_management/src/asset/audio_asset_handler.rs index 8c326ec8..dec21050 100644 --- a/resource_management/src/asset/audio_asset_handler.rs +++ b/resource_management/src/asset/audio_asset_handler.rs @@ -155,7 +155,9 @@ mod tests { let storage_backend = asset_manager.get_test_storage_backend(); - block_on(audio_asset_handler.load(&asset_manager, storage_backend, url)).expect("Audio asset handler failed to load asset"); + let asset = block_on(audio_asset_handler.load(&asset_manager, storage_backend, url)).expect("Audio asset handler failed to load asset"); + + let _ = block_on(asset.load(&asset_manager, storage_backend, url)).expect("Audio asset failed to load"); let generated_resources = storage_backend.get_resources(); diff --git a/resource_management/src/asset/image_asset_handler.rs b/resource_management/src/asset/image_asset_handler.rs index 0f91e731..0834b943 100644 --- a/resource_management/src/asset/image_asset_handler.rs +++ b/resource_management/src/asset/image_asset_handler.rs @@ -77,7 +77,7 @@ impl AssetHandler for ImageAssetHandler { // decoder.set_transformations(png::Transformations::normalize_to_color8()); } let mut reader = decoder.read_info().unwrap(); - buffer = vec![0; reader.output_buffer_size()]; + buffer = vec![0u8; reader.output_buffer_size()]; let info = reader.next_frame(&mut buffer).unwrap(); extent = Extent::rectangle(info.width, info.height); @@ -123,7 +123,7 @@ impl AssetHandler for ImageAssetHandler { Ok(Box::new(ImageAsset { id: url.to_string(), - data, + data: buffer.into(), gamma, format, extent, @@ -175,15 +175,17 @@ impl ImageAssetHandler { let (data, format) = match format { Formats::RGB8 => { - let mut buf: Vec = Vec::with_capacity(extent.width() as usize * extent.height() as usize * 4); + let mut buf: Box<[u8]> = vec![0_u8; extent.width() as usize * extent.height() as usize * 4].into(); for y in 0..extent.height() { + let source_row = &buffer[(y * extent.width() * 3) as usize..][..(extent.width() * 3) as usize]; + let dest_row = &mut buf[(y * extent.width() * 4) as usize..][..(extent.width() * 4) as usize]; + for x in 0..extent.width() { - let index = ((x + y * extent.width()) * 3) as usize; - buf.push(buffer[index + 0]); - buf.push(buffer[index + 1]); - buf.push(buffer[index + 2]); - buf.push(0xFF); + let source_pixel = &source_row[(x * 3) as usize..][..3]; + let dest_pixel = &mut dest_row[(x * 4) as usize..][..4]; + dest_pixel[..3].copy_from_slice(source_pixel); + dest_pixel[3] = 0xFF; } } @@ -199,40 +201,29 @@ impl ImageAssetHandler { } } } - Formats::RGBA8 => { + Formats::RGBA8 => { match (compress, semantic) { (true, Semantic::Normal) => { - let mut buf: Vec = Vec::with_capacity(extent.width() as usize * extent.height() as usize * 4); + let mut buf: Box<[u8]> = vec![0_u8; extent.width() as usize * extent.height() as usize * 4].into(); for y in 0..extent.height() { + let source_row = &buffer[(y * extent.width() * 4) as usize..][..(extent.width() * 4) as usize]; + let dest_row = &mut buf[(y * extent.width() * 4) as usize..][..(extent.width() * 4) as usize]; for x in 0..extent.width() { - let index = ((x + y * extent.width()) * 4) as usize; - buf.push(buffer[index + 0]); - buf.push(buffer[index + 1]); - buf.push(buffer[index + 2]); - buf.push(0xFF); + let source_pixel = &source_row[(x * 4) as usize..][..4]; + let dest_pixel = &mut dest_row[(x * 4) as usize..][..4]; + dest_pixel[..3].copy_from_slice(&source_pixel[..3]); + dest_pixel[3] = 0xFF; } } (buf, Formats::BC5) } (compress, _) => { - let mut buf: Vec = 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()) * 4) as usize; - buf.push(buffer[index + 0]); - buf.push(buffer[index + 1]); - buf.push(buffer[index + 2]); - buf.push(buffer[index + 3]); - } - } - if compress { - (buf, Formats::BC7) + (buffer, Formats::BC7) } else { - (buf, Formats::RGBA8) + (buffer, Formats::RGBA8) } } } @@ -240,31 +231,36 @@ impl ImageAssetHandler { Formats::RGB16 => { match (compress, semantic) { (true, Semantic::Normal) => { - let mut buf: Vec = Vec::with_capacity(extent.width() as usize * extent.height() as usize * 4); + let mut buf: Box<[u8]> = vec![0_u8; extent.width() as usize * extent.height() as usize * 4].into(); for y in 0..extent.height() { + let source_row = &buffer[(y * extent.width() * 6) as usize..][..(extent.width() * 6) as usize]; + let dest_row = &mut buf[(y * extent.width() * 4) as usize..][..(extent.width() * 4) as usize]; for x in 0..extent.width() { - let index = ((x + y * extent.width()) * 6) as usize; - let x = u16::from_le_bytes([buffer[index + 0], buffer[index + 1]]); - let y = u16::from_le_bytes([buffer[index + 2], buffer[index + 3]]); + let source_pixel = &source_row[(x * 6) as usize..][..6]; + let dest_pixel = &mut dest_row[(x * 4) as usize..][..4]; + let x = u16::from_le_bytes([source_pixel[0], source_pixel[1]]); + let y = u16::from_le_bytes([source_pixel[2], source_pixel[3]]); let x: u8 = (x / 256) as u8; let y: u8 = (y / 256) as u8; - buf.push(x); buf.push(y); buf.push(0x00); buf.push(0xFF); + dest_pixel[0] = x; dest_pixel[1] = y; + dest_pixel[2] = 0x00; dest_pixel[3] = 0xFF; } } (buf, Formats::BC5) } (compress, _) => { - let mut buf: Vec = Vec::with_capacity(extent.width() as usize * extent.height() as usize * 8); + let mut buf: Box<[u8]> = vec![0_u8; extent.width() as usize * extent.height() as usize * 8].into(); for y in 0..extent.height() { + let source_row = &buffer[(y * extent.width() * 6) as usize..][..(extent.width() * 6) as usize]; + let dest_row = &mut buf[(y * extent.width() * 8) as usize..][..(extent.width() * 8) as usize]; for x in 0..extent.width() { - let index = ((x + y * extent.width()) * 6) as usize; - buf.push(buffer[index + 0]); buf.push(buffer[index + 1]); - buf.push(buffer[index + 2]); buf.push(buffer[index + 3]); - buf.push(buffer[index + 4]); buf.push(buffer[index + 5]); - buf.push(0xFF); buf.push(0xFF); + let source_pixel = &source_row[(x * 6) as usize..][..6]; + let dest_pixel = &mut dest_row[(x * 8) as usize..][..8]; + dest_pixel[..6].copy_from_slice(&source_pixel); + dest_pixel[6] = 0xFF; dest_pixel[7] = 0xFF; } } @@ -283,14 +279,14 @@ impl ImageAssetHandler { let data = match format { Formats::BC5 => { - let rgba_surface = intel_tex_2::RgbaSurface { + let rgba_surface = intel_tex_2::RgSurface { data: &data, width: extent.width(), height: extent.height(), stride: extent.width() * 4, }; - intel_tex_2::bc5::compress_blocks(&rgba_surface) + intel_tex_2::bc5::compress_blocks(&rgba_surface).into() } Formats::RGB8 | Formats::RGBA8 => { data @@ -305,7 +301,7 @@ impl ImageAssetHandler { let settings = intel_tex_2::bc7::opaque_ultra_fast_settings(); - intel_tex_2::bc7::compress_blocks(&settings, &rgba_surface) + intel_tex_2::bc7::compress_blocks(&settings, &rgba_surface).into() } Formats::RGB16 | Formats::RGBA16 => { data @@ -320,7 +316,7 @@ impl ImageAssetHandler { extent: extent.as_array(), gamma: *gamma, }, - data.into()) + data) } } @@ -369,7 +365,9 @@ mod tests { let storage_backend = asset_manager.get_test_storage_backend(); - let _ = block_on(asset_handler.load(&asset_manager, storage_backend, url,)).expect("Image asset handler did not handle asset"); + let asset = block_on(asset_handler.load(&asset_manager, storage_backend, url,)).expect("Image asset handler did not handle asset"); + + let _ = block_on(asset.load(&asset_manager, storage_backend, url,)).expect("Image asset did not load"); let generated_resources = storage_backend.get_resources(); diff --git a/resource_management/src/asset/material_asset_handler.rs b/resource_management/src/asset/material_asset_handler.rs index fb5324ea..0fb75b06 100644 --- a/resource_management/src/asset/material_asset_handler.rs +++ b/resource_management/src/asset/material_asset_handler.rs @@ -1,9 +1,9 @@ -use std::{ops::Deref, sync::Arc}; +use std::sync::Arc; use futures::future::{join, join_all, try_join_all}; use log::debug; use polodb_core::bson::Bson; -use utils::Extent; +use utils::{json::{self, JsonContainerTrait, JsonValueTrait}, Extent}; use crate::{material::{MaterialModel, ParameterModel, RenderModel, Shader, ValueModel, VariantModel, VariantVariableModel}, shader_generation::{ShaderGenerationSettings, ShaderGenerator}, types::{AlphaMode, ShaderTypes}, GenericResourceResponse, ProcessedAsset, ReferenceModel, StorageBackend}; @@ -11,21 +11,21 @@ use super::{asset_handler::{Asset, AssetHandler, LoadErrors}, asset_manager::Ass pub trait ProgramGenerator: Send + Sync { /// Transforms a program. - fn transform(&self, node: besl::parser::Node, material: &json::JsonValue) -> besl::parser::Node; + fn transform(&self, node: besl::parser::Node, material: &json::Object) -> besl::parser::Node; } struct MaterialAsset { id: String, - asset: json::JsonValue, + asset: json::Object, generator: Arc, } impl Asset for MaterialAsset { fn requested_assets(&self) -> Vec { let asset = &self.asset; - let is_material = asset["parent"].is_null(); + let is_material = asset.get(&"parent").is_none(); if is_material { - asset["variables"].members().filter_map(|v| + asset["variables"].as_array().unwrap().iter().filter_map(|v| if v["data_type"] == "Texture2D" { Some(v["value"].as_str().unwrap().to_string()) } else { @@ -40,7 +40,7 @@ impl Asset for MaterialAsset { fn load<'a>(&'a self, asset_manager: &'a AssetManager, storage_backend: &'a dyn StorageBackend, url: ResourceId<'a>) -> utils::SendBoxedFuture> { Box::pin(async move { let asset = &self.asset; - let is_material = asset["parent"].is_null(); + let is_material = asset.get(&"parent").is_none(); let to_value = async |t: String, v: String| { let to_color = |name: &str| { @@ -80,22 +80,32 @@ impl Asset for MaterialAsset { let generator = generator; - let shaders = try_join_all(asset["shaders"].entries().map(|(s_type, shader_json): (&str, &json::JsonValue)| { + let asset_shaders = match asset["shaders"].as_object() { + Some(v) => v, + None => { return Err("Shaders not found".to_string()); } + }; + + let shaders = try_join_all(asset_shaders.iter().map(|(s_type, shader_json): (&str, &json::Value)| { transform_shader(generator, storage_backend, &material_domain, &asset, &shader_json, s_type) })); - let values = join_all(asset["variables"].members().map(|v: &json::JsonValue| { - let data_type = v["data_type"].to_string(); - let value = v["value"].to_string(); + let asset_variables = match asset["variables"].as_array() { + Some(v) => v, + None => { return Err("Variables not found".to_string()); } + }; + + let values = join_all(asset_variables.iter().map(|v: &json::Value| { + let data_type = v["data_type"].as_str().unwrap().to_string(); + let value = v["value"].as_str().unwrap().to_string(); to_value(data_type, value) })); let (shaders, values) = join(shaders, values).await; - let parameters = asset["variables"].members().zip(values.into_iter()).map(|(v, value)| { - let name = v["name"].to_string(); - let data_type = v["data_type"].to_string(); + let parameters = asset_variables.iter().zip(values.into_iter()).map(|(v, value)| { + let name = v["name"].as_str().unwrap().to_string(); + let data_type = v["data_type"].as_str().unwrap().to_string(); ParameterModel { name, @@ -125,14 +135,22 @@ impl Asset for MaterialAsset { let material = asset_manager.load(parent_material_url).await.or_else(|_| { Err("Failed to load parent material") })?; - let values = join_all(material.resource.as_document().unwrap().get_array("parameters").unwrap().iter().map(|v: &Bson| { + let values = try_join_all(material.resource.as_document().unwrap().get_array("parameters").unwrap().iter().map(async |v: &Bson| { let v = v.as_document().unwrap(); let name = v.get_str("name").unwrap().to_string(); let r#type = v.get_str("type").unwrap().to_string(); - let value = asset["variables"].members().find(|v2| { v2["name"].to_string() == name }).unwrap()["value"].to_string(); + let value = match asset["variables"].as_array() { + Some(v) => { + match v.iter().find(|v2| { v2["name"].as_str().unwrap() == name }) { + Some(v) => v["value"].as_str().unwrap().to_string(), + None => { return Err("Variable not found".to_string()); } + } + } + None => { return Err("Variable not found".to_string()); } + }; - to_value(r#type, value) - })).await; + Ok(to_value(r#type, value).await) + })).await.or_else(|e| { debug!("{}", e); Err("Failed to load variant") })?; let variables = material.resource.as_document().unwrap().get_array("parameters").unwrap().iter().zip(values.into_iter()).map(|(v, value)| { let v = v.as_document().unwrap(); @@ -146,12 +164,12 @@ impl Asset for MaterialAsset { } }).collect(); - let alpha_mode = match &asset["transparency"] { - json::JsonValue::Boolean(v) => { - if *v { AlphaMode::Blend } else { AlphaMode::Opaque } + let alpha_mode = match asset.get(&"transparency").map(|e| e.as_ref()) { + Some(json::ValueRef::Bool(v)) => { + if v { AlphaMode::Blend } else { AlphaMode::Opaque } } - json::JsonValue::String(s) => { - match s.as_str() { + Some(json::ValueRef::String(s)) => { + match s { "Opaque" => AlphaMode::Opaque, "Blend" => AlphaMode::Blend, _ => AlphaMode::Opaque @@ -212,7 +230,7 @@ impl AssetHandler for MaterialAssetHandler { return Err(LoadErrors::UnsupportedType); } - let asset_json = json::parse(std::str::from_utf8(&data).or_else(|_| { Err(LoadErrors::FailedToProcess) })?).or_else(|_| { Err(LoadErrors::FailedToProcess) })?; + let asset_json = json::from_str(std::str::from_utf8(&data).or_else(|_| { Err(LoadErrors::FailedToProcess) })?).or_else(|_| { Err(LoadErrors::FailedToProcess) })?; Ok(Box::new(MaterialAsset { id: url.to_string(), @@ -222,7 +240,7 @@ impl AssetHandler for MaterialAssetHandler { }) } } -fn compile_shader(generator: &dyn ProgramGenerator, name: &str, shader_code: &str, format: &str, domain: &str, material: &json::JsonValue, shader_json: &json::JsonValue, stage: &str) -> Result<(Shader, Box<[u8]>), ()> { +fn compile_shader(generator: &dyn ProgramGenerator, name: &str, shader_code: &str, format: &str, domain: &str, material: &json::Object, shader_json: &json::Value, stage: &str) -> Result<(Shader, Box<[u8]>), ()> { let root_node = if format == "glsl" { // besl::parser::NodeReference::glsl(&shader_code,/*Vec::new()*/) panic!() @@ -312,7 +330,7 @@ fn compile_shader(generator: &dyn ProgramGenerator, name: &str, shader_code: &st Ok((shader, result_shader_bytes)) } -async fn transform_shader(generator: &dyn ProgramGenerator, storage_backend: &dyn StorageBackend, domain: &str, material: &json::JsonValue, shader_json: &json::JsonValue, stage: &str) -> Result<(ReferenceModel, Box<[u8]>), ()> { +async fn transform_shader(generator: &dyn ProgramGenerator, storage_backend: &dyn StorageBackend, domain: &str, material: &json::Object, shader_json: &json::Value, stage: &str) -> Result<(ReferenceModel, Box<[u8]>), ()> { let path = shader_json.as_str().ok_or(())?; let path = ResourceId::new(path); let (arlp, _, format) = storage_backend.resolve(path).await.or(Err(()))?; @@ -329,7 +347,7 @@ async fn transform_shader(generator: &dyn ProgramGenerator, storage_backend: &dy #[cfg(test)] pub mod tests { - use utils::r#async::block_on; + use utils::{r#async::{self, block_on}, json}; use super::{MaterialAssetHandler, ProgramGenerator}; use crate::{asset::{asset_handler::AssetHandler, asset_manager::AssetManager, ResourceId,}, material::VariantModel, ReferenceModel}; @@ -345,7 +363,7 @@ pub mod tests { } impl ProgramGenerator for RootTestShaderGenerator { - fn transform(&self, mut root: besl::parser::Node, material: &json::JsonValue) -> besl::parser::Node { + fn transform(&self, mut root: besl::parser::Node, material: &json::Object) -> besl::parser::Node { let material_struct = besl::parser::Node::buffer("Material", vec![besl::parser::Node::member("color", "vec4f")]); let sample_function = besl::parser::Node::function("sample_", vec![besl::parser::Node::member("t", "u32")], "void", vec![]); @@ -367,7 +385,7 @@ pub mod tests { } impl ProgramGenerator for MidTestShaderGenerator { - fn transform(&self, mut root: besl::parser::Node, material: &json::JsonValue) -> besl::parser::Node { + fn transform(&self, mut root: besl::parser::Node, material: &json::Object) -> besl::parser::Node { let binding = besl::parser::Node::binding("materials", besl::parser::Node::buffer("Materials", vec![besl::parser::Node::member("materials", "Material[16]")]), 0, 0, true, false); let leaf_test_shader_generator = LeafTestShaderGenerator::new(); @@ -387,7 +405,7 @@ pub mod tests { } impl ProgramGenerator for LeafTestShaderGenerator { - fn transform(&self, mut root: besl::parser::Node, _: &json::JsonValue) -> besl::parser::Node { + fn transform(&self, mut root: besl::parser::Node, _: &json::Object) -> besl::parser::Node { let push_constant = besl::parser::Node::push_constant(vec![besl::parser::Node::member("material_index", "u32")]); let main = besl::parser::Node::function("main", vec![], "void", vec![besl::parser::Node::glsl("push_constant;\nmaterials;\nsample_(0);\n", &["push_constant", "materials", "sample_"], Vec::new())]); @@ -453,7 +471,9 @@ pub mod tests { storage_backend.add_file("fragment.besl", shader_file.as_bytes()); - block_on(asset_handler.load(&asset_manager, storage_backend, ResourceId::new("material.bema"),)).expect("Failed to load material"); + let asset = block_on(asset_handler.load(&asset_manager, storage_backend, ResourceId::new("material.bema"),)).expect("Failed to load material"); + + let _ = block_on(asset.load(&asset_manager, storage_backend, ResourceId::new("material.bema"))); let generated_resources = storage_backend.get_resources(); diff --git a/resource_management/src/asset/mesh_asset_handler.rs b/resource_management/src/asset/mesh_asset_handler.rs index 97067f13..86d45f95 100644 --- a/resource_management/src/asset/mesh_asset_handler.rs +++ b/resource_management/src/asset/mesh_asset_handler.rs @@ -1,7 +1,7 @@ use futures::future::join_all; use gltf::{mesh::Reader, Buffer}; use maths_rs::{mat::{MatNew4, MatScale}, vec::Vec3}; -use utils::{r#async::{spawn_blocking_local, try_join_all}, spawn, Extent}; +use utils::{r#async::{spawn_blocking_local, try_join_all}, json::{self, JsonContainerTrait, JsonValueTrait}, spawn, Extent}; use crate::{ asset::{get_base, get_fragment, image_asset_handler::{guess_semantic_from_name, Semantic}}, material::VariantModel, mesh::{MeshModel, PrimitiveModel}, types::{Formats, Gamma, IndexStreamTypes, IntegralTypes, Stream, Streams, VertexComponent, VertexSemantics}, Description, ProcessedAsset, StorageBackend, StreamDescription}; @@ -9,7 +9,7 @@ use super::{asset_handler::{Asset, AssetHandler, LoadErrors}, asset_manager::Ass struct MeshAsset { id: String, - spec: Option, + spec: Option, gltf: gltf::Gltf, buffers: Vec, } @@ -17,10 +17,16 @@ struct MeshAsset { impl Asset for MeshAsset { fn requested_assets(&self) -> Vec { if let Some(spec) = &self.spec { - let asset_key = &spec["asset"]; + let asset_key = match spec["asset"].as_object() { + Some(asset_key) => asset_key, + None => return vec![], + }; - asset_key.entries().filter_map(|(_, v)| { // Get all material asset ids - v["asset"].as_str().map(|s| s.to_string()) + asset_key.iter().filter_map(|(_, v)| { // Get all material asset ids + match v["asset"].as_str() { + Some(s) => Some(s.to_string()), + None => None, + } }).collect() } else { vec![] diff --git a/resource_management/src/asset/mod.rs b/resource_management/src/asset/mod.rs index 7a8af8dd..a97f7cd8 100644 --- a/resource_management/src/asset/mod.rs +++ b/resource_management/src/asset/mod.rs @@ -3,7 +3,7 @@ use std::fmt::Debug; -use utils::{File, r#async::AsyncReadExt}; +use utils::{r#async::AsyncReadExt, json, File}; pub mod asset_manager; pub mod asset_handler; @@ -13,7 +13,7 @@ pub mod material_asset_handler; pub mod image_asset_handler; pub mod mesh_asset_handler; -pub type BEADType = json::JsonValue; +pub type BEADType = json::Value; /// Loads an asset from source.\ /// Expects an asset name in the form of a path relative to the assets directory, or a network address.\ @@ -54,7 +54,7 @@ pub fn read_asset_from_source<'a>(url: ResourceId<'a>, base_path: Option<&'a std return Err(()); } let spec = std::str::from_utf8(&spec_bytes).or(Err(()))?; - let spec = json::parse(spec).or(Err(()))?; + let spec: json::Value = json::from_str(spec).or(Err(()))?; Some(spec) } else { None diff --git a/resource_management/src/lib.rs b/resource_management/src/lib.rs index 43067fc8..44a848de 100644 --- a/resource_management/src/lib.rs +++ b/resource_management/src/lib.rs @@ -16,7 +16,7 @@ use serde::{ser::SerializeStruct, Serialize}; use resource::resource_handler::{FileResourceReader, LoadTargets, ReadTargets, ResourceReader}; use asset::{get_base, read_asset_from_source, BEADType, ResourceId}; -use utils::{r#async::{AsyncWriteExt, RwLock}, remove_file, File}; +use utils::{r#async::{AsyncWriteExt, RwLock}, json, remove_file, File}; pub mod asset; pub mod resource; @@ -781,7 +781,7 @@ impl StorageBackend for DbStorageBackend { let mut url = url.get_base().to_string(); url.push_str(".bead"); if let Some(spec) = files.get(url.as_str()) { - Some(json::parse(std::str::from_utf8(spec).unwrap()).unwrap()) + Some(json::from_str(std::str::from_utf8(spec).unwrap()).unwrap()) } else { None } @@ -799,7 +799,7 @@ impl StorageBackend for DbStorageBackend { let mut url = url.get_base().to_string(); url.push_str(".bead"); if let Some(spec) = self.files.lock().unwrap().get(url.as_str()) { - Some(json::parse(std::str::from_utf8(spec).unwrap()).unwrap()) + Some(json::from_str(std::str::from_utf8(spec).unwrap()).unwrap()) } else { None } diff --git a/src/input/input_manager.rs b/src/input/input_manager.rs index aa011fee..01f532ce 100644 --- a/src/input/input_manager.rs +++ b/src/input/input_manager.rs @@ -219,7 +219,7 @@ impl InputManager { /// # Example /// /// ``` - /// # use byte_engine::input_manager::InputManager; + /// # use byte_engine::input::InputManager; /// # let mut input_manager = InputManager::new(); /// input_manager.register_device_class("Keyboard"); /// ``` @@ -247,7 +247,7 @@ impl InputManager { /// # Example /// /// ```rust - /// # use byte_engine::input::{InputManager, InputTypes, InputSourceDescription}; + /// # use byte_engine::input::{InputManager, input_manager::{InputTypes, InputSourceDescription}}; /// # let mut input_manager = InputManager::new(); /// # let keyboard_device_class_handle = input_manager.register_device_class("Keyboard"); /// input_manager.register_input_source(&keyboard_device_class_handle, "Up", InputTypes::Bool(InputSourceDescription::new(false, false, false, true))); @@ -275,7 +275,7 @@ impl InputManager { /// /// # Example /// ```rust - /// # use byte_engine::input::{InputManager, InputTypes, InputSourceDescription}; + /// # use byte_engine::input::{InputManager, input_manager::{InputTypes, InputSourceDescription}}; /// # let mut input_manager = InputManager::new(); /// # let gamepad_device_class_handle = input_manager.register_device_class("Gamepad"); /// input_manager.register_input_destination(&gamepad_device_class_handle, "Rumble", InputTypes::Float(InputSourceDescription::new(0f32, 0f32, 0f32, 1f32))); diff --git a/src/rendering/common_shader_generator.rs b/src/rendering/common_shader_generator.rs index 0fba3ec7..6a35fe20 100644 --- a/src/rendering/common_shader_generator.rs +++ b/src/rendering/common_shader_generator.rs @@ -2,6 +2,7 @@ use std::{cell::RefCell, rc::Rc}; use maths_rs::vec; use resource_management::asset::material_asset_handler::ProgramGenerator; +use utils::json; use crate::besl::lexer; @@ -55,7 +56,7 @@ pub struct CommonShaderGenerator { } impl ProgramGenerator for CommonShaderGenerator { - fn transform(&self, mut root: besl::parser::Node, _: &json::JsonValue) -> besl::parser::Node { + fn transform(&self, mut root: besl::parser::Node, _: &json::Object) -> besl::parser::Node { let code = "vec4 colors[16] = vec4[16]( vec4(0.16863, 0.40392, 0.77647, 1), vec4(0.32941, 0.76863, 0.21961, 1), diff --git a/src/rendering/pipeline_manager.rs b/src/rendering/pipeline_manager.rs index 1ae740b8..ba43bb8a 100644 --- a/src/rendering/pipeline_manager.rs +++ b/src/rendering/pipeline_manager.rs @@ -1,10 +1,8 @@ use std::{hash::Hash, rc::Rc}; -use gxhash::{HashMap, HashMapExt}; - use ghi::GraphicsHardwareInterface; use resource_management::{material::{Material, Shader, Variant, VariantVariable}, types::ShaderTypes, Reference}; -use utils::{r#async::{join_all, try_join_all, OnceCell}, stale_map::{Entry, StaleHashMap}, sync::{RwLock, RwLockUpgradableReadGuard}}; +use utils::{r#async::{join_all, try_join_all, OnceCell}, hash::{HashMap, HashMapExt}, stale_map::{Entry, StaleHashMap}, sync::{RwLock, RwLockUpgradableReadGuard}}; pub struct PipelineManager { pipelines: RwLock>>, diff --git a/src/rendering/shadow_render_pass.rs b/src/rendering/shadow_render_pass.rs index 472c7fbd..6f804652 100644 --- a/src/rendering/shadow_render_pass.rs +++ b/src/rendering/shadow_render_pass.rs @@ -1,9 +1,8 @@ use std::{io::Write, mem::transmute}; -use json::object; use maths_rs::mat::{MatProjection, MatTranslate, MatRotate3D}; use resource_management::{asset::material_asset_handler::ProgramGenerator, shader_generation::{ShaderGenerationSettings, ShaderGenerator}}; -use utils::Extent; +use utils::{json, Extent}; use ghi::{GraphicsHardwareInterface, CommandBufferRecording, BoundRasterizationPipelineMode, RasterizationRenderPassMode}; @@ -68,7 +67,7 @@ impl ShadowRenderingPass { let root_node = besl::parser::Node::root(); - let mut root = shader_generator.transform(root_node, &object! {}); + let mut root = shader_generator.transform(root_node, &json::object!{}); let push_constant = besl::parser::Node::push_constant(vec![besl::parser::Node::member("instance_index", "u32")]); diff --git a/src/rendering/ssao_render_pass.rs b/src/rendering/ssao_render_pass.rs index 8af77bc5..70fd210c 100644 --- a/src/rendering/ssao_render_pass.rs +++ b/src/rendering/ssao_render_pass.rs @@ -3,7 +3,7 @@ use ghi::{BoundComputePipelineMode, CommandBufferRecording, DeviceAccesses, Grap use resource_management::{asset::{asset_manager::AssetManager, material_asset_handler::ProgramGenerator}, image::Image, resource::resource_manager::ResourceManager, shader_generation::{ShaderGenerationSettings, ShaderGenerator}, Reference}; use core::{Entity, EntityHandle}; -use utils::{Extent, RGBA}; +use utils::{json, Extent, RGBA}; use super::common_shader_generator::CommonShaderGenerator; @@ -273,9 +273,7 @@ pub fn get_source() -> String { let root_node = besl::parser::Node::root(); - use json::object; - - let mut root = shader_generator.transform(root_node, &object! {}); + let mut root = shader_generator.transform(root_node, &json::object!{}); root.add(vec![camera_binding, noise_texture_binding, depth, out_ao, biased_tangent, trace_settings_struct, compute_trace, compute_occlusion, main]); diff --git a/src/rendering/ssgi_render_pass.rs b/src/rendering/ssgi_render_pass.rs index 8142c377..69fe6298 100644 --- a/src/rendering/ssgi_render_pass.rs +++ b/src/rendering/ssgi_render_pass.rs @@ -5,9 +5,8 @@ use core::{entity::EntityBuilder, Entity}; use ghi::{GraphicsHardwareInterface, CommandBufferRecording, BoundComputePipelineMode}; -use json::object; use resource_management::{asset::material_asset_handler::ProgramGenerator, shader_generation::{ShaderGenerationSettings, ShaderGenerator}}; -use utils::Extent; +use utils::{json, Extent}; use super::common_shader_generator::CommonShaderGenerator; @@ -69,7 +68,7 @@ impl SSGIRenderPass { let main = Node::function("main", Vec::new(), "void", vec![Node::glsl(CODE, &["make_normal_from_depth", "camera", "interleaved_gradient_noise", "get_cosine_hemisphere_sample"], vec![])]); - let mut root = shader_generator.transform(Node::root(), &object!{}); + let mut root = shader_generator.transform(Node::root(), &json::object!{}); root.add(vec![main]); @@ -113,7 +112,7 @@ impl SSGIRenderPass { let main = Node::function("main", Vec::new(), "void", vec![Node::glsl(CODE, &["make_uv", "camera", "get_world_space_position_from_depth", "get_view_space_position_from_depth", "ray_march"], vec![])]); - let mut root = shader_generator.transform(Node::root(), &object!{}); + let mut root = shader_generator.transform(Node::root(), &json::object!{}); root.add(vec![main]); diff --git a/src/rendering/texture_manager.rs b/src/rendering/texture_manager.rs index 223f8e7a..8ad123da 100644 --- a/src/rendering/texture_manager.rs +++ b/src/rendering/texture_manager.rs @@ -2,10 +2,8 @@ use std::{collections::hash_map::Entry, num::NonZeroU8, rc::Rc}; -use gxhash::{HashMap, HashMapExt}; - use resource_management::{image::Image, Reference}; -use utils::{sync::RwLock, Extent}; +use utils::{hash::{HashMap, HashMapExt}, sync::RwLock, Extent}; use ghi::GraphicsHardwareInterface; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] diff --git a/src/rendering/visibility_model/render_domain.rs b/src/rendering/visibility_model/render_domain.rs index da94b497..c17de96d 100644 --- a/src/rendering/visibility_model/render_domain.rs +++ b/src/rendering/visibility_model/render_domain.rs @@ -4,8 +4,8 @@ use std::sync::Arc; use ghi::{graphics_hardware_interface, ImageHandle}; use ghi::{GraphicsHardwareInterface, CommandBufferRecording, BoundComputePipelineMode, RasterizationRenderPassMode, BoundRasterizationPipelineMode}; -use gxhash::{HashMap, HashMapExt}; -use json::object; +use utils::hash::{HashMap, HashMapExt}; +use utils::json::object; use log::error; use maths_rs::mat::{MatInverse, MatProjection, MatRotate3D}; use maths_rs::{prelude::MatTranslate, Mat4f}; diff --git a/src/rendering/visibility_shader_generator.rs b/src/rendering/visibility_shader_generator.rs index 7acb18d9..7c60c8f0 100644 --- a/src/rendering/visibility_shader_generator.rs +++ b/src/rendering/visibility_shader_generator.rs @@ -3,6 +3,7 @@ use std::{cell::RefCell, ops::Deref, rc::Rc}; use besl::{Node, NodeReference}; use maths_rs::vec; use resource_management::asset::material_asset_handler::ProgramGenerator; +use utils::json::{self, JsonContainerTrait, JsonValueTrait}; use super::common_shader_generator::CommonShaderGenerator; @@ -63,7 +64,7 @@ impl VisibilityShaderGenerator { } impl ProgramGenerator for VisibilityShaderGenerator { - fn transform(&self, mut root: besl::parser::Node, material: &json::JsonValue) -> besl::parser::Node { + fn transform(&self, mut root: besl::parser::Node, material: &json::Object) -> besl::parser::Node { let set2_binding0 = self.out_albedo.clone(); let set2_binding1 = self.camera.clone(); let set2_binding4 = self.lighting_data.clone(); @@ -164,7 +165,7 @@ float roughness = float(0.5);"; let mut texture_count = 0; - for variable in material["variables"].members() { + for variable in material["variables"].as_array().unwrap().iter() { let name = variable["name"].as_str().unwrap(); let data_type = variable["data_type"].as_str().unwrap(); diff --git a/src/window_system.rs b/src/window_system.rs index 26a3939f..4d674485 100644 --- a/src/window_system.rs +++ b/src/window_system.rs @@ -1,13 +1,13 @@ //! The window system module implements logic to handle creation and management of OS windows. use component_derive::component; -use utils::Extent; +use utils::{hash::HashMap, Extent}; use crate::core::{entity::EntityBuilder, listener::{EntitySubscriber, Listener}, orchestrator, Entity, EntityHandle}; /// The window system. pub struct WindowSystem { - windows: gxhash::HashMap, ghi::Window>, + windows: HashMap, ghi::Window>, } impl Entity for WindowSystem {} @@ -47,7 +47,7 @@ impl WindowSystem { } } - WindowSystem { windows: gxhash::HashMap::default() } + WindowSystem { windows: HashMap::default() } } pub fn new_as_system<'a>() -> EntityBuilder<'a, WindowSystem> { diff --git a/utils/Cargo.toml b/utils/Cargo.toml index 6d1ca670..5f6368b4 100644 --- a/utils/Cargo.toml +++ b/utils/Cargo.toml @@ -9,4 +9,5 @@ rust-version = "1.73.0" futures = "0.3.30" tokio = { version = "1.38.0", features = ["rt", "rt-multi-thread", "fs", "io-util", "sync"] } parking_lot = "0.12" -gxhash = "3.4.1" \ No newline at end of file +gxhash = "3.4.1" +sonic-rs = "0.3.8" diff --git a/utils/src/async.rs b/utils/src/async.rs index 564f10ac..9645e3b3 100644 --- a/utils/src/async.rs +++ b/utils/src/async.rs @@ -28,7 +28,8 @@ pub use tokio::sync::OnceCell; pub use tokio::runtime::Runtime; pub fn block_on(future: F) -> F::Output where F: Future { - tokio::runtime::Handle::current().block_on(future) + let runtime = create_runtime(); + runtime.block_on(future) } pub fn create_runtime() -> tokio::runtime::Runtime { diff --git a/utils/src/lib.rs b/utils/src/lib.rs index 28a4169c..14ff55c0 100644 --- a/utils/src/lib.rs +++ b/utils/src/lib.rs @@ -12,6 +12,9 @@ pub use r#async::spawn_blocking; pub use r#async::remove_file; pub use r#async::File; +pub use sonic_rs as json; + +pub use gxhash as hash; pub struct BufferAllocator<'a> { buffer: &'a mut [u8], offset: usize,