ursus_core/assets/storage/
mod.rs

1pub mod material;
2pub mod mesh;
3pub mod shader;
4pub mod texture;
5
6pub use material::MaterialStore;
7pub use mesh::MeshStore;
8pub use shader::{ShaderDef, ShaderHandle, ShaderRegistry, ShaderSource};
9pub use texture::GpuTextureStore;
10
11use crate::render::gfx::descriptor::DescriptorAllocator;
12use crate::render::gfx::sampler::SamplerStore;
13use crate::render::gfx::types::{BufferUsage, DescriptorSetId, PipelineId, SamplerId};
14use crate::render::gfx::PipelineCache;
15use crate::render::gfx::TechniqueRegistry;
16use crate::vulkan::gfx_pipeline::pipeline::PipelineDesc;
17use crate::vulkan::MappedGpuBuffer;
18use ash::vk;
19
20pub struct GpuAssetServer {
21    pub meshes: MeshStore,
22    pub textures: GpuTextureStore,
23    pub materials: MaterialStore,
24
25    pub shaders: ShaderRegistry,
26    pub techniques: TechniqueRegistry,
27
28    pub descriptors: DescriptorAllocator,
29    pub samplers: SamplerStore,
30    pipeline_cache: PipelineCache,
31
32    device: ash::Device,
33    physical_device: vk::PhysicalDevice,
34    instance: ash::Instance,
35    command_pool: vk::CommandPool,
36}
37
38impl GpuAssetServer {
39    pub fn new(
40        device: ash::Device,
41        physical_device: vk::PhysicalDevice,
42        instance: ash::Instance,
43        command_pool: vk::CommandPool,
44        queue: vk::Queue,
45    ) -> anyhow::Result<Self> {
46        let shaders = ShaderRegistry::empty();
47        let techniques = TechniqueRegistry::default();
48        let pipeline_cache = PipelineCache::new(device.clone());
49        let mut descriptors = DescriptorAllocator::new(device.clone());
50        let meshes = MeshStore::new(device.clone(), physical_device, instance.clone(), command_pool, queue);
51        let samplers = SamplerStore::new(device.clone());
52        let materials = MaterialStore::new(device.clone(), physical_device, instance.clone(), &mut descriptors)?;
53
54        let textures = GpuTextureStore::new(
55            device.clone(),
56            physical_device,
57            instance.clone(),
58            command_pool,
59            &mut descriptors,
60            queue,
61        )?;
62
63        Ok(Self {
64            meshes,
65            textures,
66            materials,
67            shaders,
68            techniques,
69            pipeline_cache,
70            device,
71            physical_device,
72            instance,
73            command_pool,
74            descriptors,
75            samplers,
76        })
77    }
78
79    pub fn bindless_set(&self) -> DescriptorSetId {
80        self.textures.bindless().set_id
81    }
82
83    pub fn bind_uniform_buffer(&self, set: DescriptorSetId, binding: u32, buffer: vk::Buffer, size: vk::DeviceSize) {
84        self.descriptors.bind_uniform_buffer(set, binding, buffer, size).expect("bind_uniform_buffer failed");
85    }
86
87    pub fn bind_mapped_uniform_buffer<T: Copy>(&self, set: DescriptorSetId, binding: u32, mapped: &MappedGpuBuffer<T>) {
88        self.bind_uniform_buffer(set, binding, mapped.buffer, mapped.size());
89    }
90
91    pub fn bind_storage_buffer(&self, set: DescriptorSetId, binding: u32, buffer: vk::Buffer, size: vk::DeviceSize) {
92        self.descriptors.bind_storage_buffer(set, binding, buffer, size).expect("bind_storage_buffer failed");
93    }
94
95    pub fn bind_mapped_storage_buffer<T: Copy>(&self, set: DescriptorSetId, binding: u32, mapped: &MappedGpuBuffer<T>) {
96        self.bind_storage_buffer(set, binding, mapped.buffer, mapped.size());
97    }
98
99    pub fn bind_sampled_image(
100        &self,
101        set: DescriptorSetId,
102        binding: u32,
103        view: vk::ImageView,
104        layout: vk::ImageLayout,
105        sampler: SamplerId,
106    ) {
107        let vk_sampler = self.samplers.handle(sampler);
108        self.descriptors.bind_sampled_image(set, binding, view, layout, vk_sampler).expect("bind_sampled_image failed");
109    }
110
111    pub fn create_graphics_pipeline(
112        &mut self,
113        desc: &PipelineDesc,
114        set_layouts: &[DescriptorSetId],
115    ) -> anyhow::Result<PipelineId> {
116        let layouts: Vec<vk::DescriptorSetLayout> = set_layouts.iter().map(|&id| self.descriptors.layout(id)).collect();
117        self.pipeline_cache.create_graphics_pipeline(&self.device, desc, &layouts)
118    }
119
120    pub fn create_mapped_buffer<T: Copy>(
121        &self,
122        usage: BufferUsage,
123        capacity: usize,
124    ) -> anyhow::Result<MappedGpuBuffer<T>> {
125        MappedGpuBuffer::new(&self.device, self.physical_device, &self.instance, usage.to_vk(), capacity)
126    }
127
128    pub fn pipeline_cache(&self) -> &PipelineCache {
129        &self.pipeline_cache
130    }
131
132    pub fn device(&self) -> &ash::Device {
133        &self.device
134    }
135
136    pub fn command_pool(&self) -> vk::CommandPool {
137        self.command_pool
138    }
139}
ursus_core/assets/storage/mod.rs

ursus_core/assets/storage/
mod.rs
