vello_sparse_shaders 0.0.8

Provide compilation of wgsl to glsl to support the WebGL `vello_hybrid` backend.
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

// Copyright 2025 the Vello Authors
// SPDX-License-Identifier: Apache-2.0 OR MIT

use naga::{
    ShaderStage,
    back::glsl::{self, PipelineOptions, Version},
    front::wgsl,
    valid::{Capabilities, ValidationFlags, Validator},
};

use crate::types::{CompiledGlsl, ReflectionMap, Stage};

#[allow(
    dead_code,
    reason = "False positive as compile_wgsl_shader is used at build time."
)]
/// Compiles the given wgsl source into GLSL using [naga].
pub(crate) fn compile_wgsl_shader(
    source: &str,
    vertex_entry: &str,
    fragment_entry: &str,
) -> CompiledGlsl {
    let module = wgsl::parse_str(source).unwrap();

    let info = Validator::new(ValidationFlags::all(), Capabilities::default())
        .subgroup_stages(naga::valid::ShaderStages::all())
        .subgroup_operations(naga::valid::SubgroupOperationSet::all())
        .validate(&module)
        .unwrap();

    let options = glsl::Options {
        version: Version::Embedded {
            version: 300,
            is_webgl: true,
        },
        ..Default::default()
    };

    let mut glsl_vs = String::new();
    let reflection_vs = {
        let pipeline_options = PipelineOptions {
            entry_point: vertex_entry.into(),
            shader_stage: ShaderStage::Vertex,
            multiview: None,
        };

        let mut w_vs = glsl::Writer::new(
            &mut glsl_vs,
            &module,
            &info,
            &options,
            &pipeline_options,
            naga::proc::BoundsCheckPolicies {
                index: naga::proc::BoundsCheckPolicy::Unchecked,
                buffer: naga::proc::BoundsCheckPolicy::Unchecked,
                image_load: naga::proc::BoundsCheckPolicy::Unchecked,
                binding_array: naga::proc::BoundsCheckPolicy::Unchecked,
            },
        )
        .unwrap();
        ReflectionMap::new(
            w_vs.write().expect("failed to write vertex."),
            &module.global_variables,
        )
    };

    let pipeline_options = PipelineOptions {
        entry_point: fragment_entry.into(),
        shader_stage: ShaderStage::Fragment,
        multiview: None,
    };
    let mut glsl_fs = String::new();
    let mut w_fs = glsl::Writer::new(
        &mut glsl_fs,
        &module,
        &info,
        &options,
        &pipeline_options,
        naga::proc::BoundsCheckPolicies {
            index: naga::proc::BoundsCheckPolicy::Unchecked,
            buffer: naga::proc::BoundsCheckPolicy::Unchecked,
            image_load: naga::proc::BoundsCheckPolicy::Unchecked,
            binding_array: naga::proc::BoundsCheckPolicy::Unchecked,
        },
    )
    .unwrap();
    let reflection_fs = ReflectionMap::new(
        w_fs.write().expect("failed to write fragment."),
        &module.global_variables,
    );

    CompiledGlsl {
        vertex: Stage {
            source: glsl_vs,
            reflection_map: reflection_vs,
        },
        fragment: Stage {
            source: glsl_fs,
            reflection_map: reflection_fs,
        },
    }
}