lerpWhereUsing<T extends FVariants<K, E, V, D>, K extends FVariantConstraint, E extends FVariant, V, D extends Delta> static method

T lerpWhereUsing<T extends FVariants<K, E, V, D>, K extends FVariantConstraint, E extends FVariant, V, D extends Delta>(FVariants<K, E, V, D> a, FVariants<K, E, V, D> b, double t, V? lerp(V?, V?, double), T supply(V base, Map<K, V> variants),)

Linearly interpolates between two T using the given lerp and supply function.

Only keys present in both a and b are lerped.

See:

• lerpWhere for a version that returns FVariants.

Implementation

static T
lerpWhereUsing<T extends FVariants<K, E, V, D>, K extends FVariantConstraint, E extends FVariant, V, D extends Delta>(
  FVariants<K, E, V, D> a,
  FVariants<K, E, V, D> b,
  double t,
  V? Function(V?, V?, double) lerp,
  T Function(V base, Map<K, V> variants) supply,
) {
  final base = lerp(a.base, b.base, t);
  final variants = <K, V>{};

  // V is V?. Casts are necessary as flow typing isn't smart enough to propagate this check.
  if (null is V) {
    for (final key in a.variants.keys) {
      if (b.variants.containsKey(key)) {
        variants[key] = lerp(a.variants[key], b.variants[key], t) as V;
      }
    }

    return supply(base as V, variants);
  } else {
    for (final key in a.variants.keys) {
      if (b.variants.containsKey(key)) {
        if (lerp(a.variants[key], b.variants[key], t) case final lerped?) {
          variants[key] = lerped;
        }
      }
    }

    return supply(base ?? (t < 0.5 ? a.base : b.base), variants);
  }
}