wgpu-noboiler 0.2.0

Builder patter for wgpu and winit
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use std::borrow::Cow;
use std::fs;

use wgpu::{
    BindGroupLayout, BlendState, ColorTargetState, ColorWrites, DepthStencilState, Device, Face,
    FragmentState, FrontFace, MultisampleState, PipelineLayoutDescriptor, PolygonMode,
    PrimitiveState, PrimitiveTopology, RenderPipeline, RenderPipelineDescriptor, ShaderModule,
    ShaderModuleDescriptor, ShaderSource, SurfaceConfiguration, TextureFormat, VertexBufferLayout,
    VertexState,
};

/// Builder Patter for wgpu [RenderPipeline]
pub struct RenderPipelineCreator<'a> {
    device: &'a Device,
    format: &'a TextureFormat,

    shader: ShaderModule,
    vertex_main: &'a str,
    fragment_main: &'a str,

    vertex_buffers: Vec<VertexBufferLayout<'a>>,
    bind_groups: Vec<&'a BindGroupLayout>,

    depth_stencil: Option<DepthStencilState>,

    label: &'a str,

    blend_state: BlendState,
}

impl<'a> RenderPipelineCreator<'a> {
    /// creates an [RenderPipelineCreator] where the shader is from the path
    pub fn from_shader_file(
        path: &'a str,
        device: &'a Device,
        config: &'a SurfaceConfiguration,
    ) -> RenderPipelineCreator<'a> {
        Self::from_shader_code(
            &fs::read_to_string(path)
                .unwrap_or_else(|_| panic!("Could not find Shader-File at {}", path)),
            device,
            config,
        )
    }

    /// creates an [RenderPipelineCreator] where the shader is based on the given code
    pub fn from_shader_code(
        shader_code: &str,
        device: &'a Device,
        config: &'a SurfaceConfiguration,
    ) -> RenderPipelineCreator<'a> {
        let shader = device.create_shader_module(ShaderModuleDescriptor {
            label: Some("Render Pipeline Shader"),
            source: ShaderSource::Wgsl(Cow::from(shader_code)),
        });

        RenderPipelineCreator {
            device,
            format: &config.format,
            shader,
            vertex_main: "vs_main",
            fragment_main: "fs_main",

            vertex_buffers: vec![],
            bind_groups: vec![],

            depth_stencil: None,

            label: "Render Pipeline",
            blend_state: BlendState::REPLACE,
        }
    }

    /// adds a [VertexBufferLayout] to the used list
    pub fn add_vertex_buffer(mut self, layout: VertexBufferLayout<'a>) -> Self {
        self.vertex_buffers.push(layout);

        self
    }

    /// adds a [BindGroupLayout] to the used list
    pub fn add_bind_group(mut self, layout: &'a BindGroupLayout) -> Self {
        self.bind_groups.push(layout);

        self
    }

    /// sets the name of the Fragment-Main
    pub fn fragment_main(mut self, fn_name: &'a str) -> Self {
        self.fragment_main = fn_name;
        self
    }

    /// sets the name of the Vertex-Main
    pub fn vertex_main(mut self, fn_name: &'a str) -> Self {
        self.vertex_main = fn_name;
        self
    }

    /// sets the used [DepthStencilState]
    pub fn depth_stencil(mut self, depth_stencil: DepthStencilState) -> Self {
        self.depth_stencil = Some(depth_stencil);
        self
    }

    /// sets the used [BlendState]
    pub fn blend_state(mut self, blend_state: BlendState) -> Self {
        self.blend_state = blend_state;
        self
    }

    /// creates a [RenderPipeline]
    pub fn build(&self) -> RenderPipeline {
        let render_pipeline_layout =
            self.device
                .create_pipeline_layout(&PipelineLayoutDescriptor {
                    label: Some(&(self.label.to_owned() + " Layout")),
                    bind_group_layouts: &self.bind_groups[..],
                    push_constant_ranges: &[],
                });

        self.device
            .create_render_pipeline(&RenderPipelineDescriptor {
                label: Some(self.label),
                layout: Some(&render_pipeline_layout),
                vertex: VertexState {
                    module: &self.shader,
                    entry_point: self.vertex_main,
                    buffers: &self.vertex_buffers[..],
                },
                fragment: Some(FragmentState {
                    module: &self.shader,
                    entry_point: self.fragment_main,
                    targets: &[Some(ColorTargetState {
                        format: self.format.to_owned(),
                        blend: Some(self.blend_state),
                        write_mask: ColorWrites::ALL,
                    })],
                }),
                primitive: PrimitiveState {
                    topology: PrimitiveTopology::TriangleList,
                    strip_index_format: None,
                    front_face: FrontFace::Ccw,
                    cull_mode: Some(Face::Back),
                    polygon_mode: PolygonMode::Fill,
                    unclipped_depth: false,
                    conservative: false,
                },
                depth_stencil: self.depth_stencil.to_owned(),
                multisample: MultisampleState {
                    count: 1,
                    mask: !0,
                    alpha_to_coverage_enabled: false,
                },
                multiview: None,
            })
    }
}