pub enum TypeInner {
Show 13 variants
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,
},
}
Expand description
Enum with additional information, depending on the kind of type.
Variants§
Scalar(Scalar)
Number of integral or floating-point kind.
Vector
Vector of numbers.
Matrix
Matrix of numbers.
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 Struct
s
are DATA
. Pointers to dynamically sized Array
s 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
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
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 aStruct
. -
They may appear as the base type of a
Pointer
. AnAccessIndex
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 notDATA
, and cannot be stored in variables, held in arrays or structs, or passed as parameters.
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
.
Image
Possibly multidimensional array of texels.
Sampler
Can be used to sample values from images.
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>
.
Implementations§
source§impl TypeInner
impl TypeInner
sourcepub fn indexable_length(
&self,
module: &Module
) -> Result<IndexableLength, IndexableLengthError>
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.
source§impl TypeInner
impl TypeInner
sourcepub const fn scalar(&self) -> Option<Scalar>
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>
sourcepub fn scalar_width(&self) -> Option<u8>
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
sourcepub fn canonical_form(&self, types: &UniqueArena<Type>) -> Option<TypeInner>
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.
sourcepub fn equivalent(&self, rhs: &TypeInner, types: &UniqueArena<Type>) -> bool
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>
Trait Implementations§
source§impl PartialEq for TypeInner
impl PartialEq for TypeInner
impl Eq for TypeInner
impl StructuralPartialEq for TypeInner
Auto Trait Implementations§
impl Freeze for TypeInner
impl RefUnwindSafe for TypeInner
impl Send for TypeInner
impl Sync for TypeInner
impl Unpin for TypeInner
impl UnwindSafe for TypeInner
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.