wgsl_to_wgpu 0.15.2

Generate typesafe Rust bindings from WGSL shaders to wgpu
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

---
source: wgsl_to_wgpu/src/structs.rs
---
pub mod compute {
    pub const MAIN_WORKGROUP_SIZE: [u32; 3] = [64, 1, 1];
    pub fn create_main_pipeline(device: &wgpu::Device) -> wgpu::ComputePipeline {
        let module = super::create_shader_module(device);
        let layout = super::create_pipeline_layout(device);
        device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
            label: Some("Compute Pipeline main"),
            layout: Some(&layout),
            module: &module,
            entry_point: Some("main"),
            compilation_options: Default::default(),
            cache: Default::default(),
        })
    }
}
pub const ENTRY_MAIN: &str = "main";
pub const SOURCE: &str = include_str!("serde_encase_bytemuck.wgsl");
pub fn create_shader_module(device: &wgpu::Device) -> wgpu::ShaderModule {
    let source = std::borrow::Cow::Borrowed(SOURCE);
    device.create_shader_module(wgpu::ShaderModuleDescriptor {
        label: None,
        source: wgpu::ShaderSource::Wgsl(source),
    })
}
pub fn create_pipeline_layout(device: &wgpu::Device) -> wgpu::PipelineLayout {
    device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
        label: None,
        bind_group_layouts: &[],
        push_constant_ranges: &[],
    })
}
#[repr(C)]
#[derive(
    Debug,
    Copy,
    Clone,
    PartialEq,
    bytemuck :: Pod,
    bytemuck :: Zeroable,
    encase :: ShaderType,
    serde :: Serialize,
    serde :: Deserialize,
)]
pub struct Input0 {
    pub a: u32,
    pub b: i32,
    pub c: f32,
}
const _: () = assert!(
    std::mem::size_of::<Input0>() == 12,
    "size of Input0 does not match WGSL"
);
const _: () = assert!(
    std::mem::offset_of!(Input0, a) == 0,
    "offset of Input0.a does not match WGSL"
);
const _: () = assert!(
    std::mem::offset_of!(Input0, b) == 4,
    "offset of Input0.b does not match WGSL"
);
const _: () = assert!(
    std::mem::offset_of!(Input0, c) == 8,
    "offset of Input0.c does not match WGSL"
);
#[repr(C)]
#[derive(
    Debug,
    Copy,
    Clone,
    PartialEq,
    bytemuck :: Pod,
    bytemuck :: Zeroable,
    encase :: ShaderType,
    serde :: Serialize,
    serde :: Deserialize,
)]
pub struct Nested {
    pub a: Input0,
    pub b: f32,
}
const _: () = assert!(
    std::mem::size_of::<Nested>() == 16,
    "size of Nested does not match WGSL"
);
const _: () = assert!(
    std::mem::offset_of!(Nested, a) == 0,
    "offset of Nested.a does not match WGSL"
);
const _: () = assert!(
    std::mem::offset_of!(Nested, b) == 12,
    "offset of Nested.b does not match WGSL"
);