Skip to content

Commit

Permalink
Checks some functions.
Browse files Browse the repository at this point in the history
  • Loading branch information
@jimblandy
jimblandy committed Feb 15, 2025
1 parent 1541898 commit acb245f
Show file tree
Hide file tree
Showing 12 changed files with 1,837 additions and 687 deletions.
298 changes: 298 additions & 0 deletions naga/src/common/wgsl.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -67,3 +67,301 @@ impl StandardFilterableTriggeringRule {
}
}
}

impl crate::MathFunction {
pub fn to_wgsl(self) -> &'static str {
use crate::MathFunction as Mf;

match self {
Mf::Abs => "abs",
Mf::Min => "min",
Mf::Max => "max",
Mf::Clamp => "clamp",
Mf::Saturate => "saturate",
Mf::Cos => "cos",
Mf::Cosh => "cosh",
Mf::Sin => "sin",
Mf::Sinh => "sinh",
Mf::Tan => "tan",
Mf::Tanh => "tanh",
Mf::Acos => "acos",
Mf::Asin => "asin",
Mf::Atan => "atan",
Mf::Atan2 => "atan2",
Mf::Asinh => "asinh",
Mf::Acosh => "acosh",
Mf::Atanh => "atanh",
Mf::Radians => "radians",
Mf::Degrees => "degrees",
Mf::Ceil => "ceil",
Mf::Floor => "floor",
Mf::Round => "round",
Mf::Fract => "fract",
Mf::Trunc => "trunc",
Mf::Modf => "modf",
Mf::Frexp => "frexp",
Mf::Ldexp => "ldexp",
Mf::Exp => "exp",
Mf::Exp2 => "exp2",
Mf::Log => "log",
Mf::Log2 => "log2",
Mf::Pow => "pow",
Mf::Dot => "dot",
Mf::Cross => "cross",
Mf::Distance => "distance",
Mf::Length => "length",
Mf::Normalize => "normalize",
Mf::FaceForward => "faceForward",
Mf::Reflect => "reflect",
Mf::Refract => "refract",
Mf::Sign => "sign",
Mf::Fma => "fma",
Mf::Mix => "mix",
Mf::Step => "step",
Mf::SmoothStep => "smoothstep",
Mf::Sqrt => "sqrt",
Mf::InverseSqrt => "inverseSqrt",
Mf::Transpose => "transpose",
Mf::Determinant => "determinant",
Mf::QuantizeToF16 => "quantizeToF16",
Mf::CountTrailingZeros => "countTrailingZeros",
Mf::CountLeadingZeros => "countLeadingZeros",
Mf::CountOneBits => "countOneBits",
Mf::ReverseBits => "reverseBits",
Mf::ExtractBits => "extractBits",
Mf::InsertBits => "insertBits",
Mf::FirstTrailingBit => "firstTrailingBit",
Mf::FirstLeadingBit => "firstLeadingBit",
Mf::Pack4x8snorm => "pack4x8snorm",
Mf::Pack4x8unorm => "pack4x8unorm",
Mf::Pack2x16snorm => "pack2x16snorm",
Mf::Pack2x16unorm => "pack2x16unorm",
Mf::Pack2x16float => "pack2x16float",
Mf::Pack4xI8 => "pack4xI8",
Mf::Pack4xU8 => "pack4xU8",
Mf::Unpack4x8snorm => "unpack4x8snorm",
Mf::Unpack4x8unorm => "unpack4x8unorm",
Mf::Unpack2x16snorm => "unpack2x16snorm",
Mf::Unpack2x16unorm => "unpack2x16unorm",
Mf::Unpack2x16float => "unpack2x16float",
Mf::Unpack4xI8 => "unpack4xI8",
Mf::Unpack4xU8 => "unpack4xU8",
Mf::Inverse => "{matrix inverse}",
Mf::Outer => "{vector outer product}",
}
}
}

impl crate::BuiltIn {
pub fn to_wgsl(self) -> &'static str {
match self {
crate::BuiltIn::Position { invariant: true } => "@position @invariant",
crate::BuiltIn::Position { invariant: false } => "@position",
crate::BuiltIn::ViewIndex => "view_index",
crate::BuiltIn::BaseInstance => "{BaseInstance}",
crate::BuiltIn::BaseVertex => "{BaseVertex}",
crate::BuiltIn::ClipDistance => "{ClipDistance}",
crate::BuiltIn::CullDistance => "{CullDistance}",
crate::BuiltIn::InstanceIndex => "instance_index",
crate::BuiltIn::PointSize => "{PointSize}",
crate::BuiltIn::VertexIndex => "vertex_index",
crate::BuiltIn::DrawID => "{DrawId}",
crate::BuiltIn::FragDepth => "frag_depth",
crate::BuiltIn::PointCoord => "{PointCoord}",
crate::BuiltIn::FrontFacing => "front_facing",
crate::BuiltIn::PrimitiveIndex => "primitive_index",
crate::BuiltIn::SampleIndex => "sample_index",
crate::BuiltIn::SampleMask => "sample_mask",
crate::BuiltIn::GlobalInvocationId => "global_invocation_id",
crate::BuiltIn::LocalInvocationId => "local_invocation_id",
crate::BuiltIn::LocalInvocationIndex => "local_invocation_index",
crate::BuiltIn::WorkGroupId => "workgroup_id",
crate::BuiltIn::WorkGroupSize => "{WorkGroupSize}",
crate::BuiltIn::NumWorkGroups => "num_workgroups",
crate::BuiltIn::NumSubgroups => "num_subgroups",
crate::BuiltIn::SubgroupId => "{SubgroupId}",
crate::BuiltIn::SubgroupSize => "subgroup_size",
crate::BuiltIn::SubgroupInvocationId => "subgroup_invocation_id",
}
}
}

