refactor render pipeline creation

Author: arthomnix

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fractal_viewer"
-version = "2.1.1"
+version = "2.1.2"
 edition = "2021"
 description = "Cross-platform GPU-accelerated viewer for the Mandelbrot set and related fractals"
 repository = "https://github.com/arthomnix/fractal_viewer"

src/lib.rs

@@ -3,9 +3,9 @@ mod uniforms;
 #[cfg(target_arch = "wasm32")]
 mod web;
 
-use egui_wgpu::wgpu as wgpu;
+use egui_wgpu::wgpu;
 #[cfg(not(target_arch = "wasm32"))]
-use egui_wgpu::wgpu::naga as naga;
+use egui_wgpu::wgpu::naga;
 
 use crate::settings::{CustomShaderData, UserSettings};
 use crate::uniforms::{calculate_scale, Uniforms};
@@ -120,50 +120,23 @@ impl FractalViewerApp {
             }],
         });
 
-        let shader = device.create_shader_module(ShaderModuleDescriptor {
-            label: Some("fv_shader"),
-            source: ShaderSource::Wgsl(settings.shader_data.shader().into()),
-        });
-
-        let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
-            label: Some("fv_pipeline_layout"),
-            bind_group_layouts: &[&uniform_bind_group_layout],
-            push_constant_ranges: &[],
-        });
+        let renderer_state = RendererState {
+            device: Arc::clone(device),
+            target_format: wgpu_render_state.target_format.into(),
+            bind_group_layout: uniform_bind_group_layout,
+            bind_group: uniform_bind_group,
+            uniform_buffer,
+        };
 
-        let pipeline = device.create_render_pipeline(&RenderPipelineDescriptor {
-            label: Some("fv_pipeline"),
-            layout: Some(&pipeline_layout),
-            vertex: VertexState {
-                module: &shader,
-                entry_point: "vs_main",
-                compilation_options: Default::default(),
-                buffers: &[],
-            },
-            fragment: Some(FragmentState {
-                module: &shader,
-                entry_point: "fs_main",
-                compilation_options: Default::default(),
-                targets: &[Some(wgpu_render_state.target_format.into())],
-            }),
-            primitive: PrimitiveState::default(),
-            depth_stencil: None,
-            multisample: MultisampleState::default(),
-            multiview: None,
-            cache: None,
-        });
+        let pipeline = renderer_state.generate_pipeline(&settings.shader_data);
 
         wgpu_render_state
             .renderer
             .write()
             .callback_resources
             .insert(FvRenderer {
-                device: Arc::clone(device),
                 pipeline,
-                target_format: wgpu_render_state.target_format.into(),
-                bind_group: uniform_bind_group,
-                bind_group_layout: uniform_bind_group_layout,
-                uniform_buffer,
+                state: renderer_state,
             });
 
         let adapter_info = wgpu_render_state.adapter.get_info();
@@ -488,68 +461,75 @@ impl eframe::App for FractalViewerApp {
     }
 }
 
