Skip to main content

easy_gpu/assets/compute/
bind_group.rs

1use wgpu::Device;
2use crate::assets::compute::pipeline::ComputePipeline;
3use crate::assets::{Texture};
4use crate::assets::buffer::Buffer;
5use crate::assets_manager::asset_manager::AssetManager;
6use crate::assets_manager::Handle;
7
8pub struct ComputeBindGroup{
9    pub bind_group: wgpu::BindGroup
10}
11
12pub struct ComputeBindGroupBuilder{
13    textures: Vec<(u32, Handle<Texture>)>,
14    storages: Vec<(u32,Handle<Buffer>)>,
15    pipeline: Handle<ComputePipeline>,
16}
17
18impl ComputeBindGroupBuilder{
19    pub fn new(pipeline: Handle<ComputePipeline>) -> Self{
20        Self{
21            textures: vec![],
22            storages: vec![],
23            pipeline,
24        }
25    }
26
27    pub fn storage_texture(
28        mut self,
29        texture_binding: u32,
30        texture: Handle<Texture>,
31    ) -> Self {
32        self.textures.push((texture_binding, texture));
33        self
34    }
35    pub fn storage(
36        mut self,
37        binding: u32,
38        buffer: Handle<Buffer>,
39    ) -> Self {
40        self.storages.push((binding, buffer));
41        self
42    }
43
44    pub fn build(self,device:&Device, asset_manager: &AssetManager) -> ComputeBindGroup {
45        let pipeline = asset_manager.compute_pipelines.get(self.pipeline.clone()).unwrap();
46
47        let mut entries = Vec::new();
48
49        for (binding,handle) in self.storages {
50            let storage = asset_manager.buffers.get(handle).unwrap();
51
52            entries.push(wgpu::BindGroupEntry {
53                binding,
54                resource: storage.buffer.as_entire_binding(),
55            });
56        }
57
58        for (tex_binding,handle) in self.textures {
59            let texture = asset_manager.textures.get(handle).unwrap();
60
61            entries.push(wgpu::BindGroupEntry {
62                binding: tex_binding,
63                resource: wgpu::BindingResource::TextureView(&texture.view),
64            });
65        }
66
67        let bind_group = device.create_bind_group(
68            &wgpu::BindGroupDescriptor {
69                label: Some("material bind group"),
70                layout: &pipeline.layout,
71                entries: &entries,
72            }
73        );
74
75        ComputeBindGroup{
76            bind_group,
77        }
78    }
79}