Enum Motion 

pub enum Motion {
    Drift {
        velocity: VelocityVec,
    },
    Oscillate {
        amplitude: LengthVec,
        frequency: Frequency,
        phase_deg: f64,
    },
    Spin {
        axis: DVec3,
        pivot: LengthVec,
        rate_deg_per_s: f64,
    },
}

Rigid motion of one element, assembly or source.

Variants

Drift

Constant velocity: a conveyor belt, a translation stage, or the drift of a star field across an untracked telescope.

Fields

velocity: VelocityVec

How fast and which way.

Oscillate

Sinusoidal displacement about the authored position, which is the centre of the swing. amplitude carries both size and direction, so a floor vibration and an axial focus dither are the same variant.

Fields

amplitude: LengthVec

Peak displacement, carrying its direction. Half the peak-to-peak swing.

frequency: Frequency

Cycles per second.

phase_deg: f64

Where in the cycle t = 0 falls, in degrees. Zero starts at the centre moving towards amplitude.

Spin

Rotation at rate_deg_per_s about axis through pivot. A rotating stage or a scanning mirror: it turns what it carries as well as moving it, so an element’s own axis tilts too.

Fields

axis: DVec3

Rotation axis, normalised internally. Right-handed about this direction.

pivot: LengthVec

A point the axis passes through. Defaults to the origin, so a spin about the authored position needs nothing said.

rate_deg_per_s: f64

Degrees per second, positive being right-handed about axis.

Implementations

impl Motion

pub fn rotation_at(&self, t: Time) -> DQuat

The rotation this motion has accumulated by time t. Identity for the purely translational variants.

pub fn move_point(&self, p: LengthVec, t: Time) -> LengthVec

Where a point authored at p sits at time t.

pub fn turn(&self, d: DVec3, t: Time) -> DVec3

Where a direction authored as d points at time t. A direction is dimensionless, and translation does not change it.

pub fn velocity_at(&self, p: LengthVec, t: Time) -> VelocityVec

Velocity of the point authored at p, at time t.

Differentiated in closed form rather than by finite difference, so it is exact — which matters because this is what sets a motion-blur streak length and what a Doppler shift would be computed from.

Trait Implementations

impl Clone for Motion

fn clone(&self) -> Motion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Motion

impl Debug for Motion

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Motion

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Motion

fn eq(&self, other: &Motion) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Motion

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Motion