Struct chunked::world::World

pub struct World { /* fields omitted */ }

A World manages an evolving series of Snapshots.

Worlds introduce the ability to do parallel work on a snapshot at the cost of requiring futures in most cases.

You can create an empty world with an empty snapshot with World::new().

Cloning the World produces another view onto the same world.

Implementations

impl World

pub fn new(universe: Arc<Universe>) -> World

Create a new world.

pub fn with_snapshot(snapshot: Arc<Snapshot>) -> World

Create a new world with a given initial snapshot.

pub fn universe(&self) -> &Arc<Universe>

Return the universe this world exists inside.

pub async fn into_snapshot(self) -> Arc<Snapshot>

Drop this world and return the contained snapshot.

If this is not the last view onto the same world, an error will be returned with its original value.

pub async fn snapshot(&self) -> Arc<Snapshot>

Create a snapshot of the current world state.

pub async fn replace_snapshot(&self, snapshot: Arc<Snapshot>) -> Arc<Snapshot>

Replace the snapshot of the world, returning the old snapshot.

pub async fn take_snapshot(&self) -> Arc<Snapshot>

Take the current snapshot of the world and clear it.

Generally this is designed to be used as a performance optimisation: if nobody else has a reference to the Snapshot, it can be modified freely.

pub async fn set_snapshot(&self, snapshot: Arc<Snapshot>)

Set the current state of the world.

pub async fn clear(&self)

Clear all entities from the world.

pub async fn exclusive_transaction<F>(&self, f: F) where
    F: FnOnce(&mut Arc<Snapshot>) + Send, 

Modify the snapshot.

This takes the write lock for the snapshot for the entirety of the call to f() and should be used sparingly.

A good use is for applying command buffers, since it can avoid extra memory allocation.

pub async fn transaction<F>(&self, locks: impl Into<Vec<Lock>>, f: F) where
    F: FnOnce(TransactionGuard<'a>) + Send + 'static, 

Run a non-structural transaction.