Handle rounded rectangles more accurately (#288)

* Rename to match After Effects and some initial refactoring.
* Correctly support roundness where size and roundness are not animated.
* Handle non-static rounded rectangles better.
* Also fixes a misunderstanding with how animations are stopped in Composition.

Author: Simeon

source/LottieData/Polystar.cs

@@ -18,8 +18,8 @@ public Polystar(
             Animatable<double> rotation,
             Animatable<double> innerRadius,
             Animatable<double> outerRadius,
-            Animatable<double> innerRoundedness,
-            Animatable<double> outerRoundedness)
+            Animatable<double> innerRoundness,
+            Animatable<double> outerRoundness)
             : base(in args, drawingDirection)
         {
             StarType = starType;
@@ -28,8 +28,8 @@ public Polystar(
             Rotation = rotation;
             InnerRadius = innerRadius;
             OuterRadius = outerRadius;
-            InnerRoundedness = innerRoundedness;
-            OuterRoundedness = outerRoundedness;
+            InnerRoundness = innerRoundness;
+            OuterRoundness = outerRoundness;
         }
 
         internal PolyStarType StarType { get; }
@@ -44,9 +44,9 @@ public Polystar(
 
         internal Animatable<double> OuterRadius { get; }
 
-        internal Animatable<double> InnerRoundedness { get; }
+        internal Animatable<double> InnerRoundness { get; }
 
-        internal Animatable<double> OuterRoundedness { get; }
+        internal Animatable<double> OuterRoundness { get; }
 
         /// <inheritdoc/>
         public override ShapeContentType ContentType => ShapeContentType.Polystar;

source/LottieData/Rectangle.cs

@@ -14,15 +14,22 @@ public Rectangle(
             DrawingDirection drawingDirection,
             IAnimatableVector3 position,
             IAnimatableVector3 size,
-            Animatable<double> cornerRadius)
+            Animatable<double> roundness)
             : base(in args, drawingDirection)
         {
             Position = position;
             Size = size;
-            CornerRadius = cornerRadius;
+            Roundness = roundness;
         }
 
-        public Animatable<double> CornerRadius { get; }
+        /// <summary>
+        /// Determines how round the corners of the rectangle are. If the rectangle
+        /// is a square and the roundness is equal to half of the width then the
+        /// rectangle will be rendered as a circle. Once the roundness value reaches
+        /// half of the minimum of the shortest dimension, increasing it has no
+        /// further effect.
+        /// </summary>
+        public Animatable<double> Roundness { get; }
 
         public IAnimatableVector3 Size { get; }
 

source/LottieData/RoundedCorner.cs

@@ -17,6 +17,16 @@ public RoundedCorner(
             Radius = radius;
         }
 
+        /// <summary>
+        /// The radius of the rounding.
+        /// </summary>
+        /// <remarks>
+        /// If the shape to which this applies is a rectangle, the rounding will
+        /// only apply if the rectangle has a 0 roundness value. Once the radius
+        /// value reaches half of the largest dimension of the rectangle, the
+        /// result will be equivalent to an ellipse of the same size, and
+        /// increasing the radius further will have no further effect.
+        /// </remarks>
         public Animatable<double> Radius { get; }
 
         /// <inheritdoc/>

source/LottieData/Serialization/LottieCompositionXmlSerializer.cs

@@ -616,7 +616,7 @@ IEnumerable<XObject> GetContents()
 
                 yield return FromAnimatable(nameof(content.Size), content.Size);
                 yield return FromAnimatable(nameof(content.Position), content.Position);
-                yield return FromAnimatable(nameof(content.CornerRadius), content.CornerRadius);
+                yield return FromAnimatable(nameof(content.Roundness), content.Roundness);
             }
         }
 

source/LottieData/Serialization/LottieCompositionYamlSerializer.cs

@@ -644,7 +644,7 @@ YamlObject FromRectangle(Rectangle content, YamlMap superclassContent)
             var result = superclassContent;
             result.Add(nameof(content.Size), FromAnimatable(content.Size));
             result.Add(nameof(content.Position), FromAnimatable(content.Position));
-            result.Add(nameof(content.CornerRadius), FromAnimatable(content.CornerRadius));
+            result.Add(nameof(content.Roundness), FromAnimatable(content.Roundness));
             return result;
         }
 

source/LottieReader/Serialization/ShapeLayerContents.cs

