Struct Writer

pub struct Writer<W> {
    out: W,
    flags: WriterFlags,
    names: FastHashMap<NameKey, String>,
    namer: Namer,
    named_expressions: FastIndexMap<Handle<Expression>, String>,
    required_polyfills: FastIndexSet<InversePolyfill>,
}

Fields

out: W

flags: WriterFlags

names: FastHashMap<NameKey, String>

namer: Namer

named_expressions: FastIndexMap<Handle<Expression>, String>

required_polyfills: FastIndexSet<InversePolyfill>

Implementations

impl<W: Write> Writer<W>

pub fn new(out: W, flags: WriterFlags) -> Self

fn reset(&mut self, module: &Module)

fn is_builtin_wgsl_struct(&self, module: &Module, handle: Handle<Type>) -> bool

pub fn write(&mut self, module: &Module, info: &ModuleInfo) -> Result<(), Error>

fn write_enable_declarations(&mut self, module: &Module) -> Result<(), Error>

Helper method which writes all the enable declarations needed for a module.

fn write_function( &mut self, module: &Module, func: &Function, func_ctx: &FunctionCtx<'_>, ) -> Result<(), Error>

Helper method used to write functions

Notes

Ends in a newline

fn write_attributes(&mut self, attributes: &[Attribute]) -> Result<(), Error>

Helper method to write a attribute

fn write_enable_dual_source_blending_if_needed( &mut self, module: &Module, ) -> Result<(), Error>

Writes all the necessary directives out

fn write_struct( &mut self, module: &Module, handle: Handle<Type>, members: &[StructMember], ) -> Result<(), Error>

Helper method used to write structs Write the full declaration of a struct type.

Write out a definition of the struct type referred to by handle in module. The output will be an instance of the struct_decl production in the WGSL grammar.

Use members as the list of handle’s members. (This function is usually called after matching a TypeInner, so the callers already have the members at hand.)

fn write_type(&mut self, module: &Module, ty: Handle<Type>) -> Result<(), Error>

fn write_type_resolution( &mut self, module: &Module, resolution: &TypeResolution, ) -> Result<(), Error>

fn write_stmt( &mut self, module: &Module, stmt: &Statement, func_ctx: &FunctionCtx<'_>, level: Level, ) -> Result<(), Error>

Helper method used to write statements

Notes

Always adds a newline

fn plain_form_indirection( &self, expr: Handle<Expression>, module: &Module, func_ctx: &FunctionCtx<'_>, ) -> Indirection

Return the sort of indirection that expr’s plain form evaluates to.

An expression’s ‘plain form’ is the most general rendition of that expression into WGSL, lacking & or * operators:

• The plain form of LocalVariable(x) is simply x, which is a reference to the local variable’s storage.

• The plain form of GlobalVariable(g) is simply g, which is usually a reference to the global variable’s storage. However, globals in the Handle address space are immutable, and GlobalVariable expressions for those produce the value directly, not a pointer to it. Such GlobalVariable expressions are Ordinary.

• Access and AccessIndex are Reference when their base operand is a pointer. If they are applied directly to a composite value, they are Ordinary.

Note that FunctionArgument expressions are never Reference, even when the argument’s type is Pointer. FunctionArgument always evaluates to the argument’s value directly, so any pointer it produces is merely the value passed by the caller.

fn start_named_expr( &mut self, module: &Module, handle: Handle<Expression>, func_ctx: &FunctionCtx<'_>, name: &str, ) -> Result<(), Error>

fn write_expr( &mut self, module: &Module, expr: Handle<Expression>, func_ctx: &FunctionCtx<'_>, ) -> Result<(), Error>

Write the ordinary WGSL form of expr.

See write_expr_with_indirection for details.

fn write_expr_with_indirection( &mut self, module: &Module, expr: Handle<Expression>, func_ctx: &FunctionCtx<'_>, requested: Indirection, ) -> Result<(), Error>

Write expr as a WGSL expression with the requested indirection.

In terms of the WGSL grammar, the resulting expression is a singular_expression. It may be parenthesized. This makes it suitable for use as the operand of a unary or binary operator without worrying about precedence.

This does not produce newlines or indentation.

The requested argument indicates (roughly) whether Naga Pointer-valued expressions represent WGSL references or pointers. See Indirection for details.

fn write_const_expression( &mut self, module: &Module, expr: Handle<Expression>, arena: &Arena<Expression>, ) -> Result<(), Error>

fn write_possibly_const_expression<E>( &mut self, module: &Module, expr: Handle<Expression>, expressions: &Arena<Expression>, write_expression: E, ) -> Result<(), Error>

where E: Fn(&mut Self, Handle<Expression>) -> Result<(), Error>,

fn write_expr_plain_form( &mut self, module: &Module, expr: Handle<Expression>, func_ctx: &FunctionCtx<'_>, indirection: Indirection, ) -> Result<(), Error>

Write the ‘plain form’ of expr.

An expression’s ‘plain form’ is the most general rendition of that expression into WGSL, lacking & or * operators. The plain forms of LocalVariable(x) and GlobalVariable(g) are simply x and g. Such Naga expressions represent both WGSL pointers and references; it’s the caller’s responsibility to distinguish those cases appropriately.

fn write_global( &mut self, module: &Module, global: &GlobalVariable, handle: Handle<GlobalVariable>, ) -> Result<(), Error>

Helper method used to write global variables

Notes

Always adds a newline

fn write_global_constant( &mut self, module: &Module, handle: Handle<Constant>, ) -> Result<(), Error>

Helper method used to write global constants

Notes

Ends in a newline

pub fn finish(self) -> W