Enum Type 

pub enum Type {
    Bool,
    AbstractInt,
    AbstractFloat,
    I32,
    U32,
    F32,
    F16,
    Struct(Box<StructType>),
    Array(Box<Type>, Option<usize>),
    Vec(u8, Box<Type>),
    Mat(u8, u8, Box<Type>),
    Atomic(Box<Type>),
    Ptr(AddressSpace, Box<Type>, AccessMode),
    Ref(AddressSpace, Box<Type>, AccessMode),
    Texture(TextureType),
    Sampler(SamplerType),
    I64,
    U64,
    F64,
    BindingArray(Box<Type>, Option<usize>),
    RayQuery(Option<AccelerationStructureFlags>),
    AccelerationStructure(Option<AccelerationStructureFlags>),
}

WGSL type.

Variants

Bool

AbstractInt

AbstractFloat

I32

U32

F32

F16

Struct(Box<StructType>)

Array(Box<Type>, Option<usize>)

Vec(u8, Box<Type>)

Mat(u8, u8, Box<Type>)

Atomic(Box<Type>)

Ptr(AddressSpace, Box<Type>, AccessMode)

Ref(AddressSpace, Box<Type>, AccessMode)

Texture(TextureType)

Sampler(SamplerType)

I64

Available on crate feature naga-ext only.

U64

Available on crate feature naga-ext only.

F64

Available on crate feature naga-ext only.

BindingArray(Box<Type>, Option<usize>)

Available on crate feature naga-ext only.

RayQuery(Option<AccelerationStructureFlags>)

Available on crate feature naga-ext only.

AccelerationStructure(Option<AccelerationStructureFlags>)

Available on crate feature naga-ext only.

Implementations

impl Type

pub fn size_of(&self) -> Option<u32>

Compute the size of the type.

Return None if the type is not host-shareable, or if it contains a runtime-sized array. See Type::min_size_of for runtime-sized arrays.

Reference: https://www.w3.org/TR/WGSL/#alignment-and-size

pub fn min_size_of(&self) -> Option<u32>

Variant of Type::size_of, but for runtime-sized arrays, it returns the minimum size of the array, i.e. the size of an array with one element.

pub fn align_of(&self) -> Option<u32>

Compute the alignment of the type.

Return None if the type is not host-shareable.

Reference: https://www.w3.org/TR/WGSL/#alignment-and-size

impl Type

pub fn op_not(&self) -> Result<Self, Error>

pub fn op_or(&self, rhs: &Type) -> Result<Self, Error>

pub fn op_and(&self, rhs: &Type) -> Result<Self, Error>

impl Type

pub fn op_neg(&self) -> Result<Self, Error>

Valid operands:

• -S, S: scalar

pub fn op_add(&self, rhs: &Type) -> Result<Self, Error>

Valid operands:

• T + T, T: scalar or vec
• S + V or V + S, S: scalar, V: vec<S>
• M + M, M: mat

pub fn op_sub(&self, rhs: &Type) -> Result<Self, Error>

Valid operands:

• T - T, T: scalar or vec
• S - V or V - S, S: scalar, V: vec<S>
• M - M, M: mat

pub fn op_mul(&self, rhs: &Type) -> Result<Self, Error>

Valid operands:

• T * T, T: scalar or vec
• S * V or V * S, S: scalar, V: vec<S>
• S * M or M * S, S: float, M: mat<S>
• V * M or M * V, S: float, V: vec<S>, M: mat<S>
• M1 * M1, M1: matKxR, M2: matCxK

pub fn op_div(&self, rhs: &Type) -> Result<Self, Error>

Valid operands:

• T / T, T: scalar or vec
• S / V or V / S, S: scalar, V: vec<S>

pub fn op_rem(&self, rhs: &Type) -> Result<Self, Error>

Valid operands:

• T % T, T: scalar or vec
• S % V or V % S, S: scalar, V: vec<S>

impl Type

pub fn op_eq(&self, rhs: &Type) -> Result<Type, Error>

Valid operands:

• T == T, T: scalar or vec

pub fn op_ne(&self, rhs: &Type) -> Result<Type, Error>

Valid operands:

• T != T, T: scalar or vec

pub fn op_lt(&self, rhs: &Type) -> Result<Type, Error>

Valid operands:

• T < T, T: scalar or vec

pub fn op_le(&self, rhs: &Type) -> Result<Type, Error>

Valid operands:

• T <= T, T: scalar or vec

