Akiba So
3295018ee3
All checks were successful
CI / Windows build (push) Successful in 11m34s
W1 — Custom pen width + pressure sensitivity (Saber-style):
- Root cause of "压感没用": perfect_freehand 1.0.4 IGNORES real stylus pressure
(hardcodes radius=size/2 when simulatePressure=false) — width never tracked pen
force. Upgraded perfect_freehand ^1.0.0 -> ^2.0.0 (honors real pressure); migrated
all 5 getStroke call sites to the 2.x API (PointVector / StrokeOptions / Offset).
- De-hardcoded `thinning` into `kDefaultPenThinning` (0.85), single source shared by
the on-screen painter and the PDF export path; exposed as PenConfig.pressureSensitivity
with a Pressure Sensitivity slider; live-applies via a config listener.
W3 — Native Windows pen plugin (tilt + barrel/eraser buttons):
- windows/runner/pen_channel.{h,cpp}: observe WM_POINTER at the TOP of MessageHandler
(before HandleTopLevelWindowProc, which Flutter uses to consume pen events), read
GetPointerPenInfo penFlags + tilt, stream over EventChannel('badnote/pen'); non-consuming.
- PenInputService: single latched hardware state (no Win32-pointerId<->event.pointer
correlation); graceful no-op off-Windows.
- pen_canvas maps barrel/inverted/eraser through PenConfig.sideButton/eraserEnd
(eraser/undo/toggleTool/pan) and captures tilt into PenPoint.tilt -> EditorPoint.tilt.
W2 — Zoom flicker: page raster isolated in its own RepaintBoundary (safe interim);
definitive crisp-on-zoom fix gated on the on-device root-cause probe (plan M3).
Plans: ralplan-consensus plan at docs/plans/2026-06-22-badnote-pen-polish.md
(Architect APPROVE-WITH-MUST-FIX M1-M4 + Critic ITERATE->APPROVE).
Tests: 58/58 pass incl. shared-thinning invariant + thinning-affects-outline +
tilt-adapter round-trip. flutter analyze clean; linux debug build OK.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
84 lines
3.0 KiB
Dart
84 lines
3.0 KiB
Dart
// lib/editor/engine/stroke_geometry.dart
|
|
//
|
|
// Single source of stroke outline geometry for both screen render and export.
|
|
// The recipe is lifted verbatim from the proven live
|
|
// `ink_painters.buildStrokePath` (lib/editor/canvas/ink_painters.dart): points
|
|
// are scaled from normalized page coords to pixels, perfect_freehand produces
|
|
// the outline, and a closed fill Path is built. Keeping ONE implementation here
|
|
// kills the hairline-export divergence (R7).
|
|
|
|
import 'dart:ui';
|
|
|
|
import 'package:perfect_freehand/perfect_freehand.dart' as pf;
|
|
|
|
import 'stroke_model.dart';
|
|
|
|
/// Canonical default for perfect_freehand's `thinning` (how strongly pressure
|
|
/// modulates stroke width). The SINGLE source of truth shared by the on-screen
|
|
/// painter ([buildStrokeOutline] here and `ink_painters.buildStrokePath`) and
|
|
/// the PDF export path, so screen and export can never diverge. `0.85` =
|
|
/// pressure visibly sweeps width; preserves the existing feel + export golden.
|
|
/// Overridable per-stroke via [PenConfig.pressureSensitivity].
|
|
const double kDefaultPenThinning = 0.85;
|
|
|
|
/// Builds a closed, fillable outline [Path] for one [stroke], scaled into the
|
|
/// pixel space of [pageSize] (which maps normalized [0,1] coords to pixels).
|
|
///
|
|
/// [isComplete] should be false for the in-progress live stroke so freehand
|
|
/// tapers the trailing end correctly, and true for committed strokes.
|
|
///
|
|
/// [thinning] is perfect_freehand's pressure→width response (see
|
|
/// [kDefaultPenThinning]); highlighter always forces `0.0` (constant width).
|
|
///
|
|
/// Returns an empty [Path] when the stroke has no points (or freehand produces
|
|
/// no outline).
|
|
Path buildStrokeOutline(
|
|
EditorStroke stroke,
|
|
Size pageSize, {
|
|
required bool isComplete,
|
|
double thinning = kDefaultPenThinning,
|
|
}) {
|
|
final path = Path();
|
|
if (stroke.points.isEmpty) return path;
|
|
|
|
final pixelWidth = stroke.width * pageSize.width;
|
|
|
|
final hasRealPressure = stroke.points.any((p) => p.pressure != null);
|
|
final isHighlighter = stroke.tool == EditorTool.highlighter;
|
|
|
|
final pfPoints = stroke.points
|
|
.map(
|
|
(p) => pf.PointVector(
|
|
p.x * pageSize.width,
|
|
p.y * pageSize.height,
|
|
p.pressure ?? 0.5,
|
|
),
|
|
)
|
|
.toList();
|
|
|
|
final outline = pf.getStroke(
|
|
pfPoints,
|
|
options: pf.StrokeOptions(
|
|
size: pixelWidth,
|
|
// Highlighter keeps a constant width (no thinning); pen uses the
|
|
// configurable [thinning] so Surface-Pen pressure changes width.
|
|
thinning: isHighlighter ? 0.0 : thinning,
|
|
smoothing: 0.5,
|
|
streamline: 0.5,
|
|
// Real stylus pressure -> don't simulate; no pressure -> let freehand
|
|
// fake it based on velocity (highlighter never simulates). perfect_freehand
|
|
// 2.x honors real pressure when simulatePressure is false.
|
|
simulatePressure: !hasRealPressure && !isHighlighter,
|
|
isComplete: isComplete,
|
|
),
|
|
);
|
|
|
|
if (outline.isEmpty) return path;
|
|
path.moveTo(outline.first.dx, outline.first.dy);
|
|
for (var i = 1; i < outline.length; i++) {
|
|
path.lineTo(outline[i].dx, outline[i].dy);
|
|
}
|
|
path.close();
|
|
return path;
|
|
}
|