Required Components, Curves, and the Bevy CLI Working Group

Welcome back to This Week in Bevy!

This week we've got some great progress on Scenes/UI work with Required Components merging, a new Bevy CLI working group, and some great progress in the Curves group.

We've also got some exciting crate releases including an official bevy_magic_light_2d crates.io release and a new Avian Pickup plugin for portal-like shenanigans.

Required Components

Required Components is part of the recent Scenes/bsn! work and has been merged! This has a huge impact on Bundle use cases, although Bundles have not gone anywhere. (note: do not worry, the team is putting great thought into how these APIs will evolve and this is the beginning work, not the end-state).

Required Components show up in end-user APIs as a require attribute macro on Components.

#[require(Node, UiImage)]

As is common when talking about work that was just merged, Required Components are a beginning step in the Next Generation Scene / UI Proposal so expect further work in this area before official release.

The most succinct way I've seen to show the difference Required Component makes is to show the impact on an existing bundle, like the ButtonBundle.

#[derive(Component)]
#[require(Node, UiImage)]
struct Button;

commands.spawn((
    Button,
    Style { 
        width: Val::Px(100.0),
        height: Val::Px(50.0),
        ..default()
    },
    FocusPolicy::Block,
));

Note that generally, required components are for invariants. That is, additional components that the component in question does not work without. This is especially relevant when considering library code but it is worth noting that as with any new functionality, the lines are still being drawn.

Meshlet software raster

meshlet debug output overlaid on a rendered scene

Meshlets see improvements in #14623, which includes work towards faster meshlet rasterization path for small triangles, avoiding having to allocate and write out a triangle buffer, and more. The PR is wonderfully documented and includes technical details for changes.

The MeshletPlugin now comes with a cluster_buffer_slots

MeshletPlugin {
    cluster_buffer_slots: 8192,
}

The rough tldr; on cluster_buffer_slots is that it needs to be set to the worst case amount of clusters per pass in your scene over all cameras, which is a number that can obviously vary per-user. If you get the number wrong (as in, too low), you'll notice missing or flickering areas.

Observers

Debug for Trigger

#14857 introduces a Debug implementation for Trigger, which enables a more streamlined developer experience when debugging scaffolded Observers.

.observe(|e: Trigger<OnAdd, Skeleton>| {
    dbg!(e);
});

The output includes the event information, propagation, and ObserverTrigger.

on_add_mine: Trigger {
    event: OnAdd,
    propagate: false,
    trigger: ObserverTrigger {
        observer: 2v1#4294967298,
        event_type: ComponentId(
            0,
        ),
        entity: 454v1#4294967750,
    },
    _marker: PhantomData<observers::Mine>,
}

on_unimplemented for IntoObserverSystem

Observer systems must have a Trigger as their first argument and in #14840 the error message when this isn't the case includes a reminder.

for function ObserverSystems, ensure the first argument is a Trigger<T> and any subsequent ones are SystemParam

The Type type

#14838 introduces the Type struct to bevy_reflect. This type contains both the TypeId and the TypePathTable of the given type, allowing it to be used like TypeId but have the debugging capacity of TypePath.

Screenshots

As of #14833, screenshots can now use any RenderTarget and have a new Component-and-Observer-based API.

use bevy_render::view::screenshot::{save_to_disk, Screenshot};

commands
    .spawn(Screenshot::primary_window())
    .observe(save_to_disk(path));

New Run Conditions

In #14917 two new Conditions were introduced including:

• condition_changed, which changes whenever the inner condition changes
• condition_changed_to, which returns true whenever the inner condition changes to match true or false, depending on user configuration

Plane3d Gizmo updates

As of #14650 the Plane3d primitive gizmo now displays as a grid to better show the existence of a plane. Previously it was axes which had some issues when trying to view distant or off-axis plane locations.

gizmos
    .primitive_3d(
        &Plane3d {
            normal: Dir3::Y,
            half_size: Vec2::splat(1.0),
        },
        Isometry3d::new(
            Vec3::ONE * 4.0 + Vec2::from(time.elapsed_seconds().sin_cos()).extend(0.0),
            Quat::from_rotation_x(PI / 2. + time.elapsed_seconds()),
        ),
        GREEN,
    )
    .cell_count(UVec2::new(5, 10))
    .spacing(Vec2::new(0.2, 0.1));

Binary Size Reductions

#14865 is a GitHub Discussion that takes a look at generic/monomorphized code to see where there could be some savings in final binary size by moving some code around without changing existing APIs. #14865 is the first follow up on this research by splitting GenericTypeCell::get_or_insert up.

This work results in a 2% size reduction (approx 428KiB) of the final binary when building the 3d_scene example.

Further work is happening in #14934 which is seeing even more improvements already (which we'll cover in the future when/if it merges).

atomicow

#11478 details the desire to shrink the bevy_utils crate and put the functionality inside it in better places. As part of this, CowArc was moved to the new, generally usable outside Bevy, atomicow crate and its usage inside Bevy was replaced with the new crate in #14975.

CowArc is an enum that represents owned, borrowed, or static data, that is: cheap immutable references that can be converted into an owned form when mutation or ownership is required.

pub enum CowArc<'a, T: ?Sized + 'static> {
    Borrowed(&'a T),
    Static(&'static T),
    Owned(Arc<T>),
}

IMO: It should really have an atomic cow logo... :laughing:

Working Groups

bevy_mod_picking: the upstreamening

#14757 adds a sprite backend to the upstreamed bevy_picking and adds a new example in examples/picking/sprite_picking.rs showing off the functionality. Go click some bevy birds!

Curve Crew

New curve gizmos have been added for 2d and 3d in #14971 based on the previous bevy_math Curve work.

As of #14815 you can now sample curves from IntoIterator types. This allows sampling a curve at specific times t.

let times = [-0.5, 0.0, 0.5, 1.0, 1.5];

let finite_curve = function_curve(Interval::new(0.0, 1.0).unwrap(), |t| t * 3.0 + 1.0);
let samples = finite_curve.sample_iter(times).collect::<Vec<_>>();
let [y0, y1, y2, y3, y4] = samples.try_into().unwrap();

assert_eq!(y0, None);
assert_eq!(y1, Some(0.0 * 3.0 + 1.0));
assert_eq!(y2, Some(0.5 * 3.0 + 1.0));
assert_eq!(y3, Some(1.0 * 3.0 + 1.0));
assert_eq!(y4, None);

bevy_cli: please clap

A new working group dedicated to building a Bevy CLI has been created! The working group's initial scope can be found on hackmd and includes a bunch of relevant information. Give it a read if you're interested in what a Bevy CLI might look like!

The working group's discussions can be found in the official Bevy Discord, as can be all of the other working groups.

Alice's Merge Train is a maintainer-level view into active PRs, both those that are merging and those that need work.