Cyberpunk UI, Minecraft simulation, and volumetric destruction

Integrating Bevy and Wry to render webviews inside of Bevy apps.

This is an interesting approach that has been prototyped a few times going back at least 6 months since Tauri and Wry gained the ability to render multiple windows in one and interact via HasWindowHandle. Tauri has an official example of this kind of approach and so does wry.

BobbinBear is a bevy powered machine embroidery file editor primarily targeting the web. There's a lot planned for the future of this project.

quartz is a visual programming and dsp playground. This demo is called "grace" and as usual, includes audio so click through to the YouTube video to hear it.

This demo mimics the Hades 1 start menu using regular bevy_ui. Starting the game shows 3d rendered 8-directional character animations from Blender on top of an isometric level built with Tiled and integrated with bevy_ecs_tilemap. Interaction in the world happens via sensors, colliders, and raycasting from bevy_xpbd_2d. The world and character art are blockouts and will be replaced in the future.

A toon water shader based on a Unity tutorial's implementation.

First version of the personality system of ⁠To Build a Home, based on the Big Five model of personality. Characters have five personality traits, subdivided in thirty sub-traits, that define their mood, decisions, wants, needs, etc. The text on the screenshot is generated dynamically based on the sub-traits of the character.

These rocks are being created as volumetric shapes, divided into a voronoise-influenced grid, and re-meshed using a surface nets algorithm. The application is for a realistic mining game.

bevypunk is a recreation of Cyberpunk UI in Bevy using bevy_lunex: a path based retained layout engine.

This demo makes use of a brand new crate vleue_kinetoscope which is responsible for loading and playing gifs.

This puzzle platformer expects you to interact with the world via a command line interface.

An SDF fragment shader experiment. The code is fairly compact and more is included in the Discord thread

@fragment
fn fragment(mesh: VertexOutput)
  -> @location(0) vec4<f32> {
    let d = length(mesh.uv) - 0.5;
    let a = abs(sin(d * 3.14159));
    if (0.0 < d) {
        discard;
    } else {
      return vec4f(
  mesh.uv * mesh.uv * a * min(1/d * 1/d, 100.0),
	 0,
	 1
      );
    }
}

Converting GLTF files, such as those exported from Blender, to Bevy MeshletMeshs can make it easier to use the experimental meshlets feature. This demo is a demonstration of an early version of this processing work.

This demo is related to PR #13431

bevy_reactor's reflective property inspector widget now uses the new bevy_reflect custom attributes feature to specify the min/max value for numeric fields, as well as the number of decimal digits shown and the step size. This enables building a slider widget for editing f32 fields. A new SpinBox widget can be used to edit Vec3 fields. Spinboxes are used when a numeric field has no min/max constraint, or where there isn't enough space to put a slider.

Available macro attributes include @ValueRange, @Precision, and @Step with more to come and there's lots more information in the Discord thread.

#[derive(Resource, Debug, Reflect, Clone, Default)]
pub struct TestStruct {
    pub selected: bool,

    #[reflect(@ValueRange::<f32>(0.0..1.0))]
    pub scale: f32,

    pub color: Srgba,
    pub position: Vec3,
    pub unlit: Option<bool>,

    #[reflect(@ValueRange::<f32>(0.0..10.0))]
    pub roughness: Option<f32>,

    #[reflect(@Precision(2))]
    pub metalness: Option<f32>,

    #[reflect(@ValueRange::<f32>(0.0..1000.0))]
    pub factors: Vec<f32>,
}

Starfell is a game where you build your own community on a tiny planet. You will be able to construct houses, collect resources, interact with NPCs, and take on enemies and big bosses.

This update redesigns the pine trees, improves various aspects of foliage, and invests in some infrastructure and refactoring.

There's an older movement demo on YouTube.

This WIP project is about 1k lines of Rust/WGSL that shows off some very cool gpu-driven particle trails.

3d pixel art generated by using a post-process shader to draw outlines and rendering at a low resolution then scaling up.

This author's first steps with Rust and Bevy included making their own console implementation with fuzzy search.

This demo is simulating a Minecraft settlement in Bevy and then rendering it in Minecraft for GenDesignMC 2024.

As the simulation runs, each tick's changes get written to NBT, and at the end a datapack is generated that reads the NBT and replays it.

bevy_flurx provides a mechanism for more sequential description of delays, character movement, waiting for user input, and other state waits.

wry is the cross-platform WebView rendering library used by Tauri.

This demo (and associated GitHub repo) is a simple prototype integrating Bevy and Wry using bevy_flurx.