xgpui-shader 0.5.0

Shader and paint extension for xgpui with gradients, brushes, and portable WGSL shaders
Documentation
use super::*;
use anyhow::{Context, bail};
use naga::{ScalarKind, TypeInner};
const PRELUDE: &str = "struct ShaderInput { uv: vec2<f32>, position: vec2<f32>, size: vec2<f32>, scale_factor: f32, }";

pub(super) fn compile<T: ShaderInstance>(
    user: &str,
    encoding: ShaderOutputEncoding,
) -> Result<SceneShaderProgram> {
    compile_impl::<T>(user, encoding, false, false)
}
pub(super) fn compile_glyph<T: ShaderInstance>(user: &str) -> Result<SceneShaderProgram> {
    compile_impl::<T>(user, ShaderOutputEncoding::EncodedSrgb, true, false)
}
pub(super) fn compile_path<T: ShaderInstance>(user: &str) -> Result<SceneShaderProgram> {
    compile_impl::<T>(user, ShaderOutputEncoding::EncodedSrgb, false, true)
}
fn compile_impl<T: ShaderInstance>(
    user: &str,
    encoding: ShaderOutputEncoding,
    glyph: bool,
    path: bool,
) -> Result<SceneShaderProgram> {
    ensure!(user.len() <= 64 * 1024, "shader source exceeds 64 KiB");
    let user_source = format!("{PRELUDE}\n{user}");
    let parsed = naga::front::wgsl::parse_str(&user_source).map_err(|e| {
        let line = e
            .location(&user_source)
            .map(|v| v.line_number.saturating_sub(1));
        anyhow::anyhow!(
            "shader source line {}: {}\n{}",
            line.unwrap_or(0),
            e,
            e.emit_to_string(&user_source)
        )
    })?;
    ensure!(
        parsed.entry_points.is_empty()
            && parsed.global_variables.is_empty()
            && parsed.overrides.is_empty(),
        "declare only types, constants and helper functions; host owns entry points and resources"
    );
    let (_, ty) = parsed
        .types
        .iter()
        .find(|(_, t)| t.name.as_deref() == Some("Parameters"))
        .context("expected struct Parameters")?;
    let TypeInner::Struct { members, span } = &ty.inner else {
        bail!("Parameters must be a struct")
    };
    ensure!(
        !members.is_empty() && *span <= 128,
        "Parameters must contain fields and fit in 128 bytes"
    );
    ensure!(
        *span as usize == std::mem::size_of::<T>(),
        "Rust instance size {} differs from WGSL stride {}",
        std::mem::size_of::<T>(),
        span
    );
    ensure!(
        members.len() == T::FIELDS.len(),
        "Rust/WGSL member count differs"
    );
    let mut args = Vec::new();
    for (member, field) in members.iter().zip(T::FIELDS) {
        let components = match parsed.types[member.ty].inner {
            TypeInner::Scalar(naga::Scalar {
                kind: ScalarKind::Float,
                width: 4,
            }) => 1,
            TypeInner::Vector {
                size,
                scalar:
                    naga::Scalar {
                        kind: ScalarKind::Float,
                        width: 4,
                    },
            } => size as usize,
            _ => bail!("Parameters supports only f32 and vec2/3/4<f32>"),
        };
        ensure!(
            member.name.as_deref() == Some(field.name)
                && member.offset as usize == field.offset
                && components == field.components,
            "Rust/WGSL layout mismatch for {}: expected offset {}, {} components",
            field.name,
            member.offset,
            components
        );
        let values: Vec<_> = (0..components)
            .map(|i| {
                let word = member.offset as usize / 4 + i;
                format!("input.data{}[{}]", word / 4, word % 4)
            })
            .collect();
        args.push(if components == 1 {
            values[0].clone()
        } else {
            format!("vec{components}<f32>({})", values.join(","))
        });
    }
    let attributes = (0..8)
        .map(|i| format!("@location({}) data{i}: vec4<f32>,", i + 3))
        .collect::<String>();
    let varying = (0..8)
        .map(|i| {
            format!(
                "@location({}) @interpolate(flat) data{i}: vec4<f32>,",
                i + 4
            )
        })
        .collect::<String>();
    let copy = (0..8)
        .map(|i| format!("out.data{i} = instance.data{i};"))
        .collect::<String>();
    let output = if encoding == ShaderOutputEncoding::LinearRec2020 {
        r#"var rgb = color.rgb;
        if (host.pad & 1u) != 0u {
            rgb = vec3(dot(rgb,vec3(1.660491002,-0.587641139,-0.072849863)),
                dot(rgb,vec3(-0.124550475,1.132899897,-0.008349423)),
                dot(rgb,vec3(-0.018150763,-0.100578898,1.118729661)));
        } else {
            rgb = vec3(dot(rgb,vec3(1.343578253,-0.282179671,-0.061398582)),
                dot(rgb,vec3(-0.065297453,1.075787916,-0.010490463)),
                dot(rgb,vec3(0.002821787,-0.019598495,1.016776707)));
        }
        return vec4(rgb * alpha, alpha);"#
    } else if encoding == ShaderOutputEncoding::LinearDisplayP3 {
        // pad bit 0 selects scRGB (otherwise extended P3); bit 1 selects
        // Metal alpha-only glyph coverage, independently of composition space.
        r#"var rgb = color.rgb;
        if (host.pad & 1u) != 0u {
            rgb = vec3(1.2249401763 * rgb.r - 0.2249401763 * rgb.g,
                -0.0420569547 * rgb.r + 1.0420569547 * rgb.g,
                -0.0196375546 * rgb.r - 0.0786360456 * rgb.g + 1.0982736002 * rgb.b);
        }
        return vec4(rgb * alpha, alpha);"#
    } else {
        "return vec4(select(color.rgb, color.rgb * alpha, host.premultiplied != 0u), alpha);"
    };
    let glyph_resource = if glyph || path {
        "@group(1) @binding(0) var glyph_atlas: texture_2d<f32>;"
    } else {
        ""
    };
    let glyph_sample = if path {
        "let path_sample = textureLoad(glyph_atlas,vec2<i32>(input.screen.xy),0).a;"
    } else if glyph {
        "let glyph_sample = textureLoad(glyph_atlas, vec2<i32>(glyph_texel(ShaderInput(input.local, input.local * input.extent, input.extent, input.misc.y), parameters)), 0);"
    } else {
        ""
    };
    let glyph_coverage = if path {
        "path_sample"
    } else if glyph {
        "select(glyph_sample.r, glyph_sample.a, (host.pad & 2u) != 0u)"
    } else {
        "1."
    };
    let source = format!(
        r#"
{PRELUDE}
{user}
struct HostGlobals {{ viewport: vec2<f32>, premultiplied: u32, pad: u32, }}
@group(0) @binding(0) var<uniform> host: HostGlobals;
{glyph_resource}
struct HostInstance {{ @location(0) bounds: vec4<f32>, @location(1) clip: vec4<f32>, @location(2) misc: vec4<f32>, {attributes} }}
struct HostVarying {{
    @builtin(position) screen: vec4<f32>,
    @location(0) local: vec2<f32>,
    @location(1) @interpolate(flat) extent: vec2<f32>,
    @location(2) @interpolate(flat) clip: vec4<f32>,
    @location(3) @interpolate(flat) misc: vec2<f32>,
    {varying}
}}
@vertex fn shader_vertex(@builtin(vertex_index) vertex: u32, instance: HostInstance) -> HostVarying {{
    let vertices = array<vec2<f32>, 6>(vec2(0.,0.), vec2(1.,0.), vec2(0.,1.), vec2(0.,1.), vec2(1.,0.), vec2(1.,1.));
    let uv = vertices[vertex];
    let screen = instance.bounds.xy + uv * instance.bounds.zw;
    var out: HostVarying;
    out.screen = vec4(screen / host.viewport * vec2(2.,-2.) + vec2(-1.,1.), 0., 1.);
    out.local = uv; out.extent = instance.bounds.zw / instance.misc.y;
    out.clip = instance.clip; out.misc = instance.misc.xy;
    {copy}
    return out;
}}
@fragment fn shader_fragment(input: HostVarying) -> @location(0) vec4<f32> {{
    if (any(input.screen.xy < input.clip.xy) || any(input.screen.xy >= input.clip.zw)) {{ discard; }}
    let parameters = Parameters({parameters});
    let color = clamp(shade(ShaderInput(input.local, input.local * input.extent, input.extent, input.misc.y), parameters), vec4(0.), vec4(1.));
    {glyph_sample}
    let alpha = color.a * input.misc.x * {glyph_coverage};
    {output}
}}
"#,
        parameters = args.join(",")
    );
    let module = naga::front::wgsl::parse_str(&source)
        .map_err(|e| anyhow::anyhow!("{}", e.emit_to_string(&source)))?;
    let info = naga::valid::Validator::new(
        naga::valid::ValidationFlags::all(),
        naga::valid::Capabilities::empty(),
    )
    .validate(&module)
    .context("instanced shader validation")?;
    let mut msl = naga::back::msl::Options {
        lang_version: (2, 1),
        fake_missing_bindings: false,
        ..Default::default()
    };
    for entry in &module.entry_points {
        let mut resources = naga::back::msl::EntryPointResources::default();
        resources.resources.insert(
            naga::ResourceBinding {
                group: 0,
                binding: 0,
            },
            naga::back::msl::BindTarget {
                buffer: Some(1),
                ..Default::default()
            },
        );
        if glyph || path {
            resources.resources.insert(
                naga::ResourceBinding {
                    group: 1,
                    binding: 0,
                },
                naga::back::msl::BindTarget {
                    texture: Some(0),
                    ..Default::default()
                },
            );
        }
        msl.per_entry_point_map
            .insert(entry.name.clone(), resources);
    }
    let (metal, reflection) =
        naga::back::msl::write_string(&module, &info, &msl, &Default::default())
            .context("MSL translation")?;
    let names: Vec<_> = reflection
        .entry_point_names
        .into_iter()
        .collect::<std::result::Result<_, _>>()
        .map_err(|e| anyhow::anyhow!("MSL entry point: {e:?}"))?;
    let mut options = naga::back::hlsl::Options {
        shader_model: naga::back::hlsl::ShaderModel::V5_0,
        fake_missing_bindings: false,
        ..Default::default()
    };
    options.binding_map.insert(
        naga::ResourceBinding {
            group: 0,
            binding: 0,
        },
        naga::back::hlsl::BindTarget {
            register: 0,
            ..Default::default()
        },
    );
    if glyph || path {
        options.binding_map.insert(
            naga::ResourceBinding {
                group: 1,
                binding: 0,
            },
            naga::back::hlsl::BindTarget {
                register: 0,
                ..Default::default()
            },
        );
    }
    let mut hlsl = String::new();
    let reflection = naga::back::hlsl::Writer::new(&mut hlsl, &options, &Default::default())
        .write(&module, &info, None)
        .context("HLSL translation")?;
    let hlsl_names: Vec<_> = reflection
        .entry_point_names
        .into_iter()
        .collect::<std::result::Result<_, _>>()
        .map_err(|e| anyhow::anyhow!("HLSL entry point: {e:?}"))?;
    for entry in &module.entry_points {
        naga::back::spv::write_vec(
            &module,
            &info,
            &Default::default(),
            Some(&naga::back::spv::PipelineOptions {
                shader_stage: entry.stage,
                entry_point: entry.name.clone(),
            }),
        )
        .context("SPIR-V translation")?;
    }
    let program = SceneShaderProgram::new_with_output_encoding(
        source,
        (metal, names[0].clone(), names[1].clone()),
        (hlsl, hlsl_names[0].clone(), hlsl_names[1].clone()),
        encoding,
    );
    Ok(if glyph {
        program.with_glyph_mask()
    } else if path {
        program.with_path_mask()
    } else {
        program
    })
}