Enum GenericValue 

pub enum GenericValue<D: DataSystem> {
    Uniform(D),
    Animated(D::Animated),
}

A value that can be either uniform or animated over time.

This is the generic version of Value that works with any DataSystem. Use this when you have a custom data type system.

For the built-in types, use Value which is an alias for GenericValue<Data>.

Variants

Uniform(D)

A constant value that does not change over time.

Animated(D::Animated)

A value that changes over time with keyframe interpolation.

Implementations

impl<D: DataSystem> GenericValue<D>

pub fn uniform(value: D) -> Self

Creates a uniform value that does not change over time.

pub fn animated<I>(samples: I) -> Result<Self>

where I: IntoIterator<Item = (Time, D)>,

Creates an animated value from time-value pairs.

All samples must have the same data type. Vector samples are padded to match the length of the longest vector in the set.

pub fn add_sample(&mut self, time: Time, value: D) -> Result<()>

Adds a sample at a specific time.

If the value is uniform, it becomes animated with the new sample.

pub fn remove_sample(&mut self, time: &Time) -> Option<D>

Removes a sample at a specific time.

Returns the removed value if it existed. For uniform values, this is a no-op and returns None. The last sample in an animated value cannot be removed (returns None). Use remove_or_make_uniform to degrade to uniform instead.

pub fn remove_or_make_uniform(&mut self, time: &Time) -> Option<D>

Remove a sample, converting to uniform if it was the last keyframe.

If the value is uniform, returns None. If the removed sample was the last keyframe, the value degrades from GenericValue::Animated to GenericValue::Uniform with that keyframe’s value and returns None (the data is preserved, not lost). Otherwise returns the removed value.

pub fn sample_at(&self, time: Time) -> Option<D>

Samples the value at an exact time without interpolation.

Returns the exact value if it exists at the given time, or None if no sample exists at that time for animated values.

pub fn interpolate(&self, time: Time) -> D

Interpolates the value at the given time.

For uniform values, returns the constant value. For animated values, interpolates between surrounding keyframes.

pub fn is_animated(&self) -> bool

Returns true if the value is animated (has multiple keyframes).

pub fn sample_count(&self) -> usize

Returns the number of time samples.

pub fn times(&self) -> SmallVec<[Time; 10]>

Returns all keyframe times.

pub fn discriminant(&self) -> D::DataType

Returns the data type discriminant for this value.

pub fn variant_name(&self) -> &'static str

Returns a human-readable type name for this value.

pub fn merge_with<F>( &self, other: &GenericValue<D>, combiner: F, ) -> Result<GenericValue<D>>

where F: Fn(&D, &D) -> D,

Merges this value with another using a combiner function.

For uniform values, applies the combiner once. For animated values, samples both at the union of all keyframe times and applies the combiner at each time.

pub fn hash_with_shutter<H: Hasher>(&self, state: &mut H, shutter: &Shutter)

Hashes the value with shutter context for animation-aware caching.

For animated values, samples at standardized points within the shutter range and hashes the interpolated values.

Trait Implementations

impl<D: Clone + DataSystem> Clone for GenericValue<D>

where D::Animated: Clone,

fn clone(&self) -> GenericValue<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D: Debug + DataSystem> Debug for GenericValue<D>

where D::Animated: Debug,

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

Formats the value using the given formatter.

impl<D: DataSystem> From<D> for GenericValue<D>

fn from(value: D) -> Self

Converts to this type from the input type.

impl<D: Hash + DataSystem> Hash for GenericValue<D>

where D::Animated: Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<D: PartialEq + DataSystem> PartialEq for GenericValue<D>

where D::Animated: PartialEq,

fn eq(&self, other: &GenericValue<D>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<D: DataSystem> Eq for GenericValue<D>

impl<D: DataSystem> StructuralPartialEq for GenericValue<D>