-struct FvRenderer {
+struct RendererState {
     device: Arc<Device>,
-    pipeline: RenderPipeline,
     target_format: ColorTargetState,
     bind_group_layout: BindGroupLayout,
     bind_group: BindGroup,
     uniform_buffer: Buffer,
 }
 
-impl FvRenderer {
-    fn prepare(&mut self, queue: &Queue, callback: &FvRenderCallback) {
-        if let Some(data) = &callback.shader_recompilation_options {
-            let shader = self.device.create_shader_module(ShaderModuleDescriptor {
-                label: Some("fv_shader"),
-                source: ShaderSource::Wgsl(data.shader().into()),
+impl RendererState {
+    fn generate_pipeline(&self, shader_data: &CustomShaderData) -> RenderPipeline {
+        let shader = self.device.create_shader_module(ShaderModuleDescriptor {
+            label: Some("fv_shader"),
+            source: ShaderSource::Wgsl(shader_data.shader().into()),
+        });
+
+        let pipeline_layout = self
+            .device
+            .create_pipeline_layout(&PipelineLayoutDescriptor {
+                label: Some("fv_pipeline_layout"),
+                bind_group_layouts: &[&self.bind_group_layout],
+                push_constant_ranges: &[],
             });
 
-            let pipeline_layout = self
-                .device
-                .create_pipeline_layout(&PipelineLayoutDescriptor {
-                    label: Some("fv_pipeline_layout"),
-                    bind_group_layouts: &[&self.bind_group_layout],
-                    push_constant_ranges: &[],
-                });
+        self.device
+            .create_render_pipeline(&RenderPipelineDescriptor {
+                label: Some("fv_pipeline"),
+                layout: Some(&pipeline_layout),
+                vertex: VertexState {
+                    module: &shader,
+                    entry_point: "vs_main",
+                    compilation_options: Default::default(),
+                    buffers: &[],
+                },
+                fragment: Some(FragmentState {
+                    module: &shader,
+                    entry_point: "fs_main",
+                    compilation_options: Default::default(),
+                    targets: &[Some(self.target_format.clone())],
+                }),
+                primitive: PrimitiveState::default(),
+                depth_stencil: None,
+                multisample: MultisampleState::default(),
+                multiview: None,
+                cache: None,
+            })
+    }
+}
 
-            let pipeline = self
-                .device
-                .create_render_pipeline(&RenderPipelineDescriptor {
-                    label: Some("fv_pipeline"),
-                    layout: Some(&pipeline_layout),
-                    vertex: VertexState {
-                        module: &shader,
-                        entry_point: "vs_main",
-                        compilation_options: Default::default(),
-                        buffers: &[],
-                    },
-                    fragment: Some(FragmentState {
-                        module: &shader,
-                        entry_point: "fs_main",
-                        compilation_options: Default::default(),
-                        targets: &[Some(self.target_format.clone())],
-                    }),
-                    primitive: PrimitiveState::default(),
-                    depth_stencil: None,
-                    multisample: MultisampleState::default(),
-                    multiview: None,
-                    cache: None,
-                });
+struct FvRenderer {
+    pipeline: RenderPipeline,
+    state: RendererState,
+}
 
-            self.pipeline = pipeline;
+impl FvRenderer {
+    fn prepare(&mut self, queue: &Queue, callback: &FvRenderCallback) {
+        if let Some(data) = &callback.shader_recompilation_options {
+            self.pipeline = self.state.generate_pipeline(data);
         }
 
         queue.write_buffer(
-            &self.uniform_buffer,
+            &self.state.uniform_buffer,
             0,
             bytemuck::cast_slice(&[callback.uniforms]),
         );
     }
 
     fn paint(&self, render_pass: &mut RenderPass<'static>) {
         render_pass.set_pipeline(&self.pipeline);
-        render_pass.set_bind_group(0, &self.bind_group, &[]);
+        render_pass.set_bind_group(0, &self.state.bind_group, &[]);
         render_pass.draw(0..6, 0..1);
     }
 }

src/settings/compat.rs

@@ -161,12 +161,11 @@ pub(crate) mod v0_5 {
     }
 }
 
-
 pub(crate) mod v2_0 {
     use crate::settings::{CustomShaderData, InvalidSettingsImportError};
 
-    use base64::Engine;
     use base64::engine::general_purpose;
+    use base64::Engine;
 
     #[derive(Clone, serde::Serialize, serde::Deserialize)]
     pub(crate) struct UserSettings {
@@ -215,4 +214,4 @@ pub(crate) mod v2_0 {
             }
         }
     }
-}
+}

src/settings/mod.rs

@@ -1,8 +1,8 @@
 mod compat;
 
+use crate::SHADER;
 use base64::{engine::general_purpose, Engine};
 use std::fmt::{Display, Formatter};
-use crate::SHADER;
 
 #[derive(Debug, serde::Deserialize)]
 pub enum InvalidSettingsImportError {
@@ -127,7 +127,8 @@ impl Default for CustomShaderData {
     fn default() -> Self {
         Self {
             equation: "csquare(z) + c".to_string(),
-            colour: "hsv_rgb(vec3(log(n + 1.0) / log(f32(uniforms.iterations) + 1.0), 0.8, 0.8))".to_string(),
+            colour: "hsv_rgb(vec3(log(n + 1.0) / log(f32(uniforms.iterations) + 1.0), 0.8, 0.8))"
+                .to_string(),
             additional: String::new(),
         }
     }