Struct TransformMapTranslationComponent 

pub struct TransformMapTranslationComponent;

Implementations

impl TransformMapTranslationComponent

pub fn new() -> Self

Examples found in repository

examples/vr-input.rs (line 155)

fn spawn_controller_cube(
    universe: &mut engine::Universe,
    xr_rig: engine::ecs::ComponentId,
    hand: ControllerHand,
    color: (f32, f32, f32, f32),
    rotation_smoothing: f32,
    use_rotation_filter_pipeline: bool,
) -> engine::ecs::ComponentId {
    let controller_marker = universe.world.add_component(ControllerXRComponent::new(
        true,
        hand,
        ControllerPoseKind::Aim,
    ));
    let _ = universe.attach(xr_rig, controller_marker);

    // Transform driven by OpenXRSystem (TransformComponent child of ControllerXRComponent).
    let controller_t = universe
        .world
        .add_component(TransformComponent::new().with_scale(0.06, 0.06, 0.12));
    let _ = universe.attach(controller_marker, controller_t);

    if !use_rotation_filter_pipeline {
        let cube = universe.world.add_component(RenderableComponent::cube());
        let cube_color = universe
            .world
            .add_component(ColorComponent::rgba(color.0, color.1, color.2, color.3));

        let _ = universe.attach(controller_t, cube);
        let _ = universe.attach(cube, cube_color);

        return controller_marker;
    }

    let fork = universe
        .world
        .add_component(TransformForkTRSComponent::new());
    let _ = universe.attach(controller_t, fork);

    let map_translation = universe
        .world
        .add_component(TransformMapTranslationComponent::new());
    let _ = universe.attach(fork, map_translation);

    let map_rotation = universe
        .world
        .add_component(TransformMapRotationComponent::new());
    let _ = universe.attach(fork, map_rotation);
    let rotation_filter = universe.world.add_component(
        QuatTemporalFilterComponent::new().with_smoothing_factor(rotation_smoothing),
    );
    let _ = universe.attach(map_rotation, rotation_filter);

    let map_scale = universe
        .world
        .add_component(TransformMapScaleComponent::new());
    let _ = universe.attach(fork, map_scale);

    let filtered_t = universe.world.add_component(TransformComponent::new());
    let _ = universe.attach(fork, filtered_t);

    let cube = universe.world.add_component(RenderableComponent::cube());
    let cube_color = universe
        .world
        .add_component(ColorComponent::rgba(color.0, color.1, color.2, color.3));

    let _ = universe.attach(filtered_t, cube);
    let _ = universe.attach(cube, cube_color);

    controller_marker
}

Trait Implementations

impl Clone for TransformMapTranslationComponent

fn clone(&self) -> TransformMapTranslationComponent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Component for TransformMapTranslationComponent

fn name(&self) -> &'static str

Short debug/type name for this component kind (e.g. “transform”, “camera”).

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn set_id(&mut self, _component: ComponentId)

fn init(&mut self, _emit: &mut dyn SignalEmitter, _component: ComponentId)

Called when component is added to the World

fn cleanup(&mut self, _emit: &mut dyn SignalEmitter, _component: ComponentId)

Called when component is removed from the World.

fn encode(&self) -> HashMap<String, Value>

Encode component data to a HashMap for serialization.

fn decode(&mut self, _data: &HashMap<String, Value>) -> Result<(), String>

Decode component data from a HashMap after deserialization.

fn to_mms_ast(&self, _world: &World) -> ComponentExpression

Encode this component as an MMS Component Expression AST node.

impl Copy for TransformMapTranslationComponent

impl Debug for TransformMapTranslationComponent

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TransformMapTranslationComponent

fn default() -> TransformMapTranslationComponent

Returns the “default value” for a type.