Enum naga::TypeInner

pub enum TypeInner {
    Scalar {
        kind: ScalarKind,
        width: Bytes,
    },
    Vector {
        size: VectorSize,
        kind: ScalarKind,
        width: Bytes,
    },
    Matrix {
        columns: VectorSize,
        rows: VectorSize,
        width: Bytes,
    },
    Atomic {
        kind: ScalarKind,
        width: Bytes,
    },
    Pointer {
        base: Handle<Type>,
        class: StorageClass,
    },
    ValuePointer {
        size: Option<VectorSize>,
        kind: ScalarKind,
        width: Bytes,
        class: StorageClass,
    },
    Array {
        base: Handle<Type>,
        size: ArraySize,
        stride: u32,
    },
    Struct {
        members: Vec<StructMember>,
        span: u32,
    },
    Image {
        dim: ImageDimension,
        arrayed: bool,
        class: ImageClass,
    },
    Sampler {
        comparison: bool,
    },
}

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

Variants

Scalar

Fields

kind: ScalarKind

width: Bytes

Number of integral or floating-point kind.

Vector

Fields

size: VectorSize

kind: ScalarKind

width: Bytes

Vector of numbers.

Matrix

Fields

columns: VectorSize

rows: VectorSize

width: Bytes

Matrix of floats.

Atomic

Fields

kind: ScalarKind

width: Bytes

Atomic scalar.

Pointer

Fields

base: Handle<Type>

class: StorageClass

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.

ValuePointer

Fields

size: Option<VectorSize>

kind: ScalarKind

width: Bytes

class: StorageClass

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.

Array

Fields

base: Handle<Type>

size: ArraySize

stride: u32

Homogenous 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 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.

Struct

Fields

members: Vec<StructMember>

span: u32

User-defined structure.

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.

Image

Fields

dim: ImageDimension

arrayed: bool

class: ImageClass

Possibly multidimensional array of texels.

Sampler

Fields

comparison: bool

Can be used to sample values from images.

Implementations

impl TypeInner

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

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 fn scalar_kind(&self) -> Option<ScalarKind>

pub fn pointer_class(&self) -> Option<StorageClass>

pub fn span(&self, constants: &Arena<Constant>) -> u32

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

Return the canoncal 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 ==.

Trait Implementations

impl Debug for TypeInner

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TypeInner

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

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, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<TypeInner> for TypeInner

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Serialize for TypeInner

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl Eq for TypeInner

impl StructuralEq for TypeInner

impl StructuralPartialEq for TypeInner