Enum Constant 

pub enum Constant<'a> {
    Bool(bool),
    Constant(Literal),
    Composite {
        ty: Id,
        constituents: &'a [Id],
    },
    Sampler {
        addressing_mode: SamplerAddressingMode,
        is_normalized: bool,
        filter_mode: SamplerFilterMode,
    },
    Null {
        ty: Id,
    },
    SpecBool(bool),
    SpecConstant(Literal),
    SpecConstantComposite {
        ty: Id,
        constituents: &'a [Id],
    },
    SpecConstantOp {
        ty: Id,
        opcode: Code,
        operands: &'a [Id],
    },
}

Represents an constant value.

Variants

Bool(bool)

A non-specialization constant boolean.

Constant(Literal)

A non-specialization constant.

Composite

A non-specialization constant composite.

Fields

ty: Id

The type Id of the composite type.

constituents: &'a [Id]

The constituents of composite value.

Sampler

A constant sampler.

Fields

addressing_mode: SamplerAddressingMode

The addressing mode of the sampler.

is_normalized: bool

Whether the sampler uses normalized coordinates.

filter_mode: SamplerFilterMode

The filter mode of the sampler.

Null

A null value.

Fields

ty: Id

The type Id of the null value.

SpecBool(bool)

A specialization constant boolean.

SpecConstant(Literal)

A specialization constant.

SpecConstantComposite

A specialization constant composite.

Fields

ty: Id

The type Id of the composite type.

constituents: &'a [Id]

The constituents of the composite value.

SpecConstantOp

A specialization constant operation.

Fields

ty: Id

The resultant type Id of the operation.

opcode: Code

The code specifying the operation.

operands: &'a [Id]

The operands of the operation.

Trait Implementations

impl<'a> Clone for Constant<'a>

fn clone(&self) -> Constant<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Constant<'a>

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

Formats the value using the given formatter.

impl<'a> Copy for Constant<'a>