Struct cuicui_chirp::reflect::ReflectDsl

pub struct ReflectDsl<T: Struct, D: DslBundle = (), F: Format = RonFormat> { /* private fields */ }

Automatic ParseDsl implementation for any [Bundle] + [Reflect] struct.

If you find using the parse_dsl_impl macro burdensome, and just want to use any bevy Bundle as a DSL, you can use ReflectDsl to use the struct fields as DSL “methods”, and Reflect deserialization to parse the arguments automatically.

How to use

You have a type as follow:

use cuicui_chirp::ReflectDsl;

#[derive(Bundle, Reflect, Default)]
struct MyBundle {
    transform: Transform,
    visibility: Visibility,
}
// and you did register it with:
app.register_type::<MyBundle>();

You want to use it in a DSL when parsing files. Consider the following chirp file:

entity(row) {
    entity (
        transform (
           translation: (x: 0.0, y: 0.0, z: 0.0),
           rotation: (0.0, 0.0, 0.0, 1.0),
           scale: (x: 1.0, y: 1.0, z: 1.0),
         ),
         visibility Inherited,
    );
}

You want both LayoutDsl methods and fields of MyBundle to work in your chirp files.

In order to do that, you should add the loader for the correct DSL as follow:

use cuicui_chirp::ReflectDsl;

// Add `ReflectDsl<MyBundle, _>` as an extension on the `LayoutDsl` DSL.
type Dsl = ReflectDsl<MyBundle, LayoutDsl>;
app.add_plugins((
    // ...
    // The loader now recognizes the methods `transform` and `visibility`.
    // They were fields of `MyBundle`
    cuicui_chirp::loader::Plugin::new::<Dsl>(),
));

Caveats

This doesn’t work with the dsl! macro. You can only use ReflectDsl with scenes defined in chirp files.

Trait Implementations

impl<T: Clone + Struct, D: Clone + DslBundle, F: Clone + Format> Clone for ReflectDsl<T, D, F>

fn clone(&self) -> ReflectDsl<T, D, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Struct, D: Debug + DslBundle, F: Debug + Format> Debug for ReflectDsl<T, D, F>

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

Formats the value using the given formatter.

impl<T: Default + Struct, D: DslBundle, F: Format> Default for ReflectDsl<T, D, F>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Struct, D: DslBundle, F: Format> Deref for ReflectDsl<T, D, F>

type Target = D

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Struct, D: DslBundle, F: Format> DerefMut for ReflectDsl<T, D, F>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, D, F> DslBundle for ReflectDsl<T, D, F>where T: Bundle + Default + Struct, D: DslBundle, F: Format,

fn insert(&mut self, cmds: &mut EntityCommands<'_, '_, '_>)

Add given Bundle to the entity.

fn node( &mut self, cmds: &mut EntityCommands<'_, '_, '_>, f: impl FnOnce(&mut ChildBuilder<'_, '_, '_>) )

Spawn the entity as a parent of other entities.

impl<T, D, F> ParseDsl for ReflectDsl<T, D, F>where T: Bundle + Default + Struct, D: DslBundle, F: Format,

fn method(&mut self, ctx: MethodCtx<'_, '_, '_>) -> Result<()>

Apply method named name to self.