flash function

double flash(
  1. Painter p,
  2. double x,
  3. double y,
  4. double a,
  5. List<FlashLobe> l,
  6. List<int> c,
  7. int seed,
)

Renders flash lobes l at (x, y) along angle a, returning flash reach.

Implementation

double flash(
  Painter p,
  double x,
  double y,
  double a,
  List<FlashLobe> l,
  List<int> c,
  int seed,
) {
  final cs = math.cos(a);
  final sn = math.sin(a);
  var ext = 2.0;
  for (final lobe in l) {
    ext = math.max(ext, lobe.off + lobe.len + 2);
  }
  p.shade(x - ext, y - ext, x + ext, y + ext, (px, py, _) {
    final dx = px - x;
    final dy = py - y;
    final along = dx * cs + dy * sn;
    final across = -dx * sn + dy * cs;
    var m = -9.0;
    var hot = false;
    var warm = false;
    for (final lobe in l) {
      final ca = math.cos(lobe.a);
      final sa = math.sin(lobe.a);
      final lu = (along - lobe.off) * ca + across * sa;
      final lv = -(along - lobe.off) * sa + across * ca;
      if (lu < -1.5 || lu > lobe.len + 1) continue;
      final r = _profile(lobe, math.max(0.0, lu));
      final mm = r - lv.abs();
      if (mm > m) m = mm;
      if (lu < lobe.len * lobe.core && lv.abs() <= r * 0.5) hot = true;
      if (mm > r * 0.4) warm = true;
    }
    final dm = 1.6 - hypot(along - 0.5, across);
    if (dm > m) m = dm;
    if (dm > 0.6) hot = true;
    m += (rand(px.floor() * 73 + py.floor() * 151, seed) - 0.5) *
        0.5 *
        math.min(1.0, ext / 14);
    if (m < -0.85) return null;
    return m < 0
        ? c[3]
        : hot
            ? c[0]
            : warm
                ? c[1]
                : c[2];
  });
  return ext;
}