flashShape function

List<FlashLobe> flashShape(
  1. Rng r,
  2. int f, {
  3. double size = 1,
  4. List<double> spike = const [12, 20],
  5. List<double> diag = const [5, 10],
  6. List<double> cross = const [3, 6],
  7. List<double> back = const [2, 4.5],
  8. double core = 0.7,
})

Generates spiky muzzle-flash lobes from r for frame f (1 or 2).

Implementation

List<FlashLobe> flashShape(
  Rng r,
  int f, {
  double size = 1,
  List<double> spike = const [12, 20],
  List<double> diag = const [5, 10],
  List<double> cross = const [3, 6],
  List<double> back = const [2, 4.5],
  double core = 0.7,
}) {
  final k = f == 1 ? 1.0 : 0.6;
  final w = f == 1 ? 1.0 : 0.72;
  final s = size;
  final l = <FlashLobe>[
    FlashLobe(
      off: 0.5,
      a: r.range(-0.08, 0.08),
      len: r.range(5.5, 8) * s * k,
      wid: r.range(2.1, 2.6) * s * w,
      core: 0.5 * core,
    ),
    FlashLobe(
      off: 2,
      a: r.range(-0.07, 0.07),
      len: r.range(spike[0], spike[1]) * s * k,
      wid: r.range(1, 1.3) * s * w,
      core: 0.35 * core,
    ),
  ];
  void ray(double a, double len, double wid, bool on) {
    if (on) {
      l.add(FlashLobe(
        off: r.range(0.5, 2),
        a: a,
        len: len * s * k,
        wid: wid * s * w,
        core: 0.25 * core,
      ));
    }
  }

  for (final sign in const [-1, 1]) {
    ray(
      sign * r.range(0.3, 0.8),
      r.range(diag[0], diag[1]),
      r.range(1.1, 1.5),
      r.chance(0.85),
    );
    ray(
      sign * r.range(1.15, 1.7),
      r.range(cross[0], cross[1]),
      r.range(1, 1.3),
      r.chance(0.6),
    );
    ray(
      sign * r.range(2, 2.7),
      r.range(back[0], back[1]),
      1,
      r.chance(0.7) && f == 1,
    );
  }
  return l;
}