Enum naga::TypeInner

pub enum TypeInner {
    Scalar(Scalar),
    Vector {
        size: VectorSize,
        scalar: Scalar,
    },
    Matrix {
        columns: VectorSize,
        rows: VectorSize,
        scalar: Scalar,
    },
    Atomic(Scalar),
    Pointer {
        base: Handle<Type>,
        space: AddressSpace,
    },
    ValuePointer {
        size: Option<VectorSize>,
        scalar: Scalar,
        space: AddressSpace,
    },
    Array {
        base: Handle<Type>,
        size: ArraySize,
        stride: u32,
    },
    Struct {
        members: Vec<StructMember>,
        span: u32,
    },
    Image {
        dim: ImageDimension,
        arrayed: bool,
        class: ImageClass,
    },
    Sampler {
        comparison: bool,
    },
    AccelerationStructure,
    RayQuery,
    BindingArray {
        base: Handle<Type>,
        size: ArraySize,
    },
}

Enum with additional information, depending on the kind of type.

Variants

Scalar(Scalar)

Number of integral or floating-point kind.

Vector

Vector of numbers.

Fields

size: VectorSize

scalar: Scalar

Matrix

Matrix of numbers.

Fields

columns: VectorSize

rows: VectorSize

scalar: Scalar

Atomic(Scalar)

Atomic scalar.

Pointer

Pointer to another type.

Pointers to scalars and vectors should be treated as equivalent to ValuePointer types. Use the TypeInner::equivalent method to compare types in a way that treats pointers correctly.

Pointers to non-SIZED types

The base type of a pointer may be a non-SIZED type like a dynamically-sized Array, or a Struct whose last member is a dynamically sized array. Such pointers occur as the types of GlobalVariable or AccessIndex expressions referring to dynamically-sized arrays.

However, among pointers to non-SIZED types, only pointers to Structs are DATA. Pointers to dynamically sized Arrays cannot be passed as arguments, stored in variables, or held in arrays or structures. Their only use is as the types of AccessIndex expressions.

Fields

base: Handle<Type>

space: AddressSpace

ValuePointer

Pointer to a scalar or vector.

A ValuePointer type is equivalent to a Pointer whose base is a Scalar or Vector type. This is for use in TypeResolution::Value variants; see the documentation for TypeResolution for details.

Use the TypeInner::equivalent method to compare types that could be pointers, to ensure that Pointer and ValuePointer types are recognized as equivalent.

Fields

size: Option<VectorSize>

scalar: Scalar

space: AddressSpace

Array

Homogeneous list of elements.

The base type must be a SIZED, DATA type.

Dynamically sized arrays

An Array is SIZED unless its size is Dynamic. Dynamically-sized arrays may only appear in a few situations:

• They may appear as the type of a GlobalVariable, or as the last member of a Struct.

• They may appear as the base type of a Pointer. An AccessIndex expression referring to a struct’s final unsized array member would have such a pointer type. However, such pointer types may only appear as the types of such intermediate expressions. They are not DATA, and cannot be stored in variables, held in arrays or structs, or passed as parameters.

Fields

base: Handle<Type>

size: ArraySize

stride: u32

Struct

User-defined structure.

There must always be at least one member.

A Struct type is DATA, and the types of its members must be DATA as well.

Member types must be SIZED, except for the final member of a struct, which may be a dynamically sized Array. The Struct type itself is SIZED when all its members are SIZED.

Fields

members: Vec<StructMember>

span: u32

Image

Possibly multidimensional array of texels.

Fields

dim: ImageDimension

arrayed: bool

class: ImageClass

Sampler

Can be used to sample values from images.

Fields

comparison: bool

AccelerationStructure

Opaque object representing an acceleration structure of geometry.

RayQuery

Locally used handle for ray queries.

BindingArray

Array of bindings.

A BindingArray represents an array where each element draws its value from a separate bound resource. The array’s element type base may be Image, Sampler, or any type that would be permitted for a global in the Uniform or Storage address spaces. Only global variables may be binding arrays; on the host side, their values are provided by TextureViewArray, SamplerArray, or BufferArray bindings.

Since each element comes from a distinct resource, a binding array of images could have images of varying sizes (but not varying dimensions; they must all have the same Image type). Or, a binding array of buffers could have elements that are dynamically sized arrays, each with a different length.

