Module amethyst::ecs::prelude[−]

Prelude module

Contains all of the most common traits, structures,

Structs

AsyncDispatcher	Like, `Dispatcher` but works asynchronously.
BitSet	A `BitSet` is a simple set designed to track entity indices for which a certain component exists. It does not track the `Generation` of the entities that it contains.
DenseVecStorage	Dense vector storage. Has a redirection 2-way table between entities and components, allowing to leave no gaps within the data.
Dispatcher	The dispatcher struct, allowing systems to be executed in parallel.
DispatcherBuilder	Builder for the `Dispatcher`.
Entity	`Entity` type, as seen by the user.
EntityBuilder	The entity builder, allowing to build an entity together with its components.
FlaggedStorage	Wrapper storage that tracks modifications, insertions, and removals of components through an `EventChannel`.
HashMapStorage	HashMap-based storage. Best suited for rare components.
InsertedFlag	Flag with additional type safety against which kind of operations were done.
LazyUpdate	Lazy updates can be used for world updates that need to borrow a lot of resources and as such should better be done at the end. They work lazily in the sense that they are dispatched when calling `world.maintain()`.
ModifiedFlag	Flag with additional type safety against which kind of operations were done.
NullStorage	A null storage type, used for cases where the component doesn't contain any data and instead works as a simple flag.
Read	Allows to fetch a resource in a system immutably.
ReaderId	The reader id is used by readers to tell the storage where the last read ended.
RemovedFlag	Flag with additional type safety against which kind of operations were done.
Resources	A resource container, which provides methods to access to the contained resources.
StaticAccessor	The static accessor that is used for `SystemData`.
Storage	A wrapper around the masked storage and the generations vector. Can be used for safe lookup of components, insertions and removes. This is what `World::read/write` fetches for the user.
VecStorage	Vector storage. Uses a simple `Vec`. Supposed to have maximum performance for the components mostly present in entities.
World	The `World` struct contains the component storages and other resources.
Write	Allows to fetch a resource in a system mutably.

Traits

Accessor	A trait for accessing read/write multiple resources from a system. This can be used to create dynamic systems that don't specify what they fetch at compile-time.
Builder	A common trait for `EntityBuilder` and `LazyBuilder`, allowing either to be used. Entity is definitely alive, but the components may or may not exist before a call to `World::maintain`.
Component	Abstract component type. Doesn't have to be Copy or even Clone.
ParallelIterator	Parallel version of the standard iterator trait.
RunNow	Trait for fetching data and running systems. Automatically implemented for systems.
System	A `System`, executed with a set of required `Resource`s.
SystemData	A static system data that can specify its dependencies at statically (at compile-time). Most system data is a `SystemData`, the `DynamicSystemData` type is only needed for very special setups.
Tracked	`UnprotectedStorage`s that track modifications, insertions, and removals of components.

Type Definitions

Entities	A wrapper for a read `Entities` resource. Note that this is just `Read<Entities>`, so you can easily use it in your system:
ReadExpect	Allows to fetch a resource in a system mutably. This will panic if the resource does not exist. Usage of `Read` or `Option<Read>` is therefore recommended.
ReadStorage	A storage with read access.
WriteExpect	Allows to fetch a resource in a system mutably. This will panic if the resource does not exist. Usage of `Write` or `Option<Write>` is therefore recommended.
WriteStorage	A storage with read and write access.