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

package/cpp/SmoothClipSharedGeometry.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "SmoothClipRegistry.h"
+
 #include <algorithm>
 #include <cmath>
 
@@ -11,23 +13,110 @@ struct NormalizedClip {
   double right = 0;
   double bottom = 0;
   double radius = 0;
+  double topLeftRadius = 0;
+  double topRightRadius = 0;
+  double bottomRightRadius = 0;
+  double bottomLeftRadius = 0;
+  ClipCurve curve = ClipCurve::Circular;
 };
 
-// Shared clip normalization emitting edges (Android's Outline consumes
-// edges). Mirrors ios/SmoothClipGeometry.h (SmoothClipNormalizeGeometry) and
-// ClipGeometryNormalizer.kt (normalizeClipGeometryPx); a change here must
-// land in all three.
-inline bool SmoothClipNormalize(
+inline double SmoothClipResolvedRadius(double overrideValue, double radius) {
+  return std::isfinite(overrideValue) ? overrideValue : radius;
+}
+
+/**
+ * Returns true only when host normalization is the identity for this geometry.
+ *
+ * Timing/keyframe renderers interpolate already-normalized native values on
+ * iOS, while Android interpolates presentation scalars and normalizes each
+ * delivered frame. Those operations commute exactly when every anchor stays
+ * inside one host and the CSS corner-overlap rule never activates. Because
+ * each condition below is linear, it also holds for every convex interpolation
+ * between accepted anchors.
+ *
+ * Static clipping deliberately does not use this gate: out-of-bounds geometry
+ * remains valid and is still clipped by SmoothClipNormalizeV2.
+ */
+inline bool SmoothClipGeometryNormalizationIsIdentity(
+    const Geometry &geometry,
+    double hostWidth,
+    double hostHeight) {
+  const double topLeft = SmoothClipResolvedRadius(
+      geometry.topLeftRadius, geometry.radius);
+  const double topRight = SmoothClipResolvedRadius(
+      geometry.topRightRadius, geometry.radius);
+  const double bottomRight = SmoothClipResolvedRadius(
+      geometry.bottomRightRadius, geometry.radius);
+  const double bottomLeft = SmoothClipResolvedRadius(
+      geometry.bottomLeftRadius, geometry.radius);
+  const double right = geometry.x + geometry.width;
+  const double bottom = geometry.y + geometry.height;
+  const double topRadii = topLeft + topRight;
+  const double bottomRadii = bottomLeft + bottomRight;
+  const double leftRadii = topLeft + bottomLeft;
+  const double rightRadii = topRight + bottomRight;
+  const double values[] = {
+      geometry.x,
+      geometry.y,
+      geometry.width,
+      geometry.height,
+      geometry.radius,
+      topLeft,
+      topRight,
+      bottomRight,
+      bottomLeft,
+      right,
+      bottom,
+      topRadii,
+      bottomRadii,
+      leftRadii,
+      rightRadii,
+      hostWidth,
+      hostHeight,
+  };
+  for (const double value : values) {
+    if (!std::isfinite(value)) return false;
+  }
+  return hostWidth >= 0 && hostHeight >= 0 &&
+      geometry.x >= 0 && geometry.y >= 0 &&
+      geometry.width >= 0 && geometry.height >= 0 &&
+      right <= hostWidth && bottom <= hostHeight &&
+      topLeft >= 0 && topRight >= 0 &&
+      bottomRight >= 0 && bottomLeft >= 0 &&
+      topRadii <= geometry.width &&
+      bottomRadii <= geometry.width &&
+      leftRadii <= geometry.height &&
+      rightRadii <= geometry.height;
+}
+
+inline bool SmoothClipNormalizeV2(
     double x,
     double y,
     double width,
     double height,
     double radius,
+    double topLeftRadius,
+    double topRightRadius,
+    double bottomRightRadius,
+    double bottomLeftRadius,
+    ClipCurve curve,
     double hostWidth,
     double hostHeight,
     NormalizedClip &out) {
+  const double resolvedTopLeft =
+      SmoothClipResolvedRadius(topLeftRadius, radius);
+  const double resolvedTopRight =
+      SmoothClipResolvedRadius(topRightRadius, radius);
+  const double resolvedBottomRight =
+      SmoothClipResolvedRadius(bottomRightRadius, radius);
+  const double resolvedBottomLeft =
+      SmoothClipResolvedRadius(bottomLeftRadius, radius);
   if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(width) ||
       !std::isfinite(height) || !std::isfinite(radius) ||
+      !std::isfinite(resolvedTopLeft) ||
+      !std::isfinite(resolvedTopRight) ||
+      !std::isfinite(resolvedBottomRight) ||
+      !std::isfinite(resolvedBottomLeft) ||
       !std::isfinite(hostWidth) || !std::isfinite(hostHeight)) {
     return false;
   }
@@ -42,9 +131,59 @@ inline bool SmoothClipNormalize(
   out.bottom = std::min(boundedHostHeight, std::max(0.0, requestedBottom));
   const double visibleWidth = std::max(0.0, out.right - out.left);
   const double visibleHeight = std::max(0.0, out.bottom - out.top);
-  out.radius = std::min(
-      std::max(0.0, radius), std::min(visibleWidth, visibleHeight) / 2.0);
+
+  double topLeft = std::max(0.0, resolvedTopLeft);
+  double topRight = std::max(0.0, resolvedTopRight);
+  double bottomRight = std::max(0.0, resolvedBottomRight);
+  double bottomLeft = std::max(0.0, resolvedBottomLeft);
+  double scale = 1.0;
+  const auto includeLimit = [&scale](double available, double requested) {
+    if (requested > 0) scale = std::min(scale, available / requested);
+  };
+  includeLimit(visibleWidth, topLeft + topRight);
+  includeLimit(visibleWidth, bottomLeft + bottomRight);
+  includeLimit(visibleHeight, topLeft + bottomLeft);
+  includeLimit(visibleHeight, topRight + bottomRight);
+  scale = std::max(0.0, std::min(1.0, scale));
+  out.topLeftRadius = topLeft * scale;
+  out.topRightRadius = topRight * scale;
+  out.bottomRightRadius = bottomRight * scale;
+  out.bottomLeftRadius = bottomLeft * scale;
+  const bool uniform = out.topLeftRadius == out.topRightRadius &&
+      out.topLeftRadius == out.bottomRightRadius &&
+      out.topLeftRadius == out.bottomLeftRadius;
+  out.radius = uniform ? out.topLeftRadius : 0.0;
+  out.curve = curve;
   return true;
 }
 
+// Shared clip normalization emitting edges (Android's Outline consumes
+// edges). Mirrors ios/SmoothClipGeometry.h (SmoothClipNormalizeGeometry) and
+// ClipGeometryNormalizer.kt (normalizeClipGeometryPx); a change here must
+// land in all three.
+inline bool SmoothClipNormalize(
+    double x,
+    double y,
+    double width,
+    double height,
+    double radius,
+    double hostWidth,
+    double hostHeight,
+    NormalizedClip &out) {
+  return SmoothClipNormalizeV2(
+      x,
+      y,
+      width,
+      height,
+      radius,
+      radius,
+      radius,
+      radius,
+      radius,
+      ClipCurve::Circular,
+      hostWidth,
+      hostHeight,
+      out);
+}
+
 } // namespace smoothclip

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;
+}