Enum Instance 

pub enum Instance {
    Literal(LiteralInstance),
    Struct(StructInstance),
    Array(ArrayInstance),
    Vec(VecInstance),
    Mat(MatInstance),
    Ptr(PtrInstance),
    Ref(RefInstance),
    Atomic(AtomicInstance),
    Opaque(Type),
}

Instance of a plain type.

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

Variants

Literal(LiteralInstance)

Struct(StructInstance)

Array(ArrayInstance)

Vec(VecInstance)

Mat(MatInstance)

Ptr(PtrInstance)

Ref(RefInstance)

Atomic(AtomicInstance)

Opaque(Type)

This variant is used to refer to currently unreachable instances, including instances of opaque types, such as textures and samplers, and instances that cannot be computed yet.

Implementations

impl Instance

pub fn to_buffer(&self) -> Option<Vec<u8>>

Memory representation of host-shareable instances.

Returns None if the type is not host-shareable.

pub fn from_buffer(buf: &[u8], ty: &Type) -> Option<Self>

Load an instance from a byte buffer.

Returns None if the type is not host-shareable, or if the buffer is too small. The buffer can be larger than the type; extra bytes will be ignored.

impl Instance

pub fn zero_value(ty: &Type) -> Result<Self, Error>

Zero-value initialize an instance of a given type.

pub fn storable_zero_value(ty: &Type) -> Result<Self, Error>

For types that are not constructible, but are storable, there is no zero-value, but it is possible to initialize a variable storing an instance of the type.

In practice, these types are only atomics and composite of atomics (array and struct) in the workgroup address space.

There are other non-constructible, storable types, but they live in host-managed address spaces:

• textures and samplers in the handle address space.
• runtime-sized arrays in the storage address space.

impl Instance

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

impl Instance

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

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

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

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

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

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

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

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

impl Instance

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

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

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

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

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

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

impl Instance

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

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

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

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

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

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

pub fn op_shl(&self, rhs: &Self, stage: ShaderStage) -> Result<Self, Error>

pub fn op_shr(&self, rhs: &Self, stage: ShaderStage) -> Result<Self, Error>

impl Instance

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

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

impl Instance

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

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

Apply the load rule.

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

impl Instance

pub fn unwrap_literal(self) -> LiteralInstance

pub fn unwrap_literal_ref(&self) -> &LiteralInstance

pub fn unwrap_vec(self) -> VecInstance

pub fn unwrap_vec_ref(&self) -> &VecInstance

pub fn unwrap_vec_mut(&mut self) -> &mut VecInstance

impl Instance

pub fn view(&self, view: &MemView) -> Result<&Instance, Error>

Get an instance representing a memory view.

There are two ways to create a memory view:

• Accessing a struct component (struct.member)
• Indexing an array, vec, or mat (arr[n])

Reference: https://www.w3.org/TR/WGSL/#memory-views

pub fn view_mut(&mut self, view: &MemView) -> Result<&mut Instance, Error>

Get an instance representing a memory view.

See Self::view

pub fn write(&mut self, value: Instance) -> Result<Instance, Error>

Mutate the instance.

This is the operation performed by the assignment operator.

Trait Implementations

impl Clone for Instance

fn clone(&self) -> Instance

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Convert for Instance

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 Instance

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

Formats the value using the given formatter.

impl Display for Instance

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

Formats the value using the given formatter.

impl From<ArrayInstance> for Instance

fn from(value: ArrayInstance) -> Self

Converts to this type from the input type.

impl From<AtomicInstance> for Instance

fn from(value: AtomicInstance) -> Self

Converts to this type from the input type.

impl From<LiteralInstance> for Instance

fn from(value: LiteralInstance) -> Self

Converts to this type from the input type.

impl From<MatInstance> for Instance

fn from(value: MatInstance) -> Self

Converts to this type from the input type.

impl From<PtrInstance> for Instance

fn from(value: PtrInstance) -> Self

Converts to this type from the input type.

impl From<RefInstance> for Instance

fn from(value: RefInstance) -> Self

Converts to this type from the input type.

impl From<StructInstance> for Instance

fn from(value: StructInstance) -> 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 From<VecInstance> for Instance

fn from(value: VecInstance) -> Self

Converts to this type from the input type.

impl From<bool> for Instance

fn from(value: bool) -> Self

Converts to this type from the input type.

impl From<f32> for Instance

fn from(value: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Instance

fn from(value: f64) -> Self

Converts to this type from the input type.

impl From<i32> for Instance

fn from(value: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Instance

fn from(value: i64) -> Self

Converts to this type from the input type.

impl From<u32> for Instance

fn from(value: u32) -> Self

Converts to this type from the input type.

impl PartialEq for Instance

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Instance

impl Ty for Instance

fn ty(&self) -> Type

get the type of an instance.

fn inner_ty(&self) -> Type

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