cloud function

void cloud(
  1. Painter p,
  2. List<CloudPuff> list,
  3. List<int> rRamp,
  4. List<int> wrRamp, {
  5. double dens = 1.5,
  6. double max = 0.86,
  7. bool clip(
    1. double x,
    2. double y
    )?,
  8. double lit = 1,
})

Merges list of puffs into a single quantized, top-lit translucent smoke volume.

Implementation

void cloud(
  Painter p,
  List<CloudPuff> list,
  List<int> rRamp,
  List<int> wrRamp, {
  double dens = 1.5,
  double max = 0.86,
  bool Function(double x, double y)? clip,
  double lit = 1,
}) {
  if (list.isEmpty) return;
  var x0 = 1 << 30;
  var y0 = 1 << 30;
  var x1 = -(1 << 30);
  var y1 = -(1 << 30);
  for (final q in list) {
    x0 = math.min(x0, (q.x - q.r).floor());
    x1 = math.max(x1, (q.x + q.r).ceil());
    y0 = math.min(y0, (q.y - q.r).floor());
    y1 = math.max(y1, (q.y + q.r).ceil());
  }
  final w = x1 - x0 + 3;
  final h = y1 - y0 + 3;
  final dArr = Float32List(w * h);
  final lArr = Float32List(w * h);
  final fArr = Float32List(w * h);
  x0--;
  y0--;
  for (final q in list) {
    final r = q.r;
    final r2 = r * r;
    for (var y = (q.y - r).floor(); y <= (q.y + r).ceil(); y++) {
      final dy = y + 0.5 - q.y;
      for (var x = (q.x - r).floor(); x <= (q.x + r).ceil(); x++) {
        final dx = x + 0.5 - q.x;
        final d2 = (dx * dx + dy * dy) / r2;
        if (d2 >= 1) continue;
        final k = math.sqrt(1 - d2) * q.a;
        final i = (y - y0) * w + (x - x0);
        dArr[i] += k;
        lArr[i] += k * q.b;
        fArr[i] += k * q.w * (0.5 + 0.5 * clamp(0.5 + dx / r));
      }
    }
  }
  final bArr = _blur(_blur(dArr, w, h, 1, 2), w, h, w, 2);
  final n = rRamp.length;
  p.each(x0 + 1.0, y0 + 1.0, x1 + 1.0, y1 + 1.0, (lx, ly, sx, sy) {
    final cx = lx.floor() - x0;
    final cy = ly.floor() - y0;
    if (cx < 1 || cy < 1 || cx >= w - 1 || cy >= h - 1) return;
    final i = cy * w + cx;
    final d = dArr[i];
    if (d < 0.05 || (clip != null && !clip(lx, ly))) return;
    final a = math.min(max, ((1 - math.exp(-d * dens)) * 6).ceil() / 6);
    if (a < 0.15) return;
    final gy = bArr[i + w] - bArr[i - w];
    final gx = bArr[i + 1] - bArr[i - 1];
    final up = clamp(
      0.5 +
          math.atan((gy * 0.9 + gx * 0.35) / (bArr[i] * 0.16 + 0.03)) *
              0.42 *
              lit,
    );
    final warm = fArr[i] / d;
    final j = clampInt(
      ((lArr[i] / d) * (0.3 + 0.7 * up) * (n - 1) + 0.25 + warm * 1.5 + 0.5)
          .floor(),
      0,
      n - 1,
    );
    p.blendPx(
      sx,
      sy,
      warm > 0.03
          ? mix(rRamp[j], wrRamp[j], math.min(0.9, (warm * 10).ceil() / 10))
          : rRamp[j],
      a,
    );
  });
}