[Impeller] Sample the render target rect in offscreen advanced blends - #192988

Problem

In the offscreen advanced blend path, the subpass render target is allocated with an integral size — ISize(subpass_coverage.GetSize()), a truncating conversion — and the quad spans that render target. But the texture coordinates are derived from the full, fractional coverage. The quad therefore displays a slightly larger region than it covers, scaling the contents by trunc(w)/w.

That factor changes whenever the coverage crosses a pixel boundary, so animated content is resampled differently every frame, which reads as shaking and crawling. The coverage does not need to be meaningfully fractional: in the per-draw path the blend runs over the whole pass (FlipBackdrop), and floating-point residue in the transform chain is enough — instrumenting master while running the Rive artboard below, the extent truncated on 29% of blend subpasses and the origin was fractional on 34%.

Only configurations without framebuffer fetch take this path — the iOS simulator, PowerVR, and Adreno on GLES. Devices with framebuffer fetch blend in-pass via ApplyFramebufferBlend, which is exact.

Fix

Derive the texture coordinates from the rect the render target actually represents, so the quad and the sampled region agree exactly. The render target size, the composite origin and the composited rect are all unchanged from master; PipelineBlend draws each input at its own size and transform and never had this mismatch, so it is not touched.

Verification

Measured on an iPhone 17 Pro simulator against a Rive artboard exercising Multiply, Screen, Overlay, Soft Light and Color Dodge, loaded with Factory.flutter so drawing goes through Flutter's canvas and into Impeller's blend paths. The landmark is the left edge of static artboard content that never moves in the animation, so every pixel of movement is the bug. 40 consecutive frames:

import 'package:flutter/material.dart';
import 'package:rive/rive.dart';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await RiveNative.init();
  runApp(const MaterialApp(home: Scaffold(body: BlendModeTest())));
}

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

  @override
  State<BlendModeTest> createState() => _BlendModeTestState();
}

class _BlendModeTestState extends State<BlendModeTest> {
  File? _file;
  RiveWidgetController? _controller;

  @override
  void initState() {
    super.initState();
    _load();
  }

  Future<void> _load() async {
    // Factory.flutter routes drawing through Flutter's Canvas, so the artboard
    // goes through Impeller's blend paths. Factory.rive would use Rive's own
    // renderer and would not exercise this code at all.
    final file = await File.asset(
      'assets/blend_mode_test.riv',
      riveFactory: Factory.flutter,
    );
    if (file == null) {
      return;
    }
    setState(() {
      _file = file;
      _controller = RiveWidgetController(file);
    });
  }

  @override
  void dispose() {
    _controller?.dispose();
    _file?.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    final controller = _controller;
    if (controller == null) {
      return const Center(child: CircularProgressIndicator());
    }
    return Container(
      color: const Color(0xFF9E9E9E),
      child: RiveWidget(controller: controller, fit: Fit.contain),
    );
  }
}

(The recordings were made with an earlier revision of this change; the measured result for the final revision is identical.)

Golden change

This changes exactly one engine golden (of 466 Metal goldens compared locally): ColorFilterAdvancedBlendNoFbFetch. It is a correction, not a regression. That test stacks thirty full-frame blends, so the per-frame resampling error accumulates into a visible smear of every cell edge. Cell 2's image begins at x=400 (400 px pitch, 320 px images); row y=220:

The current golden bleeds orange four pixels into the empty gap before the cell and blurs the edge over ~7 px; this PR matches the exact in-pass rendering to within 1/255. The golden will need triage.

Tests

DlGoldenTest.StackedOffscreenAdvancedBlendsDoNotResample renders a hard backdrop edge and blends over it thirty times with kLighten on a context without framebuffer fetch, then requires the result to match a single blend. Lighten is idempotent, so the only thing that can differ is resampling error accumulated across the stacked subpasses. A 0.4x canvas scale makes the full-pass coverage fractional the same way the golden does. Fails on master (RMSE 5.75), passes with this change (RMSE 0).

impeller_unittests *Blend*/*Filter*: 791 passing, 0 failing. The ColorFilterAdvancedBlendNoFbFetch golden exercises the same path with thirty stacked blends and visibly captures the defect.

Fixes #192980

Pre-launch Checklist

• I read the Contributor Guide and followed the process outlined there for submitting PRs.
• I read the AI contribution guidelines and understand my responsibilities, or I am not using AI tools.
• I read the Tree Hygiene wiki page, which explains my responsibilities.
• I read and followed the Flutter Style Guide, including [Features we expect every widget to implement].
• I signed the CLA.
• I listed at least one issue that this PR fixes in the description above.
• I updated/added relevant in-code documentation (doc comments with ///).
• If this PR introduces a new feature or capability, I created and linked a website documentation issue or PR in [flutter/website] (or verified none is needed).
• I added new tests to check the change I am making, or this PR is test-exempt.
• I followed the breaking change policy and added Data Driven Fixes where supported.
• All existing and new tests are passing.