public override ShapeBorder lerpTo(ShapeBorder b, float t)
{
if (b is StadiumBorder stadiumBorder)
{
return(new _StadiumToRoundedRectangleBorder(
side: BorderSide.lerp(this.side, stadiumBorder.side, t),
borderRadius: this.borderRadius,
rectness: this.rectness * (1.0f - t)
));
}
if (b is RoundedRectangleBorder rectBorder)
{
return(new _StadiumToRoundedRectangleBorder(
side: BorderSide.lerp(this.side, rectBorder.side, t),
borderRadius: this.borderRadius,
rectness: this.rectness + (1.0f - this.rectness) * t
));
}
if (b is _StadiumToRoundedRectangleBorder border)
{
return(new _StadiumToRoundedRectangleBorder(
side: BorderSide.lerp(this.side, border.side, t),
borderRadius: BorderRadius.lerp(this.borderRadius, border.borderRadius, t),
rectness: MathUtils.lerpFloat(this.rectness, border.rectness, t)
));
}
return(base.lerpTo(b, t));
}
public static ShapeDecoration lerp(ShapeDecoration a, ShapeDecoration b, float t)
{
if (a == null && b == null)
{
return(null);
}
if (a != null && b != null)
{
if (t == 0.0)
{
return(a);
}
if (t == 1.0)
{
return(b);
}
}
return(new ShapeDecoration(
color: Color.lerp(a?.color, b?.color, t),
gradient: Gradient.lerp(a?.gradient, b?.gradient, t),
image: t < 0.5 ? a.image : b.image,
shadows: BoxShadow.lerpList(a?.shadows, b?.shadows, t),
shape: ShapeBorder.lerp(a?.shape, b?.shape, t)
));
}
public override ShapeBorder lerpTo(ShapeBorder b, float t)
{
if (b is StadiumBorder stadiumBorder)
{
return(new StadiumBorder(side: BorderSide.lerp(this.side, stadiumBorder.side, t)));
}
if (b is CircleBorder circleBorder)
{
return(new _StadiumToCircleBorder(
side: BorderSide.lerp(this.side, circleBorder.side, t),
circleness: t
));
}
if (b is RoundedRectangleBorder rectBorder)
{
return(new _StadiumToRoundedRectangleBorder(
side: BorderSide.lerp(this.side, rectBorder.side, t),
borderRadius: rectBorder.borderRadius,
rectness: t
));
}
return(base.lerpTo(b, t));
}
public override ShapeBorder lerpFrom(ShapeBorder a, float t)
{
if (a is StadiumBorder stadiumBorder)
{
return(new StadiumBorder(side: BorderSide.lerp(stadiumBorder.side, this.side, t)));
}
if (a is CircleBorder circleBorder)
{
return(new _StadiumToCircleBorder(
side: BorderSide.lerp(circleBorder.side, this.side, t),
circleness: 1.0f - t
));
}
if (a is RoundedRectangleBorder rectBorder)
{
return(new _StadiumToRoundedRectangleBorder(
side: BorderSide.lerp(rectBorder.side, this.side, t),
borderRadius: rectBorder.borderRadius,
rectness: 1.0f - t
));
}
return(base.lerpFrom(a, t));
}
public override ShapeBorder lerpFrom(ShapeBorder a, double t)
{
if (a is StadiumBorder stadiumBorder)
{
return(new _StadiumToRoundedRectangleBorder(
side: BorderSide.lerp(stadiumBorder.side, this.side, t),
borderRadius: this.borderRadius,
rectness: this.rectness * t
));
}
if (a is RoundedRectangleBorder rectBorder)
{
return(new _StadiumToRoundedRectangleBorder(
side: BorderSide.lerp(rectBorder.side, this.side, t),
borderRadius: this.borderRadius,
rectness: this.rectness + (1.0 - this.rectness) * (1.0 - t)
));
}
if (a is _StadiumToRoundedRectangleBorder border)
{
return(new _StadiumToRoundedRectangleBorder(
side: BorderSide.lerp(border.side, this.side, t),
borderRadius: BorderRadius.lerp(border.borderRadius, this.borderRadius, t),
rectness: MathUtils.lerpDouble(border.rectness, this.rectness, t)
));
}
return(base.lerpFrom(a, t));
}
public override ShapeBorder lerpTo(ShapeBorder b, float t)
{
if (b is RoundedRectangleBorder rectBorder)
{
return(new _RoundedRectangleToCircleBorder(
side: BorderSide.lerp(side, rectBorder.side, t),
borderRadius: BorderRadius.lerp(borderRadius, rectBorder.borderRadius, t),
circleness: circleness * (1.0f - t)
));
}
if (b is CircleBorder circleBorder)
{
return(new _RoundedRectangleToCircleBorder(
side: BorderSide.lerp(side, circleBorder.side, t),
borderRadius: borderRadius,
circleness: circleness + (1.0f - circleness) * t
));
}
if (b is _RoundedRectangleToCircleBorder border)
{
return(new _RoundedRectangleToCircleBorder(
side: BorderSide.lerp(side, border.side, t),
borderRadius: BorderRadius.lerp(borderRadius, border.borderRadius, t),
circleness: MathUtils.lerpNullableFloat(circleness, border.circleness, t)
));
}
return(base.lerpTo(b, t));
}
public override ShapeBorder lerpFrom(ShapeBorder a, float t)
{
if (a is StadiumBorder stadiumBorder)
{
return(new _StadiumToRoundedRectangleBorder(
side: BorderSide.lerp(stadiumBorder.side, side, t),
borderRadius: borderRadius,
rectness: rectness * t
));
}
if (a is RoundedRectangleBorder rectBorder)
{
return(new _StadiumToRoundedRectangleBorder(
side: BorderSide.lerp(rectBorder.side, side, t),
borderRadius: borderRadius,
rectness: rectness + (1.0f - rectness) * (1.0f - t)
));
}
if (a is _StadiumToRoundedRectangleBorder border)
{
return(new _StadiumToRoundedRectangleBorder(
side: BorderSide.lerp(border.side, side, t),
borderRadius: BorderRadius.lerp(border.borderRadius, borderRadius, t),
rectness: MathUtils.lerpNullableFloat(border.rectness, rectness, t)
));
}
return(base.lerpFrom(a, t));
}
public override ShapeBorder lerpFrom(ShapeBorder a, float t)
{
if (a is RoundedRectangleBorder rectBorder)
{
return(new _RoundedRectangleToCircleBorder(
side: BorderSide.lerp(rectBorder.side, this.side, t),
borderRadius: BorderRadius.lerp(rectBorder.borderRadius, this.borderRadius, t),
circleness: this.circleness * t
));
}
if (a is CircleBorder circleBorder)
{
return(new _RoundedRectangleToCircleBorder(
side: BorderSide.lerp(circleBorder.side, this.side, t),
borderRadius: this.borderRadius,
circleness: this.circleness + (1.0f - this.circleness) * (1.0f - t)
));
}
if (a is _RoundedRectangleToCircleBorder border)
{
return(new _RoundedRectangleToCircleBorder(
side: BorderSide.lerp(border.side, this.side, t),
borderRadius: BorderRadius.lerp(border.borderRadius, this.borderRadius, t),
circleness: MathUtils.lerpFloat(border.circleness, this.circleness, t)
));
}
return(base.lerpFrom(a, t));
}
public override ShapeBorder lerpTo(ShapeBorder b, double t)
{
if (b is RoundedRectangleBorder rectBorder)
{
return(new _RoundedRectangleToCircleBorder(
side: BorderSide.lerp(this.side, rectBorder.side, t),
borderRadius: BorderRadius.lerp(this.borderRadius, rectBorder.borderRadius, t),
circleness: this.circleness * (1.0 - t)
));
}
if (b is CircleBorder circleBorder)
{
return(new _RoundedRectangleToCircleBorder(
side: BorderSide.lerp(this.side, circleBorder.side, t),
borderRadius: this.borderRadius,
circleness: this.circleness + (1.0 - this.circleness) * t
));
}
if (b is _RoundedRectangleToCircleBorder border)
{
return(new _RoundedRectangleToCircleBorder(
side: BorderSide.lerp(this.side, border.side, t),
borderRadius: BorderRadius.lerp(this.borderRadius, border.borderRadius, t),
circleness: MathUtils.lerpDouble(this.circleness, border.circleness, t)
));
}
return(base.lerpTo(b, t));
}
public override ShapeBorder lerpTo(ShapeBorder b, float t)
{
if (b is StadiumBorder stadiumBorder)
{
return(new _StadiumToCircleBorder(
side: BorderSide.lerp(this.side, stadiumBorder.side, t),
circleness: this.circleness * (1.0f - t)
));
}
if (b is CircleBorder circleBorder)
{
return(new _StadiumToCircleBorder(
side: BorderSide.lerp(this.side, circleBorder.side, t),
circleness: this.circleness + (1.0f - this.circleness) * t
));
}
if (b is _StadiumToCircleBorder border)
{
return(new _StadiumToCircleBorder(
side: BorderSide.lerp(this.side, border.side, t),
circleness: MathUtils.lerpFloat(this.circleness, border.circleness, t)
));
}
return(base.lerpTo(b, t));
}
public override ShapeBorder lerpFrom(ShapeBorder a, float t)
{
if (a is StadiumBorder stadiumBorder)
{
return(new _StadiumToCircleBorder(
side: BorderSide.lerp(stadiumBorder.side, this.side, t),
circleness: this.circleness * t
));
}
if (a is CircleBorder circleBorder)
{
return(new _StadiumToCircleBorder(
side: BorderSide.lerp(circleBorder.side, this.side, t),
circleness: this.circleness + (1.0f - this.circleness) * (1.0f - t)
));
}
if (a is _StadiumToCircleBorder border)
{
return(new _StadiumToCircleBorder(
side: BorderSide.lerp(border.side, this.side, t),
circleness: MathUtils.lerpFloat(border.circleness, this.circleness, t)
));
}
return(base.lerpFrom(a, t));
}
public override ShapeBorder lerpFrom(ShapeBorder a, double t)
{
if (a is Border border)
{
return(lerp(border, this, t));
}
return(base.lerpFrom(a, t));
}
public virtual ShapeBorder lerpFrom(ShapeBorder a, float t)
{
if (a == null)
{
return(this.scale(t));
}
return(null);
}
public override ShapeBorder lerpTo(ShapeBorder b, double t)
{
if (b is Border border)
{
return(lerp(this, border, t));
}
return(base.lerpTo(b, t));
}
public virtual ShapeBorder lerpTo(ShapeBorder b, float t)
{
if (b == null)
{
return(this.scale(1.0f - t));
}
return(null);
}
public override ShapeBorder lerpTo(ShapeBorder b, float t)
{
if (b is CircleBorder border)
{
return(new CircleBorder(side: BorderSide.lerp(side, border.side, t)));
}
return(base.lerpTo(b, t));
}
public override ShapeBorder lerpFrom(ShapeBorder a, float t)
{
if (a is CircleBorder border)
{
return(new CircleBorder(side: BorderSide.lerp(border.side, side, t)));
}
return(base.lerpFrom(a, t));
}
public override ShapeBorder lerpFrom(ShapeBorder a, double t)
{
if (a is BeveledRectangleBorder border)
{
return(new BeveledRectangleBorder(
side: BorderSide.lerp(border.side, this.side, t),
borderRadius: BorderRadius.lerp(border.borderRadius, this.borderRadius, t)
));
}
return(base.lerpFrom(a, t));
}
public override ShapeBorder lerpTo(ShapeBorder b, double t)
{
if (b is BeveledRectangleBorder border)
{
return(new BeveledRectangleBorder(
side: BorderSide.lerp(this.side, border.side, t),
borderRadius: BorderRadius.lerp(this.borderRadius, border.borderRadius, t)
));
}
return(base.lerpTo(b, t));
}
public override ShapeBorder lerpTo(ShapeBorder b, float t)
{
if (b is ContinuousRectangleBorder)
{
return(new ContinuousRectangleBorder(
side: BorderSide.lerp(this.side, (b as ContinuousRectangleBorder).side, t),
borderRadius: BorderRadius.lerp(this.borderRadius,
(b as ContinuousRectangleBorder).borderRadius, t)
));
}
return(base.lerpTo(b, t));
}
public override ShapeBorder lerpFrom(ShapeBorder a, float t)
{
if (a is ContinuousRectangleBorder)
{
return(new ContinuousRectangleBorder(
side: BorderSide.lerp((a as ContinuousRectangleBorder).side, this.side, t),
borderRadius: BorderRadius.lerp((a as ContinuousRectangleBorder).borderRadius,
this.borderRadius, t)
));
}
return(base.lerpFrom(a, t));
}
public static ShapeBorder lerp(ShapeBorder a, ShapeBorder b, float t)
{
ShapeBorder result = null;
if (b != null)
{
result = b.lerpFrom(a, t);
}
if (result == null && a != null)
{
result = a.lerpTo(b, t);
}
return(result ?? (t < 0.5 ? a : b));
}
public ShapeDecoration(
Color color = null,
DecorationImage image = null,
Gradient gradient = null,
List <BoxShadow> shadows = null,
ShapeBorder shape = null
)
{
D.assert(!(color != null && gradient != null));
D.assert(shape != null);
this.color = color;
this.image = image;
this.gradient = gradient;
this.shadows = shadows;
this.shape = shape;
}
public override ShapeBorder add(ShapeBorder other, bool reversed = false)
{
if (!(other is Border border))
{
return(null);
}
if (BorderSide.canMerge(this.top, border.top) &&
BorderSide.canMerge(this.right, border.right) &&
BorderSide.canMerge(this.bottom, border.bottom) &&
BorderSide.canMerge(this.left, border.left))
{
return(merge(this, border));
}
return(null);
}
public static ShapeDecoration fromBoxDecoration(BoxDecoration source)
{
ShapeBorder shape = null;
switch (source.shape)
{
case BoxShape.circle:
if (source.border != null)
{
D.assert(source.border.isUniform);
shape = new CircleBorder(side: source.border.top);
}
else
{
shape = new CircleBorder();
}
break;
case BoxShape.rectangle:
if (source.borderRadius != null)
{
D.assert(source.border == null || source.border.isUniform);
shape = new RoundedRectangleBorder(
side: source.border?.top ?? BorderSide.none,
borderRadius: source.borderRadius
);
}
else
{
shape = source.border ?? new Border();
}
break;
}
return(new ShapeDecoration(
color: source.color,
image: source.image,
gradient: source.gradient,
shadows: source.boxShadow,
shape: shape
));
}
public override ShapeBorder lerpFrom(ShapeBorder a, float t)
{
if (a is RoundedRectangleBorder border)
{
return(new RoundedRectangleBorder(
side: BorderSide.lerp(border.side, side, t),
borderRadius: BorderRadius.lerp(border.borderRadius, borderRadius, t)
));
}
if (a is CircleBorder circleBorder)
{
return(new _RoundedRectangleToCircleBorder(
side: BorderSide.lerp(circleBorder.side, side, t),
borderRadius: borderRadius,
circleness: 1.0f - t
));
}
return(base.lerpFrom(a, t));
}
public override ShapeBorder lerpTo(ShapeBorder b, float t)
{
if (b is RoundedRectangleBorder border)
{
return(new RoundedRectangleBorder(
side: BorderSide.lerp(side, border.side, t),
borderRadius: BorderRadius.lerp(borderRadius, border.borderRadius, t)
));
}
if (b is CircleBorder circleBorder)
{
return(new _RoundedRectangleToCircleBorder(
side: BorderSide.lerp(side, circleBorder.side, t),
borderRadius: borderRadius,
circleness: t
));
}
return(base.lerpTo(b, t));
}
public new static _CompoundBorder lerp(ShapeBorder a, ShapeBorder b, float t)
{
D.assert(a is _CompoundBorder || b is _CompoundBorder);
List <ShapeBorder> aList = a is _CompoundBorder aBorder ? aBorder.borders : new List <ShapeBorder> {
a
};
List <ShapeBorder> bList = b is _CompoundBorder bBorder ? bBorder.borders : new List <ShapeBorder> {
b
};
List <ShapeBorder> results = new List <ShapeBorder>();
int length = Mathf.Max(aList.Count, bList.Count);
for (int index = 0; index < length; index += 1)
{
ShapeBorder localA = index < aList.Count ? aList[index] : null;
ShapeBorder localB = index < bList.Count ? bList[index] : null;
if (localA != null && localB != null)
{
ShapeBorder localResult = localA.lerpTo(localB, t) ?? localB.lerpFrom(localA, t);
if (localResult != null)
{
results.Add(localResult);
continue;
}
}
if (localB != null)
{
results.Add(localB.scale(t));
}
if (localA != null)
{
results.Add(localA.scale(1.0f - t));
}
}
return(new _CompoundBorder(results));
}
public override ShapeBorder add(ShapeBorder other, bool reversed = false)
{
if (!(other is _CompoundBorder))
{
ShapeBorder ours = reversed ? this.borders.Last() : this.borders.First();
ShapeBorder merged = ours.add(other, reversed: reversed) ?? other.add(ours, reversed: !reversed);
if (merged != null)
{
List <ShapeBorder> result = new List <ShapeBorder>(this.borders);
result[reversed ? result.Count - 1 : 0] = merged;
return(new _CompoundBorder(result));
}
}
List <ShapeBorder> mergedBorders = new List <ShapeBorder>();
if (reversed)
{
mergedBorders.AddRange(this.borders);
}
if (other is _CompoundBorder border)
{
mergedBorders.AddRange(border.borders);
}
else
{
mergedBorders.Add(other);
}
if (!reversed)
{
mergedBorders.AddRange(this.borders);
}
return(new _CompoundBorder(mergedBorders));
}
public override ShapeBorder lerpTo(ShapeBorder b, float t)
{
return(lerp(this, b, t));
}
