dynec 0.2.1

An opinionated ECS-like framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! Systems are actions performed every frame to manipulate entities and components.
//!
//! A system can declare mutable or immutable access
//! to archetype-specific components and global states.
//! dynec will schedule systems such that systems have unique access to mutable resources they
//! request.
//! Furthermore, systems can request relative execution order through [`Partition`]s.
//! Systems that use thread-unsafe resources (systems that are not [`Send`])
//! are always executed on the main thread.

use std::any::TypeId;

use crate::entity::{ealloc, referrer};
use crate::world;
use crate::world::offline;
pub use crate::world::rw::isotope::read::full::ReadIsotopeFull;
pub use crate::world::rw::isotope::read::partial::ReadIsotopePartial;
pub use crate::world::rw::isotope::write::full::WriteIsotopeFull;
pub use crate::world::rw::isotope::write::partial::WriteIsotopePartial;
pub use crate::world::rw::simple::{ReadSimple, WriteSimple};

pub mod access;
pub use access::{Isotope as AccessIsotope, Single as AccessSingle};

pub mod iter;
pub use iter::{EntityIterator, IntoZip, Try, Zip, ZipChunked};

pub mod partition;
pub use partition::{EntityCreationPartition, Partition};

mod offline_buffer;
pub use offline_buffer::{EntityCreator, EntityDeleter};

pub mod spec;
#[doc(inline)]
pub use spec::Spec;

/// Describes a system.
pub trait Descriptor {
    /// Describes the resource requirements of this system.
    ///
    /// The method is only called when the system was initially scheduled,
    /// but it should return a consistent value.
    fn get_spec(&self) -> Spec;

    /// Delegates to [`Referrer::visit_type`](referrer::Referrer::visit_type)
    /// for the states of this system.
    fn visit_type(&self, arg: &mut referrer::VisitTypeArg);

    /// By default, systems with states that strongly reference entities always execute
    /// before systems that create those entities to ensure the entities initialized.
    /// If references to uninitialized entities are tolerable,
    /// include the TypeId of the archetype in the returned vector.
    fn state_maybe_uninit(&self) -> Vec<TypeId> { Vec::new() }

    /// Executes the mutable visitor
    fn visit_mut(&mut self) -> referrer::AsObject<'_>;
}

/// A system requests some resources, stores some states of its own and is runnable with the
/// requested resources.
///
/// There may be multiple instances of the same implementor type.
/// This is meaningful as they may have different states.
pub trait Sendable: Send + Descriptor + 'static {
    /// Runs the system.
    fn run(
        &mut self,
        globals: &world::SyncGlobals,
        components: &world::Components,
        ealloc_shard_map: &mut ealloc::ShardMap,
        offline_shard: &mut offline::BufferShard,
    );

    /// Returns self upcast to [`Descriptor`] as a trait object.
    fn as_descriptor_mut(&mut self) -> &mut dyn Descriptor;
}

/// A variant of [`Sendable`] that runs on the main thread only,
/// but allows storing [`Send`] states
/// and accessing non-<code>[Send] + [Sync]</code> global states.
pub trait Unsendable: Descriptor + 'static {
    /// Runs the system.
    fn run(
        &mut self,
        sync_globals: &world::SyncGlobals,
        unsync_globals: &mut world::UnsyncGlobals,
        components: &world::Components,
        ealloc_shard_map: &mut ealloc::ShardMap,
        offline_shard: &mut offline::BufferShard,
    );

    /// Returns self upcast to [`Descriptor`] as a trait object.
    fn as_descriptor_mut(&mut self) -> &mut dyn Descriptor;
}