[Impeller] MetalSDF mis-clips a gradient-shader + MaskFilter.blur draw when the canvas is rotated by 90°/180°/270° (shape vanishes near a window edge) - regression in 3.47 #191449

// Minimal repro for flutter/flutter.
//
// Impeller MetalSDF (macOS, Flutter 3.47): a Paint that has BOTH a gradient
// shader AND a MaskFilter.blur is mis-clipped when the canvas is rotated by a
// multiple of 90°. The clip moves with the shape's distance to the window
// edge; a shape touching the bottom edge (for rotate(1.5π)) is not drawn at
// all. Shader-only and solid+blur paints are unaffected, as is any rotation
// that is not a multiple of 90°.
//
// Layout: two rows of three 250 px arcs, every arc drawn on a canvas rotated
// by 1.5π about its centre.
//   column A: gradient shader, no blur     (control)
//   column B: gradient shader + blur(1)    <-- bug column
//   column C: solid color + blur(1)        (control)
//   top row   : arcs flush with the TOP of the window
//   bottom row: arcs flush with the BOTTOM of the window
// Expected: six identical arcs. Actual on MetalSDF: bottom-row B is missing.
//
// Run as a macOS desktop app (`flutter run -d macos`); the bug is in the macOS
// Impeller backend, so it cannot reproduce on web/DartPad. After the first
// frame the app samples one pixel on every arc and prints the RGBA values.

import 'dart:math' as math;
import 'dart:ui' as ui;

import 'package:flutter/material.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/scheduler.dart';

const Color kAccent = Color(0xFFFF8A4C);
const Color kBackground = Color(0xFF0E0A0B);
const double kArcSize = 250;
const double kStrokeWidth = 8;
const double kGap = 16;
const double kRotation = 1.5 * math.pi;

void main() {
  runApp(
    const MaterialApp(
      debugShowCheckedModeBanner: false,
      home: ReproPage(),
    ),
  );
}

enum PaintVariant {
  shaderOnly('A: shader, no blur'),
  shaderPlusBlur('B: shader + blur(1)'),
  solidPlusBlur('C: solid + blur(1)');

  const PaintVariant(this.label);
  final String label;
}

class ArcPainter extends CustomPainter {
  const ArcPainter(this.variant);
  final PaintVariant variant;

  @override
  void paint(Canvas canvas, Size size) {
    final center = size.center(Offset.zero);
    final rect = Rect.fromCircle(
      center: center,
      radius: size.shortestSide / 2 - kStrokeWidth,
    );

    // Rotate about the arc centre (e.g. to move 0° to 12 o'clock).
    canvas.translate(center.dx, center.dy);
    canvas.rotate(kRotation);
    canvas.translate(-center.dx, -center.dy);

    final paint = Paint()
      ..style = PaintingStyle.stroke
      ..strokeWidth = kStrokeWidth
      ..strokeCap = StrokeCap.butt;

    switch (variant) {
      case PaintVariant.shaderOnly:
        paint.shader = _gradient(rect);
      case PaintVariant.shaderPlusBlur:
        paint
          ..shader = _gradient(rect)
          ..maskFilter = const MaskFilter.blur(BlurStyle.normal, 1);
      case PaintVariant.solidPlusBlur:
        paint
          ..color = kAccent
          ..maskFilter = const MaskFilter.blur(BlurStyle.normal, 1);
    }

    canvas.drawArc(rect, 0, 1.5 * math.pi, false, paint);
  }

  static Shader _gradient(Rect rect) => SweepGradient(
        colors: [kAccent.withValues(alpha: 0.05), kAccent, kAccent],
        stops: const [0.0, 0.375, 0.75],
      ).createShader(rect);

  @override
  bool shouldRepaint(ArcPainter oldDelegate) => oldDelegate.variant != variant;
}

class ArcRow extends StatelessWidget {
  const ArcRow({super.key, required this.labelsBelow});
  final bool labelsBelow;

