Struct rin::blender::ActionMix

pub struct ActionMix<A1, A2> { /* fields omitted */ }

Mixes two different actions by applying the two at the same time

Usually only useful for actions that apply to different elements.

Implementations

impl<A1, A2> ActionMix<A1, A2> where
    A1: ActionExt,
    A2: ActionExt, 

pub fn new(action1: A1, action2: A2) -> ActionMix<A1, A2>

Trait Implementations

impl<A1, A2> ActionExt for ActionMix<A1, A2> where
    A1: ActionExt,
    A2: ActionExt, 

pub fn orientation_at(
    &self,
    object: &str,
    t: f32,
    current_value: &Unit<Quaternion<f32>>
) -> Option<Unit<Quaternion<f32>>>

pub fn orientation_from_axis_angle_at(
    &self,
    object: &str,
    t: f32,
    current_value: &Unit<Quaternion<f32>>
) -> Option<Unit<Quaternion<f32>>>

pub fn orientation_from_euler_at(
    &self,
    object: &str,
    t: f32,
    current_value: &Unit<Quaternion<f32>>,
    rot_order: RotOrder
) -> Option<Unit<Quaternion<f32>>>

pub fn location_at(
    &self,
    object: &str,
    t: f32,
    current_value: &Point<f32, U3>
) -> Option<Point<f32, U3>>

pub fn scale_at(
    &self,
    object: &str,
    t: f32,
    current_value: &Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>
) -> Option<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>

pub fn rotation_at(
    &self,
    object: &str,
    _t: f32,
    _current_value: &Rotation
) -> Option<Rotation>

pub fn keyblock_at(&self, keyblock: &str, t: f32) -> Option<f32>

pub fn hide_view_at(&self, object: &str, t: f32) -> Option<bool>

pub fn hide_render_at(&self, object: &str, t: f32) -> Option<bool>

pub fn root_motion_location_at(
    &self,
    object: &str,
    t: f32,
    current_value: &Point<f32, U3>,
    prev_positions: &mut HashMap<String, Option<(f32, Point<f32, U3>)>, RandomState>
) -> Option<(Point<f32, U3>, Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>)>

pub fn root_motion_orientation_at(
    &self,
    object: &str,
    t: f32,
    current_value: &Unit<Quaternion<f32>>,
    prev_orientations: &mut HashMap<String, Option<(f32, Unit<Quaternion<f32>>)>, RandomState>
) -> Option<(Unit<Quaternion<f32>>, Unit<Quaternion<f32>>)>

pub fn needs_root_motion_reset(&self, t: f32) -> bool

pub fn name(&self) -> &str

pub fn root_motion_remove(&self, t: Option<f32>) -> RootMotionRemove

pub fn reset_root_motion_positions(
    &self,
    object: &str,
    t: f32,
    current_value: &Point<f32, U3>,
    prev_positions: &mut HashMap<String, Option<(f32, Point<f32, U3>)>, RandomState>
)

pub fn reset_root_motion_orientations(
    &self,
    object: &str,
    t: f32,
    current_value: &Unit<Quaternion<f32>>,
    prev_orientations: &mut HashMap<String, Option<(f32, Unit<Quaternion<f32>>)>, RandomState>
)

pub fn min_time_s(&self) -> f32

pub fn max_time_s(&self) -> f32

pub fn duration(&self) -> f32

impl<A1, A2> ActionNeedsUpdate for ActionMix<A1, A2> where
    A1: ActionNeedsUpdate,
    A2: ActionNeedsUpdate, 

pub const NEEDS_UPDATE: bool

impl<A1, A2> ActionUpdate for ActionMix<A1, A2> where
    A1: ActionUpdate,
    A2: ActionUpdate, 

pub fn update(&mut self)

impl<A1, A2> Clone for ActionMix<A1, A2> where
    A1: Clone,
    A2: Clone, 

pub fn clone(&self) -> ActionMix<A1, A2>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A1, A2> Debug for ActionMix<A1, A2> where
    A1: Debug,
    A2: Debug, 

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

Formats the value using the given formatter.

impl<'de, A1, A2> Deserialize<'de> for ActionMix<A1, A2> where
    A1: Deserialize<'de>,
    A2: Deserialize<'de>, 

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<ActionMix<A1, A2>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<A1, A2> Serialize for ActionMix<A1, A2> where
    A1: Serialize,
    A2: Serialize, 

pub fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.