Struct naga::Module

pub struct Module {
    pub types: UniqueArena<Type>,
    pub special_types: SpecialTypes,
    pub constants: Arena<Constant>,
    pub overrides: Arena<Override>,
    pub global_variables: Arena<GlobalVariable>,
    pub global_expressions: Arena<Expression>,
    pub functions: Arena<Function>,
    pub entry_points: Vec<EntryPoint>,
}

Shader module.

A module is a set of constants, global variables and functions, as well as the types required to define them.

Some functions are marked as entry points, to be used in a certain shader stage.

To create a new module, use the Default implementation. Alternatively, you can load an existing shader using one of the available front ends.

When finished, you can export modules using one of the available backends.

Fields

types: UniqueArena<Type>

Arena for the types defined in this module.

special_types: SpecialTypes

Dictionary of special type handles.

constants: Arena<Constant>

Arena for the constants defined in this module.

overrides: Arena<Override>

Arena for the pipeline-overridable constants defined in this module.

global_variables: Arena<GlobalVariable>

Arena for the global variables defined in this module.

global_expressions: Arena<Expression>

Constant expressions and override expressions used by this module.

If an expression is in this arena, then its subexpressions are in this arena too. In other words, every Handle<Expression> in this arena refers to an Expression in this arena too.

Each Expression must occur in the arena before any Expression that uses its value.

functions: Arena<Function>

Arena for the functions defined in this module.

Each function must appear in this arena strictly before all its callers. Recursion is not supported.

entry_points: Vec<EntryPoint>

Entry points.

Implementations

impl Module

pub fn generate_ray_desc_type(&mut self) -> Handle<Type>

Populate this module’s SpecialTypes::ray_desc type.

SpecialTypes::ray_desc is the type of the descriptor operand of an Initialize RayQuery statement. In WGSL, it is a struct type referred to as RayDesc.

Backends consume values of this type to drive platform APIs, so if you change any its fields, you must update the backends to match. Look for backend code dealing with RayQueryFunction::Initialize.

pub fn generate_ray_intersection_type(&mut self) -> Handle<Type>

Populate this module’s SpecialTypes::ray_intersection type.

SpecialTypes::ray_intersection is the type of a RayQueryGetIntersection expression. In WGSL, it is a struct type referred to as RayIntersection.

Backends construct values of this type based on platform APIs, so if you change any its fields, you must update the backends to match. Look for the backend’s handling for Expression::RayQueryGetIntersection.

pub fn generate_predeclared_type( &mut self, special_type: PredeclaredType, ) -> Handle<Type>

Populate this module’s SpecialTypes::predeclared_types type and return the handle.

impl Module

pub const fn to_ctx(&self) -> GlobalCtx<'_>

Trait Implementations

impl Clone for Module

fn clone(&self) -> Module

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Module

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

Formats the value using the given formatter.

impl Default for Module

fn default() -> Module

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Module

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Module

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

where __S: Serializer,

Serialize this value into the given Serde serializer.