Engine Architecture Guides

[stefnotch]

https://bevy-cheatbook.github.io/introduction.html

[stefnotch]

Bevy Query notes

• https://www.reddit.com/r/bevy/comments/u6of27/how_does_bevy_know_what_arguments_your_function/
• https://nickbryan.co.uk/software/using-a-type-map-for-dependency-injection-in-rust/
• https://www.reddit.com/r/rust/comments/p9lkt6/how_does_bevys_res_query_or_actixs_data_actually/
• https://blog.logrocket.com/rust-bevy-entity-component-system/

[stefnotch]

ECS

• https://github.com/leudz/shipyard
• https://github.com/Ralith/hecs
• awe no variadic generics https://www.reddit.com/r/rust/comments/hy3v2s/simulate_variadic_generics/

[stefnotch]

Rust hurting my brain

// https://www.reddit.com/r/rust/comments/tdrrop/which_heterogenous_list_generic_tuple_library/

fn test() {
    let query = (H, (H, Null));
    let nully = query.gib();
    let e = query.0;
}

trait HList {
    type Output;
    // Define whatever fns you need here.
    // In my experience you usually want to operate on all values of your HList recursively.
    fn gib(&self) -> Self::Output;
}

// This is your "base case", an empty HList.
struct Null;

impl HList for Null {
    type Output = ();
    // Implement your fns with a simple base case implementation.
    fn gib(&self) -> Self::Output {
        ()
    }
}

// This is the "recursive case", defining variable length lists.
impl<H, T> HList for (H, T)
where
    T: HList,
    H: Cat,
{
    type Output = (H::Output, T::Output);
    // Implement your fns, often calling the same fn on `T`.
    // This allows you to recursively operate on your list.
    fn gib(&self) -> Self::Output {
        (self.0.gib_value(), self.1.gib())
    }
}

struct H;
impl Cat for H {
    type Output = i32;
    fn gib_value(&self) -> Self::Output {
        1
    }
}

trait Cat {
    type Output;
    fn gib_value(&self) -> Self::Output;
}

[stefnotch]

Scene graphs

Features

• maybe have a concept of "required systems" or "enabled systems", like a scene that doesn't require the physics engine, or two scenes that want a separate instance of the physics engine (see bevy Scenes bevyengine/bevy#255 (comment))
• serialization format (on disk)
  • should be git-diff-able, see Scenes and System Management bevyengine/bevy#654 (comment)
• loading a scene, loading multiple scenes at the same times
• referencing assets (which have stable IDs)
• unloading (after a level is done)

Actor graphs

• actors, children, scripts, ...
• might be the same as a scene graph

Out of scope/no use-case

• prefabs
• saving a scene

See here for an API example https://github.com/bevyengine/bevy/blob/main/examples/scene/scene.rs

And see here for how a popular game engine does it https://docs.godotengine.org/en/stable/getting_started/step_by_step/nodes_and_scenes.html

[YouSafe]

Rust Engine + Game:
https://github.com/franckv/gobs-engine

[stefnotch]

ECS is nice