Avian 0.4, Easier Profiling, and Logging improvements

With the release of getrandom v0.3.4, which fixes Web WASM builds to no longer need --cfg getrandom_backend, a patch fix to bevy_rand was released to pin getrandom to that version upwards, so building Bevy + bevy_rand for Web will be much easier now. As it is a patch update, just run cargo update and you are gucci!

crates.io docs.rs

meta_merge is intended to create sets of macro attributes you can use as a "template" and apply them across many items.

use meta_merge::*;
use bevy::prelude::*;
use serde::{Deserialize, Serialize};
use serde_json::json;

#[export(merge)]
#[derive(Component, Reflect)]
#[reflect(Component)]
struct DefaultComponent;

#[export(merge)]
#[derive(Debug, Serialize, Deserialize)]
struct DefaultSerializable;

#[apply(MergeDefaultSerializable!)]
#[apply(MergeDefaultComponent!)]
#[derive(PartialEq)]
struct FooComponent {
    a: u32,
    b: String,
    c: bool,
}

#[test]
fn foo_component_should_deserialize() {
    assert_eq!(
        serde_json::from_value(json!({
            "a": 1,
            "b": "foo",
            "c": true,
        }))
        .map_err(|e| e.to_string()),
        Ok(FooComponent {
            a: 1,
            b: "foo".to_string(),
            c: true,
        }),
    );
}

Lightyear is a full-featured networking library for bevy

v0.25 is a big release with a few sizeable breaking changes

• Predicted/Interpolated/Confirmed have been merged: the replication updates are now received directly on the Predicted or Interpolated entity.

• PreSpawned can be used outside of Prediction

• Improve BevyEnhancedInput handling: input rebroadcasting now works properly with BEI, and BEI inputs consume a LOT less bandwidth

• Projectile replication example: a new example showcasing various ways of doing projectile replication for FPS games

For more information, you should check out:

• the release notes
• the examples
• the tutorial

Avian is an ECS-driven physics engine for Bevy.

v0.4 is the biggest release yet, with several new features, quality-of-life improvements, and bug fixes. Highlights include:

• Massive performance improvements: Avian is 3x as fast as before, with much better scaling for multi-core hardware.
  • Solver bodies: The solver stores bodies in a much more efficient format optimized for cache locality and future wide SIMD support.
  • Graph coloring: The constraint solver is now multi-threaded with graph coloring.
  • Simulation islands: Islands are used for a much improved sleeping and waking system, reducing overhead for large game worlds with many resting bodies.
• Force overhaul: The force and impulse APIs have been redesigned from the ground up, providing a much more capable and intuitive interface.
• Joint improvements: Joints now support full reference frames (anchor + basis), and have new JointDamping and JointForces components.
• Voxel colliders: Avian now supports voxel colliders for efficient representation of Minecraft-like worlds and other volumetric data.
• Bevy 0.17 support: Avian has been updated to the latest version of Bevy, and has changed its collision event types and system set naming to match.
• Contact API improvements: Contact data now provides access to world-space points, normal speeds, and more accurate contact impulses.
• Benchmarking CLI: Avian has a new CLI tool for benchmarking various scenes and profiling multi-threaded scaling.

Check out the announcement blog post for a more in-depth overview of what has changed and why. A changelog and migration guide can be found on GitHub.

Sometimes, Glam's matrix types are not enough. glam_matrix_extras aims to address this by implementing various additional matrix types and utilities, such as dedicated symmetric matrices, rectangular matrices, and 2x2 and 3x3 Eigen decompositions. These are already being used in Avian and bevy_heavy, and more will be added as use cases arise (ex: dynamically sized matrices a la Nalgebra for multi-body joints requiring higher degrees of freedom).