shdrlib 0.2.0

High-level shader compilation and rendering library built on wgpu and naga
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

use crate::managers::asset_manager::AssetManager;
use wgpu;

/// RuntimeManager handles executing render passes with your pipelines
/// Holds references to pipelines by name and executes them
pub struct RuntimeManager<'a> {
    asset_manager: &'a AssetManager,
    surface: Option<wgpu::Surface<'a>>,
    surface_config: Option<wgpu::SurfaceConfiguration>,
}

impl<'a> RuntimeManager<'a> {
    /// Create a new runtime manager that references an AssetManager
    pub fn new(asset_manager: &'a AssetManager) -> Self {
        Self {
            asset_manager,
            surface: None,
            surface_config: None,
        }
    }

    /// Configure a surface for rendering (optional - for window rendering)
    pub fn with_surface(
        mut self,
        surface: wgpu::Surface<'a>,
        width: u32,
        height: u32,
        format: wgpu::TextureFormat,
    ) -> Self {
        let config = wgpu::SurfaceConfiguration {
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
            format,
            width,
            height,
            present_mode: wgpu::PresentMode::Fifo,
            alpha_mode: wgpu::CompositeAlphaMode::Auto,
            view_formats: vec![],
            desired_maximum_frame_latency: 2,
        };

        surface.configure(self.asset_manager.device(), &config);
        self.surface = Some(surface);
        self.surface_config = Some(config);
        self
    }

    /// Execute a render pass with a specific pipeline
    /// Returns the command buffer for submission
    pub fn render_pass(
        &self,
        pipeline_name: &str,
        target_view: &wgpu::TextureView,
        clear_color: wgpu::Color,
        vertex_count: u32,
    ) -> Result<wgpu::CommandBuffer, String> {
        // Get the pipeline
        let duo = self.asset_manager.get_pipeline(pipeline_name)
            .ok_or_else(|| format!("Pipeline '{}' not found", pipeline_name))?;

        // Create command encoder
        let mut encoder = self.asset_manager.device().create_command_encoder(
            &wgpu::CommandEncoderDescriptor {
                label: Some("Render Encoder"),
            }
        );

        // Begin render pass
        {
            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("Render Pass"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: target_view,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Clear(clear_color),
                        store: wgpu::StoreOp::Store,
                    },
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
            });

            // Set the pipeline and draw
            render_pass.set_pipeline(&duo.pipeline);
            render_pass.draw(0..vertex_count, 0..1);
        }

        Ok(encoder.finish())
    }

    /// Convenience method: render to surface (if configured)
    pub fn render_to_surface(
        &self,
        pipeline_name: &str,
        clear_color: wgpu::Color,
        vertex_count: u32,
    ) -> Result<(), String> {
        let surface = self.surface.as_ref()
            .ok_or("Surface not configured")?;

        // Get surface texture
        let output = surface.get_current_texture()
            .map_err(|e| format!("Failed to get surface texture: {:?}", e))?;

        let view = output.texture.create_view(&wgpu::TextureViewDescriptor::default());

        // Render
        let command_buffer = self.render_pass(pipeline_name, &view, clear_color, vertex_count)?;

        // Submit and present
        self.asset_manager.queue().submit(Some(command_buffer));
        output.present();

        Ok(())
    }

    /// Render to a texture and return it (for offscreen rendering)
    pub fn render_to_texture(
        &self,
        pipeline_name: &str,
        width: u32,
        height: u32,
        format: wgpu::TextureFormat,
        clear_color: wgpu::Color,
        vertex_count: u32,
    ) -> Result<wgpu::Texture, String> {
        // Create texture
        let texture = self.asset_manager.device().create_texture(&wgpu::TextureDescriptor {
            label: Some("Render Target"),
            size: wgpu::Extent3d {
                width,
                height,
                depth_or_array_layers: 1,
            },
            mip_level_count: 1,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format,
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
            view_formats: &[],
        });

        let view = texture.create_view(&wgpu::TextureViewDescriptor::default());

        // Render to it
        let command_buffer = self.render_pass(pipeline_name, &view, clear_color, vertex_count)?;
        self.asset_manager.queue().submit(Some(command_buffer));

        Ok(texture)
    }
}