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

use crate::front::storage::ShaderObject;
use wgpu;

/// A wgpu shader module created from your Naga IR
pub struct WGPUShader {
    pub module: wgpu::ShaderModule,
    pub stage: naga::ShaderStage,
    pub entry_point: String,
}

impl WGPUShader {
    /// Create a wgpu ShaderModule from your ShaderObject
    pub fn from_shader_object(device: &wgpu::Device, shader_obj: &ShaderObject) -> Self {
        // Validate the Naga module first
        let info = naga::valid::Validator::new(
            naga::valid::ValidationFlags::all(),
            naga::valid::Capabilities::all(),
        )
        .validate(&shader_obj.ir.module)
        .expect("Shader validation failed");

        // Convert Naga IR to WGSL string for wgpu
        let wgsl_string = naga::back::wgsl::write_string(
            &shader_obj.ir.module,
            &info,
            naga::back::wgsl::WriterFlags::empty(),
        )
        .expect("Failed to convert Naga to WGSL");

        // Create shader module from WGSL
        let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("shdrlib shader"),
            source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Owned(wgsl_string)),
        });

        WGPUShader {
            module,
            stage: shader_obj.ir.metadata.stage,
            entry_point: shader_obj.ir.metadata.entry_point.clone(),
        }
    }

    /// Create from raw Naga module and metadata
    pub fn from_ir(
        device: &wgpu::Device,
        module: &naga::Module,
        stage: naga::ShaderStage,
        entry_point: String,
    ) -> Self {
        // Validate the Naga module
        let info = naga::valid::Validator::new(
            naga::valid::ValidationFlags::all(),
            naga::valid::Capabilities::all(),
        )
        .validate(module)
        .expect("Shader validation failed");

        // Convert to WGSL
        let wgsl_string = naga::back::wgsl::write_string(
            module,
            &info,
            naga::back::wgsl::WriterFlags::empty(),
        )
        .expect("Failed to convert Naga to WGSL");

        let shader_module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("shdrlib shader"),
            source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Owned(wgsl_string)),
        });

        WGPUShader {
            module: shader_module,
            stage,
            entry_point,
        }
    }
}