blend static method

void blend(OrbFrame from, OrbFrame to, double progress, OrbFrame out, { double stagger = 0.35, })

Writes the index-mapped morph of from into to at progress into out. Dots leave in a staggered wave (stagger of the progress span) so the change reads as a flow rather than a slide. Lines cross-fade.

Implementation

static void blend(
  OrbFrame from,
  OrbFrame to,
  double progress,
  OrbFrame out, {
  double stagger = 0.35,
}) {
  out.clear();
  if (from.isEmpty || progress >= 1) {
    out.copyFrom(to);
    return;
  }
  if (to.isEmpty || progress <= 0) {
    out.copyFrom(from);
    return;
  }
  final na = from._length;
  final nb = to._length;
  final n = na > nb ? na : nb;
  final a = from._data;
  final b = to._data;
  for (var k = 0; k < n; k++) {
    final ia = (k * na ~/ n) * stride;
    final ib = (k * nb ~/ n) * stride;
    final offset = stagger * hashD(k.toDouble(), 3.7);
    final f = smoothStep((progress * (1 + stagger) - offset) / 1);
    final ta = a[ia + _oTint];
    final tb = b[ib + _oTint];
    out.addTinted(
      lerp(a[ia + _ox], b[ib + _ox], f),
      lerp(a[ia + _oy], b[ib + _oy], f),
      lerp(a[ia + _oz], b[ib + _oz], f),
      lerp(a[ia + _or], b[ib + _or], f),
      lerp(a[ia + _oInk], b[ib + _oInk], f),
      lerp(a[ia + _oAlpha], b[ib + _oAlpha], f),
      ta == 0
          ? b[ib + _oTintR]
          : (tb == 0
                ? a[ia + _oTintR]
                : lerp(a[ia + _oTintR], b[ib + _oTintR], f)),
      ta == 0
          ? b[ib + _oTintG]
          : (tb == 0
                ? a[ia + _oTintG]
                : lerp(a[ia + _oTintG], b[ib + _oTintG], f)),
      ta == 0
          ? b[ib + _oTintB]
          : (tb == 0
                ? a[ia + _oTintB]
                : lerp(a[ia + _oTintB], b[ib + _oTintB], f)),
      lerp(ta, tb, f),
    );
  }
  out._appendLines(from, 1 - progress);
  out._appendLines(to, progress);
}