Crate specs [−] [src]
SPECS Parallel ECS
This library provides an ECS variant designed for parallel execution and convenient usage. It is highly flexible when it comes to actual component data and the way it is stored and accessed.
Features:
- depending on chosen features either 0 virtual function calls or one per system
- parallel iteration over components
- parallel execution of systems
High-level overview
One could basically split this library up into two parts: The data part and the execution part.
The data
World
is where component storages, resources and entities are stored.
See the docs of World
for more.
Component
s can be easily implemented like this:
use specs::{Component, VecStorage}; struct MyComp; impl Component for MyComp { type Storage = VecStorage<Self>; }
Or alternatively, if you import the specs-derive
crate, you can use a
custom #[derive]
macro:
#[macro_use] extern crate specs_derive; use specs::VecStorage; #[derive(Component)] #[component(VecStorage)] struct MyComp;
You can choose different storages according to your needs.
These storages can be join
ed together, for example joining a Velocity
and a Position
storage means you'll only get entities which have both of them.
Thanks to rayon, this is even possible in parallel! See ParJoin
for more.
System execution
Here we have System
and Dispatcher
as our core types. Both types
are provided by a library called shred
.
The Dispatcher
can be seen as an optional part here;
it allows dispatching the systems in parallel, given a list
of systems and their dependencies on other systems.
If you don't like it, you can also execute the systems yourself
by using RunNow
.
System
s are traits with a run()
method and an associated
SystemData
, allowing type-safe aspects (knowledge about the
reads / writes of the systems).
Examples
This is a basic example of using Specs:
extern crate specs; use specs::{Component, DispatcherBuilder, Join, ReadStorage, System, VecStorage, WriteStorage, World}; // A component contains data which is // associated with an entity. struct Vel(f32); impl Component for Vel { type Storage = VecStorage<Self>; } struct Pos(f32); impl Component for Pos { type Storage = VecStorage<Self>; } struct SysA; impl<'a> System<'a> for SysA { // These are the resources required for execution. // You can also define a struct and `#[derive(SystemData)]`, // see the `full` example. type SystemData = (WriteStorage<'a, Pos>, ReadStorage<'a, Vel>); fn run(&mut self, (mut pos, vel): Self::SystemData) { // The `.join()` combines multiple components, // so we only access those entities which have // both of them. // This joins the component storages for Position // and Velocity together; it's also possible to do this // in parallel using rayon's `ParallelIterator`s. // See `ParJoin` for more. for (pos, vel) in (&mut pos, &vel).join() { pos.0 += vel.0; } } } fn main() { // The `World` is our // container for components // and other resources. let mut world = World::new(); world.register::<Pos>(); world.register::<Vel>(); // An entity may or may not contain some component. world.create_entity().with(Vel(2.0)).with(Pos(0.0)).build(); world.create_entity().with(Vel(4.0)).with(Pos(1.6)).build(); world.create_entity().with(Vel(1.5)).with(Pos(5.4)).build(); // This entity does not have `Vel`, so it won't be dispatched. world.create_entity().with(Pos(2.0)).build(); // This builds a dispatcher. // The third parameter of `add` specifies // logical dependencies on other systems. // Since we only have one, we don't depend on anything. // See the `full` example for dependencies. let mut dispatcher = DispatcherBuilder::new().add(SysA, "sys_a", &[]).build(); // This dispatches all the systems in parallel (but blocking). dispatcher.dispatch(&mut world.res); }
You can also easily create new entities on the fly:
use specs::{Entities, FetchMut, System, WriteStorage}; struct EnemySpawner; impl<'a> System<'a> for EnemySpawner { type SystemData = Entities<'a>; fn run(&mut self, entities: Entities<'a>) { let enemy = entities.create(); } }
See the repository's examples directory for more examples.
Modules
common |
Common functionality you might need when using Specs. |
error |
Specs error module. |
saveload |
Save and load entities from various formats with serde. |
Structs
AsyncDispatcher |
Like, |
BTreeStorage |
BTreeMap-based storage. |
ChangeEvents |
Events iterator for all events between the last reset and the last,
eventual maintain. See |
CreateIter |
An iterator for entity creation. Please note that you have to consume it because iterators are lazy. |
CreateIterAtomic |
An iterator for entity creation. Please note that you have to consume it because iterators are lazy. |
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 |
EntitiesRes |
The entities of this ECS. This is a resource, stored in the |
Entity |
|
EntityBuilder |
The entity builder, allowing to build an entity together with its components. |
Entry |
An entry to a storage. |
Fetch |
Return value of |
FetchId |
Return value of |
FetchIdMut |
Return value of |
FetchMut |
Return value of |
FlaggedStorage |
Wrapper storage that stores modifications to components in a bitset. |
Generation |
Index generation. When a new entity is placed at an old index,
it bumps the |
HashMapStorage |
HashMap-based storage. Best suited for rare components. |
JoinIter |
|
JoinParIter |
|
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 |
MaskedStorage |
The |
NullStorage |
A null storage type, used for cases where the component doesn't contain any data and instead works as a simple flag. |
OccupiedEntry |
An entry to a storage which has a component associated to the entity. |
PackedData |
Structure of packed components with offsets of which entities they belong to. Offsets define which entities the components correspond to, based on a list of entities the packed data is sent in with. |
RestrictedStorage |
Similar to a |
RudyStorage |
Rudy-based storage. |
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 |
TrackedStorage |
Storage which tracks changes. |
VacantEntry |
An entry to a storage which does not have a component associated to the entity. |
VecStorage |
Vector storage. Uses a simple |
World |
The |
Enums
Change |
This enum represents the different changes the |
InsertResult |
The status of an |
MergeError |
The error type returned
by |
NormalRestriction |
Specifies that the |
ParallelRestriction |
Specifies that the |
RunningTime | |
StorageEntry |
Entry to a storage for convenient filling of components or removal based on whether the entity has a component. |
Traits
Component |
Abstract component type. Doesn't have to be Copy or even Clone. |
DistinctStorage |
This is a marker trait which requires you to uphold the following guarantee: |
Join |
The purpose of the |
ParJoin |
The purpose of the |
RunNow |
Trait for fetching data and running systems. Automatically implemented for systems. |
System |
A |
SystemData |
A struct implementing system data indicates that it bundles some resources which are required for the execution. |
UnprotectedStorage |
Used by the framework to quickly join components. |
Type Definitions
Entities |
A wrapper for a fetched |
Index |
An index is basically the id of an |
ReadStorage |
A storage with read access. |
WriteStorage |
A storage with read and write access. |