Struct ComponentRegistration 

pub struct ComponentRegistration<'a, C> {
    pub app: &'a mut App,
    /* private fields */
}

Available on crate feature replication only.

Fields

app: &'a mut App

Implementations

impl<C> ComponentRegistration<'_, C>

pub fn new(app: &mut App) -> ComponentRegistration<'_, C>

pub fn add_map_entities(self) -> ComponentRegistration<'_, C>

where C: Clone + MapEntities + 'static,

Specify that the component contains entities which should be mapped from the remote world to the local world upon deserialization using the component’s MapEntities implementation.

pub fn add_component_map_entities(self) -> ComponentRegistration<'_, C>

where C: Clone + Component + 'static,

Similar to add_map_entities, but uses the Component::map_entities function instead of MapEntities::map_entities

pub fn with_replication_config( self, config: ComponentReplicationConfig, ) -> ComponentRegistration<'_, C>

where C: Component, <C as Component>::Mutability: GetWriteFns<C>,

pub fn add_delta_compression<Delta>(self) -> ComponentRegistration<'_, C>

where C: Component<Mutability = Mutable> + PartialEq + Diffable<Delta>, Delta: Serialize + DeserializeOwned + Message,

Enable delta compression when serializing this component

impl<C> ComponentRegistration<'_, C>

where C: Debug,

pub fn add_default_hash(self) -> ComponentRegistration<'_, C>

where C: Hash + Component,

Add a hash function for this component using the core::hash::Hash trait implementation.

This will be used to compute a checksum for determinism checks.

pub fn add_custom_hash( self, f: fn(&C, &mut SeaHasher), ) -> ComponentRegistration<'_, C>

where C: Component,

Add a hash function for this component using the core::hash::Hash trait implementation.

This will be used to compute a checksum for determinism checks.

Trait Implementations

impl<C> InterpolationRegistrationExt<C> for ComponentRegistration<'_, C>

fn register_interpolation_fn( self, interpolation_fn: fn(C, C, f32) -> C, ) -> ComponentRegistration<'_, C>

where C: SyncComponent,

Register an interpolation function for this component using the provided LerpFn

fn register_linear_interpolation(self) -> ComponentRegistration<'_, C>

where C: SyncComponent + Ease,

Register an interpolation function for this component using the Ease implementation

fn add_interpolation_with( self, interpolation_fn: fn(C, C, f32) -> C, ) -> ComponentRegistration<'_, C>

where C: SyncComponent,

Add interpolation for this component using the provided LerpFn

fn add_linear_interpolation(self) -> ComponentRegistration<'_, C>

where C: SyncComponent + Ease,

Enable interpolation systems for this component using the Ease implementation

fn add_custom_interpolation(self) -> ComponentRegistration<'_, C>

where C: Component + Clone,

The remote updates will be stored in a ConfirmedHistory<C> component but the user has to define the interpolation logic themselves (lightyear won’t perform any kind of interpolation)

impl<C> PredictionRegistrationExt<C> for ComponentRegistration<'_, C>

fn add_prediction(self) -> ComponentRegistration<'_, C>

where C: SyncComponent,

Enable prediction for this component.

fn enable_correction(self) -> ComponentRegistration<'_, C>

where C: SyncComponent,

Enables correction for this component, without adding the correction systems.

fn add_linear_correction_fn<D>(self) -> ComponentRegistration<'_, C>

where C: SyncComponent + Diffable<D>, D: Ease + Debug + Clone + Default + Send + Sync + 'static,

Add correction for this component where the interpolation will done using the lerp function provided by the Ease trait.

fn add_correction_fn<D>( self, correction_fn: fn(D, D, f32) -> D, ) -> ComponentRegistration<'_, C>

where C: SyncComponent + Diffable<D>, D: Ease + Debug + Clone + Default + Send + Sync + 'static,

Add correction for this component where the interpolation will done using the lerp function provided by the Ease trait.

fn add_should_rollback( self, should_rollback: fn(&C, &C) -> bool, ) -> ComponentRegistration<'_, C>

where C: SyncComponent,

Add a custom comparison function to determine if we should rollback by comparing the confirmed component with the predicted component’s history.