impl crate::Interpolation {
pub fn to_wgsl(self) -> &'static str {
match self {
crate::Interpolation::Perspective => "perspective",
crate::Interpolation::Linear => "linear",
crate::Interpolation::Flat => "flat",
}
}
}

impl crate::Sampling {
pub fn to_wgsl(self) -> &'static str {
match self {
crate::Sampling::Center => "center",
crate::Sampling::Centroid => "centroid",
crate::Sampling::Sample => "sample",
crate::Sampling::First => "first",
crate::Sampling::Either => "either",
}
}
}

pub struct Wgslish<T>(pub T);

impl Display for Wgslish<&crate::TypeInner> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
match *self.0 {
crate::TypeInner::Scalar(scalar) => Wgslish(scalar).fmt(f),
crate::TypeInner::Vector { size, scalar } => {
write!(f, "vec{}<{}>", size as u8, Wgslish(scalar))
}
crate::TypeInner::Matrix {
columns,
rows,
scalar,
} => {
write!(
f,
"mat{}x{}<{}>",
columns as u8,
rows as u8,
Wgslish(scalar)
)
}
crate::TypeInner::Atomic(scalar) => {
write!(f, "atomic<{}>", Wgslish(scalar))
}
crate::TypeInner::Pointer { base, space } => {
write!(f, "ptr<{}, {base:?}>", Wgslish(space))
}
crate::TypeInner::ValuePointer {
size,
scalar,
space,
} => {
write!(f, "ptr<{}, ", Wgslish(space))?;
match size {
Some(size) => write!(f, "vec{}<{}>", size as u8, Wgslish(scalar))?,
None => Wgslish(scalar).fmt(f)?,
}
f.write_str(">")
}
crate::TypeInner::Array { base, size, stride } => {
write!(f, "@stride({stride}) array<{base:?}")?;
match size {
crate::ArraySize::Constant(non_zero) => write!(f, ", {non_zero}>"),
crate::ArraySize::Pending(pending_array_size) => match pending_array_size {
crate::PendingArraySize::Expression(handle) => {
write!(f, "expression {handle:?}")
}
crate::PendingArraySize::Override(handle) => {
write!(f, "override {handle:?}")
}
},
crate::ArraySize::Dynamic => f.write_str(">"),
}
}
crate::TypeInner::Struct { ref members, span } => {
write!(f, "@span({span}) struct {{ ")?;
for (i, member) in members.iter().enumerate() {
if i != 0 {
f.write_str(", ")?;
}
write!(f, "@offset({}) ", member.offset)?;
if let Some(ref binding) = member.binding {
Wgslish(binding).fmt(f)?;
}
write!(
f,
"{}: {:?}",
member.name.as_deref().unwrap_or("<anonymous>"),
member.ty
)?;
}
f.write_str("}")
}
crate::TypeInner::Image {
dim: _,
arrayed: _,
class: _,
} => todo!(),
crate::TypeInner::Sampler { comparison: _ } => todo!(),
crate::TypeInner::AccelerationStructure => todo!(),
crate::TypeInner::RayQuery => todo!(),
crate::TypeInner::BindingArray { base, size } => {
write!(f, "array<{base:?}")?;
match size {
crate::ArraySize::Constant(non_zero) => write!(f, ", {non_zero}>"),
crate::ArraySize::Pending(pending_array_size) => match pending_array_size {
crate::PendingArraySize::Expression(handle) => {
write!(f, "expression {handle:?}")
}
crate::PendingArraySize::Override(handle) => {
write!(f, "override {handle:?}")
}
},
crate::ArraySize::Dynamic => f.write_str(">"),
}
}
}
}
}

impl Display for Wgslish<crate::Scalar> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
let bits = self.0.width * 8;
match self.0.kind {
crate::ScalarKind::Sint => write!(f, "i{bits}"),
crate::ScalarKind::Uint => write!(f, "u{bits}"),
crate::ScalarKind::Float => write!(f, "f{bits}"),
crate::ScalarKind::Bool => f.write_str("bool"),
crate::ScalarKind::AbstractInt => f.write_str("{AbstractInt}"),
crate::ScalarKind::AbstractFloat => f.write_str("{AbstractFloat}"),
}
}
}

impl Display for Wgslish<crate::AddressSpace> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
let wgsl = match self.0 {
crate::AddressSpace::Function => "function",
crate::AddressSpace::Private => "private",
crate::AddressSpace::WorkGroup => "workgroup",
crate::AddressSpace::Uniform => "uniform",
crate::AddressSpace::Storage { access } => {
return write!(f, "storage, {access:?}");
}
crate::AddressSpace::Handle => "handle",
crate::AddressSpace::PushConstant => "push_constant",
};
f.write_str(wgsl)
}
}

impl Display for Wgslish<&crate::Binding> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
match *self.0 {
crate::Binding::BuiltIn(built_in) => f.write_str(built_in.to_wgsl()),
crate::Binding::Location {
location,
second_blend_source,
interpolation,
sampling,
} => {
write!(f, "@location({location})")?;
if second_blend_source {
f.write_str(" @second_blend_source")?;
}
if let Some(interpolation) = interpolation {
write!(f, " {}", interpolation.to_wgsl())?;
}
if let Some(sampling) = sampling {
write!(f, " {}", sampling.to_wgsl())?;
}
Ok(())
}
}
}
}
Loading

0 comments on commit acb245f

Please sign in to comment.