  @override
  Widget build(BuildContext context) {
    return Row(
      mainAxisSize: MainAxisSize.min,
      children: [
        for (final (i, v) in PaintVariant.values.indexed) ...[
          if (i > 0) const SizedBox(width: kGap),
          Column(
            mainAxisSize: MainAxisSize.min,
            children: [
              if (!labelsBelow) ArcLabel(variant: v),
              CustomPaint(
                size: const Size.square(kArcSize),
                painter: ArcPainter(v),
              ),
              if (labelsBelow) ArcLabel(variant: v),
            ],
          ),
        ],
      ],
    );
  }
}

class ArcLabel extends StatelessWidget {
  const ArcLabel({super.key, required this.variant});
  final PaintVariant variant;

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.symmetric(vertical: 4),
      child: Text(
        variant.label,
        style: const TextStyle(color: Colors.white70, fontSize: 11),
      ),
    );
  }
}

class ReproPage extends StatefulWidget {
  const ReproPage({super.key});

  @override
  State<ReproPage> createState() => _ReproPageState();
}

class _ReproPageState extends State<ReproPage> {
  final GlobalKey _boundaryKey = GlobalKey();

  @override
  void initState() {
    super.initState();
    SchedulerBinding.instance.addPostFrameCallback((_) => _probe());
  }

  Future<void> _probe() async {
    // Wait one extra frame so the GPU-backed surface has definitely rendered.
    await SchedulerBinding.instance.endOfFrame;
    if (!mounted) return;
    final dpr = View.of(context).devicePixelRatio;
    final boundary = _boundaryKey.currentContext!.findRenderObject()!
        as RenderRepaintBoundary;
    final image = await boundary.toImage(pixelRatio: dpr);
    final bytes = (await image.toByteData(format: ui.ImageByteFormat.rawRgba))!;
    final size = boundary.size;

    final buffer = StringBuffer(
      '\n=== pixel probe (window ${size.width}x${size.height}, dpr $dpr) ===\n',
    );
    const radius = kArcSize / 2 - kStrokeWidth;
    final rowWidth = 3 * kArcSize + 2 * kGap;
    final left = (size.width - rowWidth) / 2;
    for (final (row, top) in [0.0, size.height - kArcSize].indexed) {
      for (final (col, variant) in PaintVariant.values.indexed) {
        final cx = left + col * (kArcSize + kGap) + kArcSize / 2;
        final cy = top + kArcSize / 2;
        // 90° into the sweep — inside the opaque part of every variant —
        // offset by the canvas rotation so we sample the same spot on screen.
        const angle = math.pi / 2 + kRotation;
        final x = ((cx + radius * math.cos(angle)) * dpr).round();
        final y = ((cy + radius * math.sin(angle)) * dpr).round();
        final offset = (y * image.width + x) * 4;
        final r = bytes.getUint8(offset);
        final g = bytes.getUint8(offset + 1);
        final b = bytes.getUint8(offset + 2);
        final a = bytes.getUint8(offset + 3);
        // Background is 0x0E0A0B; anything with r < 40 was not drawn.
        buffer.writeln(
          '${row == 0 ? "top   " : "bottom"} ${variant.name.padRight(15)} '
          '@($x,$y) rgba($r,$g,$b,$a)  ${r > 40 ? "ok" : "<-- NOT RENDERED"}',
        );
      }
    }
    debugPrint(buffer.toString());
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      backgroundColor: kBackground,
      body: RepaintBoundary(
        key: _boundaryKey,
        child: Container(
          color: kBackground,
          child: const Column(
            children: [
              // Top row: arcs flush with the top edge, labels below them.
              ArcRow(labelsBelow: true),
              Spacer(),
              // Bottom row: labels above, arcs flush with the bottom edge.
              ArcRow(labelsBelow: false),
            ],
          ),
        ),
      ),
    );
  }
}