Binding arrays are in the same address spaces as their underlying type. As such, referring to an array of images produces an Image value directly (as opposed to a pointer). The only operation permitted on BindingArray values is indexing, which works transparently: indexing a binding array of samplers yields a Sampler, indexing a pointer to the binding array of storage buffers produces a pointer to the storage struct.

Unlike textures and samplers, binding arrays are not ARGUMENT, so they cannot be passed as arguments to functions.

Naga’s WGSL front end supports binding arrays with the type syntax binding_array<T, N>.

Fields

base: Handle<Type>

size: ArraySize

Implementations

impl TypeInner

pub const fn is_handle(&self) -> bool

Returns true if this is a handle to a type rather than the type directly.

impl TypeInner

fn automatically_converts_to( &self, goal: &Self, types: &UniqueArena<Type>, ) -> Option<(Scalar, Scalar)>

Determine whether self automatically converts to goal.

If WGSL’s automatic conversions (excluding the Load Rule) will convert self to goal, then return a pair (from, to), where from and to are the scalar types of the leaf values of self and goal.

This function assumes that self and goal are different types. Callers should first check whether any conversion is needed at all.

If the automatic conversions cannot convert self to goal, return None.

fn automatically_convertible_scalar( &self, types: &UniqueArena<Type>, ) -> Option<Scalar>

impl TypeInner

pub fn to_wgsl(&self, gctx: &GlobalCtx<'_>) -> String

Formats the type as it is written in wgsl.

For example vec3<f32>.

Note: TypeInner::Struct doesn’t include the name of the struct type. Therefore this method will simply return “struct” for them.

impl TypeInner

pub fn indexable_length( &self, module: &Module, ) -> Result<IndexableLength, IndexableLengthError>

Return the length of a subscriptable type.

The self parameter should be a handle to a vector, matrix, or array type, a pointer to one of those, or a value pointer. Arrays may be fixed-size, dynamically sized, or sized by a specializable constant. This function does not handle struct member references, as with AccessIndex.

The value returned is appropriate for bounds checks on subscripting.

Return an error if self does not describe a subscriptable type at all.

impl TypeInner

pub const fn scalar(&self) -> Option<Scalar>

Return the scalar type of self.

If inner is a scalar, vector, or matrix type, return its scalar type. Otherwise, return None.

pub fn scalar_kind(&self) -> Option<ScalarKind>

pub fn scalar_width(&self) -> Option<u8>

Returns the scalar width in bytes

pub const fn pointer_space(&self) -> Option<AddressSpace>

pub fn is_atomic_pointer(&self, types: &UniqueArena<Type>) -> bool

pub fn size(&self, _gctx: GlobalCtx<'_>) -> u32

Get the size of this type.

pub fn canonical_form(&self, types: &UniqueArena<Type>) -> Option<TypeInner>

Return the canonical form of self, or None if it’s already in canonical form.

Certain types have multiple representations in TypeInner. This function converts all forms of equivalent types to a single representative of their class, so that simply applying Eq to the result indicates whether the types are equivalent, as far as Naga IR is concerned.

pub fn equivalent(&self, rhs: &TypeInner, types: &UniqueArena<Type>) -> bool

Compare self and rhs as types.

This is mostly the same as <TypeInner as Eq>::eq, but it treats ValuePointer and Pointer types as equivalent.

When you know that one side of the comparison is never a pointer, it’s fine to not bother with canonicalization, and just compare TypeInner values with ==.

pub fn is_dynamically_sized(&self, types: &UniqueArena<Type>) -> bool

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

pub fn component_type(&self, index: usize) -> Option<TypeResolution>

impl TypeInner

const fn is_sized(&self) -> bool

const fn image_storage_coordinates(&self) -> Option<ImageDimension>

Return the ImageDimension for which self is an appropriate coordinate.

Trait Implementations

impl Clone for TypeInner

fn clone(&self) -> TypeInner

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TypeInner

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

Formats the value using the given formatter.

impl Hash for TypeInner

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TypeInner

fn eq(&self, other: &TypeInner) -> 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 Eq for TypeInner

impl StructuralPartialEq for TypeInner