@@ -326,23 +326,23 @@ Polystar ReadPolystar(
             var position = ReadAnimatableVector3(obj.ObjectPropertyOrNull("p"));
             var rotation = ReadAnimatableFloat(obj.ObjectPropertyOrNull("r"));
             var outerRadius = ReadAnimatableFloat(obj.ObjectPropertyOrNull("or"));
-            var outerRoundedness = ReadAnimatableFloat(obj.ObjectPropertyOrNull("os"));
+            var outerRoundness = ReadAnimatableFloat(obj.ObjectPropertyOrNull("os"));
 
             var polystarType = SyToPolystarType(obj.DoublePropertyOrNull("sy")) ?? Polystar.PolyStarType.Polygon;
 
             Animatable<double> innerRadius;
-            Animatable<double> innerRoundedness;
+            Animatable<double> innerRoundness;
 
             switch (polystarType)
             {
                 case Polystar.PolyStarType.Star:
                     innerRadius = ReadAnimatableFloat(obj.ObjectPropertyOrNull("ir"));
-                    innerRoundedness = ReadAnimatableFloat(obj.ObjectPropertyOrNull("is"));
+                    innerRoundness = ReadAnimatableFloat(obj.ObjectPropertyOrNull("is"));
                     break;
 
                 default:
                     innerRadius = null;
-                    innerRoundedness = null;
+                    innerRoundness = null;
                     break;
             }
 
@@ -356,8 +356,8 @@ Polystar ReadPolystar(
                 rotation,
                 innerRadius,
                 outerRadius,
-                innerRoundedness,
-                outerRoundedness);
+                innerRoundness,
+                outerRoundness);
         }
 
         Rectangle ReadRectangle(
@@ -370,10 +370,10 @@ Rectangle ReadRectangle(
             var drawingDirection = DToDrawingDirection(obj.DoublePropertyOrNull("d"));
             var position = ReadAnimatableVector3(obj.ObjectPropertyOrNull("p"));
             var size = ReadAnimatableVector3(obj.ObjectPropertyOrNull("s"));
-            var cornerRadius = ReadAnimatableFloat(obj.ObjectPropertyOrNull("r"));
+            var roundness = ReadAnimatableFloat(obj.ObjectPropertyOrNull("r"));
 
             obj.AssertAllPropertiesRead();
-            return new Rectangle(in shapeLayerContentArgs, drawingDirection, position, size, cornerRadius);
+            return new Rectangle(in shapeLayerContentArgs, drawingDirection, position, size, roundness);
         }
 
         Path ReadPath(

source/LottieToWinComp/ExpressionFactory.cs

@@ -27,6 +27,7 @@ static class ExpressionFactory
         internal static readonly Vector2 MyPosition = MyVector2("Position");
         internal static readonly Vector2 MySize = MyVector2("Size");
         internal static readonly Matrix3x2 MyTransformMatrix = MyMatrix3x2("TransformMatrix");
+        static readonly Scalar MyRoundness = MyScalar("Roundness");
         static readonly Scalar MyTStart = MyScalar("TStart");
         static readonly Scalar MyTEnd = MyScalar("TEnd");
 
@@ -67,6 +68,15 @@ internal static Color ColorMultipliedByPreMultipliedOpacities(Wui.Color color, S
 
         internal static Scalar RootScalar(string propertyName) => Scalar(RootProperty(propertyName));
 
+        internal static Vector2 ConstrainedCornerRadiusScalar(double roundness)
+            => Vector2(Min(roundness, Min(MySize.X, MySize.Y) / 2), Min(roundness, Min(MySize.X, MySize.Y) / 2));
+
+        internal static Vector2 ConstrainedCornerRadiusScalar()
+            => Vector2(Min(MyRoundness, Min(MySize.X, MySize.Y) / 2), Min(MyRoundness, Min(MySize.X, MySize.Y) / 2));
+
+        internal static Vector2 ConstrainedCornerRadiusScalar(Sn.Vector2 size)
+            => Vector2(Min(MyRoundness, Math.Min(size.X, size.Y) / 2), Min(MyRoundness, Math.Min(size.X, size.Y) / 2));
+
         // The value of a Color property stored as a Vector4 on the theming property set.
         static Vector4 ThemedColor4Property(string propertyName) => Vector4(ThemeProperty(propertyName));