Struct bevy_hanabi::graph::expr::ExprWriter

pub struct ExprWriter { /* private fields */ }

Expression writer.

Utility to write expressions with a simple functional syntax. Expressions created with the writer are gatherned into a Module which can be transfered once finish()ed to initialize an EffectAsset.

Because an EffectAsset contains a single Module, you generally want to keep using the same ExprWriter to write all the expressions used by all the Modifers assigned to a given EffectAsset, and only then once done call finish() to recover the ExprWriter’s underlying Module to assign it to the EffectAsset.

Example

// Create a writer
let w = ExprWriter::new();

// Create a new expression: max(5. + particle.position, properties.my_prop)
let expr = (w.lit(5.) + w.attr(Attribute::POSITION)).max(w.prop("my_prop"));

// Finalize the expression and write it down into the `Module` as an `Expr`
let expr: ExprHandle = expr.expr();

// Create a modifier and assign the expression to one of its input(s)
let init_modifier = SetAttributeModifier::new(Attribute::LIFETIME, expr);

// Create an EffectAsset with the modifier and the Module from the writer
let effect = EffectAsset::new(1024, Spawner::rate(32_f32.into()), w.finish())
    .init(init_modifier);

Implementations

impl ExprWriter

pub fn new() -> Self

Create a new writer.

The writer owns a new Module internally, and write all expressions to it. The module can be released to the user with finish() once done using the writer.

pub fn from_module(module: Rc<RefCell<Module>>) -> Self

Create a new writer from an existing module.

This is an advanced use entry point to write expressions into an existing Module. In general, users should prefer using ExprWriter::new() to create a new Module, and keep using the same ExprWriter to write all expressions of the same EffectAsset.

pub fn push(&self, expr: impl Into<Expr>) -> WriterExpr

Push a new expression into the writer.

pub fn lit(&self, value: impl Into<Value>) -> WriterExpr

Create a new writer expression from a literal constant.

Example

let mut w = ExprWriter::new();
let x = w.lit(-3.5); // x = -3.5;

pub fn attr(&self, attr: Attribute) -> WriterExpr

Create a new writer expression from an attribute.

Example

let mut w = ExprWriter::new();
let x = w.attr(Attribute::POSITION); // x = particle.position;

pub fn prop(&self, name: impl Into<String>) -> WriterExpr

Create a new writer expression from a property.

Example

let mut w = ExprWriter::new();
let x = w.prop("my_prop"); // x = properties.my_prop;

pub fn time(&self) -> WriterExpr

Create a new writer expression representing the current simulation time.

Example

let mut w = ExprWriter::new();
let x = w.time(); // x = sim_params.time;

pub fn delta_time(&self) -> WriterExpr

Create a new writer expression representing the simulation delta time since last frame.

Example

let mut w = ExprWriter::new();
let x = w.delta_time(); // x = sim_params.delta_time;

pub fn rand(&self, value_type: impl Into<ValueType>) -> WriterExpr

Create a new writer expression representing a random value of the given type.

The type can be any scalar or vector type. Matrix types are not supported. The random values generated are uniformly distributed in [0:1]. For vectors, each component is sampled separately.

Panics

Panics in the same cases as BuiltInExpr::new() does.

Example

let mut w = ExprWriter::new();
let x = w.rand(VectorType::VEC3F); // x = frand3();

pub fn alpha_cutoff(&self) -> WriterExpr

Create a new writer expression representing the alpha cutoff value used for alpha masking.

This expression is only valid when used in the context of the fragment shader, in the render context.

Example

let mut w = ExprWriter::new();
let x = w.alpha_cutoff(); // x = alpha_cutoff;

pub fn finish(self) -> Module

Finish using the writer, and recover the Module where all Expr were written by the writer.

This module is typically passed to EffectAsset::new() before adding to that effect the modifiers which use the expressions created by this writer.

Example

let mut w = ExprWriter::new();
// [...]
let module = w.finish();
let asset = EffectAsset::new(256, spawner, module);

Trait Implementations

impl Clone for ExprWriter

fn clone(&self) -> ExprWriter

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExprWriter

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

Formats the value using the given formatter.

impl Default for ExprWriter

fn default() -> ExprWriter

Returns the “default value” for a type.