[naga wgsl] Add to_wgsl functions for some Naga IR types.

Add `to_wgsl` functions that return the WGSL representations of the
following types as `&'static str` values:

- `MathFunction`
- `BuiltIn`
- `Interpolation`
- `Sampling`

Use these functions in the WGSL backend.

Also add `to_wgsl_debug` functions that return some legible string for
all possible values, not just those that are defined by the WGSL standard.

Author: jimblandy

naga/src/back/wgsl/mod.rs

@@ -19,7 +19,7 @@ pub enum Error {
     Custom(String),
     #[error("{0}")]
     Unimplemented(String), // TODO: Error used only during development
-    #[error("Unsupported math function: {0:?}")]
+    #[error("Unsupported math function: {}", .0.to_wgsl_debug())]
     UnsupportedMathFunction(crate::MathFunction),
     #[error("Unsupported relational function: {0:?}")]
     UnsupportedRelationalFunction(crate::RelationalFunction),

naga/src/back/wgsl/writer.rs

@@ -342,7 +342,12 @@ impl<W: Write> Writer<W> {
                 Attribute::Location(id) => write!(self.out, "@location({id}) ")?,
                 Attribute::SecondBlendSource => write!(self.out, "@second_blend_source ")?,
                 Attribute::BuiltIn(builtin_attrib) => {
-                    let builtin = builtin_str(builtin_attrib)?;
+                    let builtin = builtin_attrib.to_wgsl().ok_or_else(|| {
+                        Error::Custom(format!(
+                            "Unsupported builtin `{}`",
+                            builtin_attrib.to_wgsl_debug()
+                        ))
+                    })?;
                     write!(self.out, "@builtin({builtin}) ")?;
                 }
                 Attribute::Stage(shader_stage) => {
@@ -368,20 +373,20 @@ impl<W: Write> Writer<W> {
                         write!(
                             self.out,
                             "@interpolate({}, {}) ",
-                            interpolation_str(
-                                interpolation.unwrap_or(crate::Interpolation::Perspective)
-                            ),
-                            sampling_str(sampling.unwrap_or(crate::Sampling::Center))
+                            interpolation
+                                .unwrap_or(crate::Interpolation::Perspective)
+                                .to_wgsl(),
+                            sampling.unwrap_or(crate::Sampling::Center).to_wgsl(),
                         )?;
                     } else if interpolation.is_some()
                         && interpolation != Some(crate::Interpolation::Perspective)
                     {
                         write!(
                             self.out,
                             "@interpolate({}) ",
-                            interpolation_str(
-                                interpolation.unwrap_or(crate::Interpolation::Perspective)
-                            )
+                            interpolation
+                                .unwrap_or(crate::Interpolation::Perspective)
+                                .to_wgsl(),
                         )?;
                     }
                 }
@@ -1697,98 +1702,20 @@ impl<W: Write> Writer<W> {
                     InversePolyfill(InversePolyfill),
                 }
 
-                let function = match fun {
-                    Mf::Abs => Function::Regular("abs"),
-                    Mf::Min => Function::Regular("min"),
-                    Mf::Max => Function::Regular("max"),
-                    Mf::Clamp => Function::Regular("clamp"),
-                    Mf::Saturate => Function::Regular("saturate"),
-                    // trigonometry
-                    Mf::Cos => Function::Regular("cos"),
-                    Mf::Cosh => Function::Regular("cosh"),
-                    Mf::Sin => Function::Regular("sin"),
-                    Mf::Sinh => Function::Regular("sinh"),
-                    Mf::Tan => Function::Regular("tan"),
-                    Mf::Tanh => Function::Regular("tanh"),
-                    Mf::Acos => Function::Regular("acos"),
-                    Mf::Asin => Function::Regular("asin"),
-                    Mf::Atan => Function::Regular("atan"),
-                    Mf::Atan2 => Function::Regular("atan2"),
-                    Mf::Asinh => Function::Regular("asinh"),
-                    Mf::Acosh => Function::Regular("acosh"),
-                    Mf::Atanh => Function::Regular("atanh"),
-                    Mf::Radians => Function::Regular("radians"),
-                    Mf::Degrees => Function::Regular("degrees"),
-                    // decomposition
-                    Mf::Ceil => Function::Regular("ceil"),
-                    Mf::Floor => Function::Regular("floor"),
-                    Mf::Round => Function::Regular("round"),
-                    Mf::Fract => Function::Regular("fract"),
-                    Mf::Trunc => Function::Regular("trunc"),
-                    Mf::Modf => Function::Regular("modf"),
-                    Mf::Frexp => Function::Regular("frexp"),
-                    Mf::Ldexp => Function::Regular("ldexp"),
-                    // exponent
-                    Mf::Exp => Function::Regular("exp"),
-                    Mf::Exp2 => Function::Regular("exp2"),
-                    Mf::Log => Function::Regular("log"),
-                    Mf::Log2 => Function::Regular("log2"),
-                    Mf::Pow => Function::Regular("pow"),
-                    // geometry
-                    Mf::Dot => Function::Regular("dot"),
-                    Mf::Cross => Function::Regular("cross"),
-                    Mf::Distance => Function::Regular("distance"),
-                    Mf::Length => Function::Regular("length"),
-                    Mf::Normalize => Function::Regular("normalize"),
-                    Mf::FaceForward => Function::Regular("faceForward"),
-                    Mf::Reflect => Function::Regular("reflect"),
-                    Mf::Refract => Function::Regular("refract"),
-                    // computational
-                    Mf::Sign => Function::Regular("sign"),
-                    Mf::Fma => Function::Regular("fma"),
-                    Mf::Mix => Function::Regular("mix"),
-                    Mf::Step => Function::Regular("step"),
-                    Mf::SmoothStep => Function::Regular("smoothstep"),
-                    Mf::Sqrt => Function::Regular("sqrt"),
-                    Mf::InverseSqrt => Function::Regular("inverseSqrt"),
-                    Mf::Transpose => Function::Regular("transpose"),
-                    Mf::Determinant => Function::Regular("determinant"),
-                    Mf::QuantizeToF16 => Function::Regular("quantizeToF16"),
-                    // bits
-                    Mf::CountTrailingZeros => Function::Regular("countTrailingZeros"),
-                    Mf::CountLeadingZeros => Function::Regular("countLeadingZeros"),
-                    Mf::CountOneBits => Function::Regular("countOneBits"),
-                    Mf::ReverseBits => Function::Regular("reverseBits"),
-                    Mf::ExtractBits => Function::Regular("extractBits"),
-                    Mf::InsertBits => Function::Regular("insertBits"),
-                    Mf::FirstTrailingBit => Function::Regular("firstTrailingBit"),
-                    Mf::FirstLeadingBit => Function::Regular("firstLeadingBit"),
-                    // data packing
-                    Mf::Pack4x8snorm => Function::Regular("pack4x8snorm"),
-                    Mf::Pack4x8unorm => Function::Regular("pack4x8unorm"),
-                    Mf::Pack2x16snorm => Function::Regular("pack2x16snorm"),
-                    Mf::Pack2x16unorm => Function::Regular("pack2x16unorm"),
-                    Mf::Pack2x16float => Function::Regular("pack2x16float"),
-                    Mf::Pack4xI8 => Function::Regular("pack4xI8"),
-                    Mf::Pack4xU8 => Function::Regular("pack4xU8"),
-                    // data unpacking
-                    Mf::Unpack4x8snorm => Function::Regular("unpack4x8snorm"),
-                    Mf::Unpack4x8unorm => Function::Regular("unpack4x8unorm"),
-                    Mf::Unpack2x16snorm => Function::Regular("unpack2x16snorm"),
-                    Mf::Unpack2x16unorm => Function::Regular("unpack2x16unorm"),
-                    Mf::Unpack2x16float => Function::Regular("unpack2x16float"),
-                    Mf::Unpack4xI8 => Function::Regular("unpack4xI8"),
-                    Mf::Unpack4xU8 => Function::Regular("unpack4xU8"),
-                    Mf::Inverse => {
-                        let typ = func_ctx.resolve_type(arg, &module.types);
-
-                        let Some(overload) = InversePolyfill::find_overload(typ) else {
-                            return Err(Error::UnsupportedMathFunction(fun));
-                        };
+                let function = match fun.to_wgsl() {
+                    Some(name) => Function::Regular(name),
+                    None => match fun {
+                        Mf::Inverse => {
+                            let typ = func_ctx.resolve_type(arg, &module.types);
 
-                        Function::InversePolyfill(overload)
-                    }
-                    Mf::Outer => return Err(Error::UnsupportedMathFunction(fun)),
+                            let Some(overload) = InversePolyfill::find_overload(typ) else {
+                                return Err(Error::UnsupportedMathFunction(fun));
+                            };
+
+                            Function::InversePolyfill(overload)
+                        }
+                        other => return Err(Error::UnsupportedMathFunction(other)),
+                    },
                 };
 
                 match function {
@@ -1969,39 +1896,6 @@ impl<W: Write> Writer<W> {
     }
 }
 
-fn builtin_str(built_in: crate::BuiltIn) -> Result<&'static str, Error> {
-    use crate::BuiltIn as Bi;
-
-    Ok(match built_in {
-        Bi::VertexIndex => "vertex_index",
-        Bi::InstanceIndex => "instance_index",
-        Bi::Position { .. } => "position",
-        Bi::FrontFacing => "front_facing",
-        Bi::FragDepth => "frag_depth",
-        Bi::LocalInvocationId => "local_invocation_id",
-        Bi::LocalInvocationIndex => "local_invocation_index",
-        Bi::GlobalInvocationId => "global_invocation_id",
-        Bi::WorkGroupId => "workgroup_id",
-        Bi::NumWorkGroups => "num_workgroups",
-        Bi::SampleIndex => "sample_index",
-        Bi::SampleMask => "sample_mask",
-        Bi::PrimitiveIndex => "primitive_index",
-        Bi::ViewIndex => "view_index",
-        Bi::NumSubgroups => "num_subgroups",
-        Bi::SubgroupId => "subgroup_id",
-        Bi::SubgroupSize => "subgroup_size",
-        Bi::SubgroupInvocationId => "subgroup_invocation_id",
-        Bi::BaseInstance
-        | Bi::BaseVertex
-        | Bi::ClipDistance
-        | Bi::CullDistance
-        | Bi::PointSize
-        | Bi::PointCoord
-        | Bi::WorkGroupSize
-        | Bi::DrawID => return Err(Error::Custom(format!("Unsupported builtin {built_in:?}"))),
-    })
-}
-
 const fn image_dimension_str(dim: crate::ImageDimension) -> &'static str {
     use crate::ImageDimension as IDim;
 
@@ -2098,17 +1992,6 @@ const fn storage_format_str(format: crate::StorageFormat) -> &'static str {
     }
 }
 
-/// Helper function that returns the string corresponding to the WGSL interpolation qualifier
-const fn interpolation_str(interpolation: crate::Interpolation) -> &'static str {
-    use crate::Interpolation as I;
-
-    match interpolation {
-        I::Perspective => "perspective",
-        I::Linear => "linear",
-        I::Flat => "flat",
-    }
-}
-
 /// Return the WGSL auxiliary qualifier for the given sampling value.
 const fn sampling_str(sampling: crate::Sampling) -> &'static str {
     use crate::Sampling as S;