pub fn op_gt(&self, rhs: &Type) -> Result<Type, Error>

Valid operands:

• T > T, T: scalar or vec

pub fn op_ge(&self, rhs: &Type) -> Result<Type, Error>

Valid operands:

• T >= T, T: scalar or vec

impl Type

pub fn op_bitnot(&self) -> Result<Type, Error>

Valid operands:

• ~T, I: integer, T: I or vec<I>

pub fn op_bitor(&self, rhs: &Type) -> Result<Type, Error>

Note: this is both the “bitwise OR” and “logical OR” operator.

Valid operands:

• T | T, T: integer, or vec<integer> (bitwise OR)
• V | V, V: vec<bool> (logical OR)

pub fn op_bitand(&self, rhs: &Type) -> Result<Type, Error>

Note: this is both the “bitwise AND” and “logical AND” operator.

Valid operands:

• T & T, T: integer or vec<integer> (bitwise AND)
• V & V, V: vec<bool> (logical AND)

pub fn op_bitxor(&self, rhs: &Type) -> Result<Type, Error>

Valid operands:

• T ^ T, T: integer or vec<integer>

pub fn op_shl(&self, rhs: &Type) -> Result<Type, Error>

Valid operands:

• integer << u32
• vec<integer> << vec<u32>

pub fn op_shr(&self, rhs: &Type) -> Result<Type, Error>

Valid operands:

• integer >> u32
• vec<integer> >> vec<u32>

impl Type

pub fn op_ref(&self) -> Result<Type, Error>

pub fn op_deref(&self) -> Result<Type, Error>

impl Type

pub fn is_convertible_to(&self, ty: &Type) -> bool

pub fn concretize(&self) -> Self

pub fn loaded(self) -> Self

Apply the load rule.

Reference: https://www.w3.org/TR/WGSL/#load-rule

impl Type

pub fn is_scalar(&self) -> bool

Reference: https://www.w3.org/TR/WGSL/#scalar

pub fn is_numeric(&self) -> bool

Reference: https://www.w3.org/TR/WGSL/#numeric-scalar

pub fn is_integer(&self) -> bool

Reference: https://www.w3.org/TR/WGSL/#integer-scalar

pub fn is_float(&self) -> bool

Reference: https://www.w3.org/TR/WGSL/#floating-point-types

pub fn is_abstract(&self) -> bool

Reference: https://www.w3.org/TR/WGSL/#abstract-types

pub fn is_concrete(&self) -> bool

pub fn is_storable(&self) -> bool

Reference: https://www.w3.org/TR/WGSL/#storable-types

pub fn is_array(&self) -> bool

pub fn is_vec(&self) -> bool

pub fn is_i32(&self) -> bool

pub fn is_u32(&self) -> bool

pub fn is_f32(&self) -> bool

pub fn is_i64(&self) -> bool

Available on crate feature naga-ext only.

pub fn is_u64(&self) -> bool

Available on crate feature naga-ext only.

pub fn is_f64(&self) -> bool

Available on crate feature naga-ext only.

pub fn is_bool(&self) -> bool

pub fn is_mat(&self) -> bool

pub fn is_abstract_int(&self) -> bool

pub fn unwrap_atomic(self) -> Box<Type>

pub fn unwrap_struct(self) -> Box<StructType>

pub fn unwrap_vec(self) -> (u8, Box<Type>)

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Convert for Type

fn convert_to(&self, ty: &Type) -> Option<Self>

Convert an instance to another type, if a feasible conversion exists.

fn convert_inner_to(&self, ty: &Type) -> Option<Self>

Convert an instance by changing its inner type to another.

fn concretize(&self) -> Option<Self>

Convert an abstract instance to a concrete type.

impl Debug for Type

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Type

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<SampledType> for Type

fn from(value: SampledType) -> Self

Converts to this type from the input type.

impl From<StructType> for Type

fn from(value: StructType) -> Self

Converts to this type from the input type.

impl From<Type> for Instance

fn from(value: Type) -> Self

Converts to this type from the input type.

impl PartialEq for Type

fn eq(&self, other: &Type) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<&Type> for SampledType

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &Type) -> Result<Self, Self::Error>

Performs the conversion.

impl Ty for Type

fn ty(&self) -> Type

get the type of an instance.

fn inner_ty(&self) -> Type

get the inner type of an instance (not recursive).

impl Eq for Type

impl StructuralPartialEq for Type