Struct ProgrammableStageDescriptor 

pub struct ProgrammableStageDescriptor<'a, SM = ShaderModuleId> {
    pub module: SM,
    pub entry_point: Option<Cow<'a, str>>,
    pub constants: PipelineConstants,
    pub zero_initialize_workgroup_memory: bool,
}

Describes a programmable pipeline stage.

Fields

module: SM

The compiled shader module for this stage.

entry_point: Option<Cow<'a, str>>

The name of the entry point in the compiled shader. The name is selected using the following logic:

• If Some(name) is specified, there must be a function with this name in the shader.
• If a single entry point associated with this stage must be in the shader, then proceed as if Some(…) was specified with that entry point’s name.

constants: PipelineConstants

Specifies the values of pipeline-overridable constants in the shader module.

If an @id attribute was specified on the declaration, the key must be the pipeline constant ID as a decimal ASCII number; if not, the key must be the constant’s identifier name.

The value may represent any of WGSL’s concrete scalar types.

zero_initialize_workgroup_memory: bool

Whether workgroup scoped memory will be initialized with zero values for this stage.

This is required by the WebGPU spec, but may have overhead which can be avoided for cross-platform applications

Trait Implementations

impl<'a, SM: Clone> Clone for ProgrammableStageDescriptor<'a, SM>

fn clone(&self) -> ProgrammableStageDescriptor<'a, SM>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, SM: Debug> Debug for ProgrammableStageDescriptor<'a, SM>

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

Formats the value using the given formatter.

impl<'de, 'a, SM> Deserialize<'de> for ProgrammableStageDescriptor<'a, SM>

where SM: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, SM> Serialize for ProgrammableStageDescriptor<'a, SM>

where SM: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.