react-native-smooth-clip-view 0.2.9 → 0.3.0

package/cpp/SmoothClipVelocityTracker.h

@@ -6,8 +6,9 @@
 namespace smoothclip {
 
 // The two most recent interactive samples used by `initialVelocity: 'inherit'`.
-// Channels are the seven presentation scalars (x, y, width, height, radius,
-// contentTranslateX, contentTranslateY) but the tracker is value-agnostic:
+// Channels are the eleven continuous V2 presentation scalars. Scale is stored
+// so histories remain coherent but excluded from velocity projection; each of
+// the four radius channels contributes one quarter of the legacy radius weight.
 // iOS records normalized (host-clamped) geometry, Android raw DIP — the
 // projection only needs both samples and the target in the same space.
 // Shared by ios/SmoothClipView.mm and android/.../SmoothClipRegistry.cpp; a
@@ -15,8 +16,8 @@ namespace smoothclip {
 struct VelocitySampleHistory {
   bool hasPrevious = false;
   bool hasLatest = false;
-  std::array<double, 7> previous{};
-  std::array<double, 7> latest{};
+  std::array<double, 11> previous{};
+  std::array<double, 11> latest{};
   double previousTimeS = 0;
   double latestTimeS = 0;
 };
@@ -40,7 +41,7 @@ inline constexpr double kVelocityFullCreditS = 1.0 / 60.0;
 
 inline void recordVelocitySample(
     VelocitySampleHistory &history,
-    const std::array<double, 7> &channels,
+    const std::array<double, 11> &channels,
     double nowS) {
   if (history.hasLatest && channels == history.latest) {
     // Identical re-record (a `from` seed equal to the last interactive
@@ -97,7 +98,7 @@ inline double velocityStalenessCredit(double holdS) {
 // Android seeds each integrator channel with scalar·displacement.
 inline double inheritedVelocity(
     const VelocitySampleHistory &history,
-    const std::array<double, 7> &target,
+    const std::array<double, 11> &target,
     double nowS) {
   if (!history.hasPrevious || !history.hasLatest) return 0;
   const double elapsed = history.latestTimeS - history.previousTimeS;
@@ -107,11 +108,14 @@ inline double inheritedVelocity(
   }
   double numerator = 0;
   double denominator = 0;
-  for (int index = 0; index < 7; index += 1) {
+  for (int index = 0; index < 11; index += 1) {
+    const double weight = index >= 4 && index <= 7
+        ? 0.25
+        : (index == 10 ? 0.0 : 1.0);
     const double sampleDelta = history.latest[index] - history.previous[index];
     const double destinationDelta = target[index] - history.latest[index];
-    numerator += sampleDelta * destinationDelta;
-    denominator += destinationDelta * destinationDelta;
+    numerator += weight * sampleDelta * destinationDelta;
+    denominator += weight * destinationDelta * destinationDelta;
   }
   if (denominator <= 1e-12) return 0;
   const double result = numerator / elapsed / denominator * credit;

package/ios/SmoothClipGeometry.h

@@ -2,23 +2,77 @@
 
 #include <math.h>
 
+typedef struct {
+  CGFloat topLeft;
+  CGFloat topRight;
+  CGFloat bottomRight;
+  CGFloat bottomLeft;
+} SmoothClipCornerRadii;
+
+typedef NS_ENUM(NSInteger, SmoothClipCornerCurve) {
+  SmoothClipCornerCurveCircular = 0,
+  SmoothClipCornerCurveContinuous = 1,
+};
+
 typedef struct {
   CGRect rect;
+  // Retained for the V1 uniform-radius contract. V2 callers should consume
+  // `radii`; this field is zero when the normalized radii are unequal.
   CGFloat radius;
+  SmoothClipCornerRadii radii;
+  SmoothClipCornerCurve curve;
 } SmoothNormalizedClipGeometry;
 
-/** Mirrors the Android and JavaScript geometry contract without allocating. */
-NS_INLINE BOOL SmoothClipNormalizeGeometry(
+NS_INLINE BOOL SmoothClipCornerRadiiEqual(
+    SmoothClipCornerRadii first,
+    SmoothClipCornerRadii second) {
+  return first.topLeft == second.topLeft &&
+      first.topRight == second.topRight &&
+      first.bottomRight == second.bottomRight &&
+      first.bottomLeft == second.bottomLeft;
+}
+
+NS_INLINE BOOL SmoothClipCornerRadiiAreUniform(
+    SmoothClipCornerRadii radii) {
+  return radii.topLeft == radii.topRight &&
+      radii.topLeft == radii.bottomRight &&
+      radii.topLeft == radii.bottomLeft;
+}
+
+NS_INLINE CGFloat SmoothClipSafeOverlapFactor(
+    CGFloat extent,
+    CGFloat firstRadius,
+    CGFloat secondRadius) {
+  const CGFloat sum = firstRadius + secondRadius;
+  return sum > 0 ? extent / sum : 1;
+}
+
+/**
+ * Normalizes the V2 rectangle and four radii without allocating.
+ *
+ * The proportional overlap rule matches CSS border radii and the shared
+ * Android/C++ contract: all corners use one scale factor, preserving their
+ * relative shape while no opposing pair exceeds its edge.
+ */
+NS_INLINE BOOL SmoothClipNormalizeGeometryV2(
     CGFloat x,
     CGFloat y,
     CGFloat width,
     CGFloat height,
-    CGFloat radius,
+    CGFloat topLeftRadius,
+    CGFloat topRightRadius,
+    CGFloat bottomRightRadius,
+    CGFloat bottomLeftRadius,
+    NSInteger curveCode,
     CGSize hostSize,
     SmoothNormalizedClipGeometry *result) {
   if (!isfinite(x) || !isfinite(y) || !isfinite(width) ||
-      !isfinite(height) || !isfinite(radius) ||
-      !isfinite(hostSize.width) || !isfinite(hostSize.height)) {
+      !isfinite(height) || !isfinite(topLeftRadius) ||
+      !isfinite(topRightRadius) || !isfinite(bottomRightRadius) ||
+      !isfinite(bottomLeftRadius) || !isfinite(hostSize.width) ||
+      !isfinite(hostSize.height) ||
+      (curveCode != SmoothClipCornerCurveCircular &&
+       curveCode != SmoothClipCornerCurveContinuous)) {
     return NO;
   }
 
@@ -35,7 +89,131 @@ NS_INLINE BOOL SmoothClipNormalizeGeometry(
   const CGFloat visibleWidth = MAX(0, right - left);
   const CGFloat visibleHeight = MAX(0, bottom - top);
 
+  SmoothClipCornerRadii radii = {
+      MAX(0, topLeftRadius),
+      MAX(0, topRightRadius),
+      MAX(0, bottomRightRadius),
+      MAX(0, bottomLeftRadius),
+  };
+  const CGFloat overlapScale = MIN(
+      1,
+      MIN(
+          MIN(
+              SmoothClipSafeOverlapFactor(
+                  visibleWidth, radii.topLeft, radii.topRight),
+              SmoothClipSafeOverlapFactor(
+                  visibleWidth, radii.bottomLeft, radii.bottomRight)),
+          MIN(
+              SmoothClipSafeOverlapFactor(
+                  visibleHeight, radii.topLeft, radii.bottomLeft),
+              SmoothClipSafeOverlapFactor(
+                  visibleHeight, radii.topRight, radii.bottomRight))));
+  radii.topLeft *= overlapScale;
+  radii.topRight *= overlapScale;
+  radii.bottomRight *= overlapScale;
+  radii.bottomLeft *= overlapScale;
+
   result->rect = CGRectMake(left, top, visibleWidth, visibleHeight);
-  result->radius = MIN(MAX(0, radius), MIN(visibleWidth, visibleHeight) / 2.0);
+  result->radii = radii;
+  result->radius = SmoothClipCornerRadiiAreUniform(radii)
+      ? radii.topLeft
+      : 0;
+  result->curve = (SmoothClipCornerCurve)curveCode;
   return YES;
 }
+
+/** Mirrors the Android and JavaScript geometry contract without allocating. */
+NS_INLINE BOOL SmoothClipNormalizeGeometry(
+    CGFloat x,
+    CGFloat y,
+    CGFloat width,
+    CGFloat height,
+    CGFloat radius,
+    CGSize hostSize,
+    SmoothNormalizedClipGeometry *result) {
+  return SmoothClipNormalizeGeometryV2(
+      x,
+      y,
+      width,
+      height,
+      radius,
+      radius,
+      radius,
+      radius,
+      SmoothClipCornerCurveCircular,
+      hostSize,
+      result);
+}
+
+/**
+ * Creates the stable nine-segment rounded-rectangle topology used by the
+ * unequal-corner CAShapeLayer mask. Every corner is one cubic, including a
+ * zero-radius corner, so Core Animation can interpolate paths without a
+ * topology change.
+ */
+NS_INLINE CGPathRef SmoothClipCreateRoundedRectPath(
+    CGRect rect,
+    SmoothClipCornerRadii radii,
+    SmoothClipCornerCurve curve) CF_RETURNS_RETAINED {
+  const CGFloat minX = CGRectGetMinX(rect);
+  const CGFloat minY = CGRectGetMinY(rect);
+  const CGFloat maxX = CGRectGetMaxX(rect);
+  const CGFloat maxY = CGRectGetMaxY(rect);
+  // Circular is the exact cubic-circle coefficient. The portable continuous
+  // fallback uses kappa=1 so each cubic joins its straight edges with zero
+  // curvature, matching the portable Android path. Hit testing derives
+  // from this rendered path rather than maintaining a second curve model.
+  // Uniform
+  // continuous shapes use CALayer.cornerCurve for Apple's platform-native
+  // compositor shape and are intentionally not pixel-identical cross-platform.
+  const CGFloat controlFactor =
+      curve == SmoothClipCornerCurveContinuous
+      ? 1.0
+      : 0.5522847498307936;
+
+  CGMutablePathRef path = CGPathCreateMutable();
+  CGPathMoveToPoint(path, NULL, minX + radii.topLeft, minY);
+  CGPathAddLineToPoint(path, NULL, maxX - radii.topRight, minY);
+  CGPathAddCurveToPoint(
+      path,
+      NULL,
+      maxX - radii.topRight + radii.topRight * controlFactor,
+      minY,
+      maxX,
+      minY + radii.topRight - radii.topRight * controlFactor,
+      maxX,
+      minY + radii.topRight);
+  CGPathAddLineToPoint(path, NULL, maxX, maxY - radii.bottomRight);
+  CGPathAddCurveToPoint(
+      path,
+      NULL,
+      maxX,
+      maxY - radii.bottomRight + radii.bottomRight * controlFactor,
+      maxX - radii.bottomRight +
+          radii.bottomRight * controlFactor,
+      maxY,
+      maxX - radii.bottomRight,
+      maxY);
+  CGPathAddLineToPoint(path, NULL, minX + radii.bottomLeft, maxY);
+  CGPathAddCurveToPoint(
+      path,
+      NULL,
+      minX + radii.bottomLeft - radii.bottomLeft * controlFactor,
+      maxY,
+      minX,
+      maxY - radii.bottomLeft + radii.bottomLeft * controlFactor,
+      minX,
+      maxY - radii.bottomLeft);
+  CGPathAddLineToPoint(path, NULL, minX, minY + radii.topLeft);
+  CGPathAddCurveToPoint(
+      path,
+      NULL,
+      minX,
+      minY + radii.topLeft - radii.topLeft * controlFactor,
+      minX + radii.topLeft - radii.topLeft * controlFactor,
+      minY,
+      minX + radii.topLeft,
+      minY);
+  CGPathCloseSubpath(path);
+  return path;
+}