Does bevy ECS do recursive component contiguation?

[Paladynee]

I'm a beginner to bevy but I've previously been doing low level optimization tricks and I was just wondering how exactly this example component is stored in memory:

#[derive(Component)]
struct Player {
    position: Position,
    id: u32,
}

#[derive(Component)]
struct Position {
    x: f32,
    y: f32,
}

Does the underlying memory for Player that has been inserted to the ECS via commands.spawn(Player::new(...))look like
a) &[Player]
b) &[Position], &[u32]
c) &[f32], &[f32], &[u32]

• for the case a, accessing the memory linearly for just player id's will have a stride of size_of::<Player>().
• for the case b, accessing the memory linearly for just player id's will have a stride of size_of::<u32>() and allow maximal vectorization for just id's, but accessing the memory linearly for Position.x and Position.y will have a stride of size_of::<Position>().
• for the case c, accessing any recursive subfield of Player has the smallest possible stride, like a perfected SoA representation.

which one is the reality currently? does bevy have

• per-T: Bundle memory layout boundaries (option a)
• per-#[derive(Component)] layout boundaries (option b)
• recursive per-subtype layout boundaries (option c)

[bilsen]

Underlying storage (if using tables) is basically a vector per component (and archetype). Not sure which option to select since

per-T: Bundle memory layout boundaries (option a)

doesn't fit with the example (Player is a component not a bundle)

[bilsen]

see also https://docs.rs/bevy/latest/bevy/ecs/component/trait.Component.html#choosing-a-storage-type

[SkiFire13]

The answer is a)

The fact that Position implements Component does nothing here. In other words, the entity you spawned does not have the Position component. It's just a field.

However:

per-T: Bundle memory layout boundaries (option a)

This is not correct. If you insert a (Position, Velocity) then the layout will look like &[Position], &[Velocity]. Similarly if you insert an instance of the following PosVel type:

#[derive(Bundle)] // <-- not Component!
struct PosVel {
    position: Position,
    velocity: Velocity,
}

The layout is per component: each component gets its own contiguous storage. But fields of components are not components themselves, so this doesn't recurse.