/// <summary>
/// 拉伸 RectTransfrom
/// </summary>
public static void Stretch(StretchType type, RectTransform input)
{
switch (type)
{
case StretchType.StretchHorizontal:
{
input.anchorMin = new Vector2(0, 0.5f);
input.anchorMax = new Vector2(1, 0.5f);
input.pivot = new Vector2(0.5f, 0.5f);
input.offsetMin = new Vector2(0, input.offsetMin.y);
input.offsetMax = new Vector2(0, input.offsetMax.y);
}
return;
case StretchType.StretchVertical:
{
input.anchorMin = new Vector2(0.5f, 0);
input.anchorMax = new Vector2(0.5f, 1);
input.pivot = new Vector2(0.5f, 0.5f);
input.offsetMin = new Vector2(input.offsetMin.x, 0);
input.offsetMax = new Vector2(input.offsetMax.x, 0);
}
return;
case StretchType.StretchAll:
{
input.anchorMin = new Vector2(0, 0);
input.anchorMax = new Vector2(1, 1);
input.pivot = new Vector2(0.5f, 0.5f);
input.offsetMin = Vector2.zero;
input.offsetMax = Vector2.zero;
}
return;
}
}
public void SetStretch(bool screen, StretchType offsetType, Vector2 offsetValues)
{
screenStretch = screen;
stretchType = offsetType;
stretchValues = offsetValues;
if (uiStretch == null)
{
return;
}
uiStretch.container = screen ? null : uiLabel.gameObject;
switch (offsetType)
{
case StretchType.Pixel:
uiStretch.borderPadding = offsetValues;
uiStretch.relativeSize = Vector2.one;
break;
case StretchType.Relative:
uiStretch.relativeSize = offsetValues;
break;
default:
break;
}
return;
}
public void Init(float min = DEFAULT_IDEAL_MIN, float max = DEFAULT_IDEAL_MAX, float math = DEFAULT_MATCH)
{
if (!isInit)
{
screenSize = new Vector2(Screen.width, Screen.height);
screenRatio = screenSize.x / screenSize.y;
screenModle = screenSize.x > screenSize.y
? ScreenModle.Landscape
: ScreenModle.Portrait;
if (screenModle == ScreenModle.Portrait)
{
isiPhoneX = screenRatio.EQ(IPHONEX_MIN / IPHONEX_MAX);
idealSize = new Vector2(min, max);
}
else
{
isiPhoneX = screenRatio.EQ(IPHONEX_MAX / IPHONEX_MIN);
idealSize = new Vector2(max, min);
}
idealRatio = idealSize.x / idealSize.y;
// 计算canvas的大小
float logWidth = Mathf.Log(screenSize.x / idealSize.x, 2f);
float logHeight = Mathf.Log(screenSize.y / idealSize.y, 2f);
float scaleFactor = Mathf.Pow(2f, Mathf.Lerp(logWidth, logHeight, math));
canvasRealSize = screenSize / scaleFactor;
canvasSize = canvasRealSize;
// iphoneX顶部刘海，底部圆角都是无效区域
if (isiPhoneX)
{
canvasRealSize -= screenModle == ScreenModle.Portrait
? new Vector2(0, IPHONEX_INVALID_OFFSET)
: new Vector2(IPHONEX_INVALID_OFFSET, 0);
}
canvasRealRatio = canvasRealSize.x / canvasRealSize.y;
if (canvasRealRatio.EQ(idealRatio))
{
stretchType = StretchType.None; // 未拉伸
}
if (canvasRealRatio.GT(idealRatio))
{
stretchType = screenModle == ScreenModle.Portrait ? StretchType.Height : StretchType.Width; // eg：iphoneX
}
else
{
stretchType = screenModle == ScreenModle.Portrait ? StretchType.Width : StretchType.Height; //eg: ipad
}
isInit = true;
}
}
public static Bitmap Stretch(Bitmap image, int length, StretchType type)
{
Bitmap result;
switch (type)
{
case StretchType.ToRight:
result = new Bitmap(image, length, image.Height);
return(result);
default:
return(image);
}
}
private void TestArrangeOverrideInfiniteValues(StretchType stretch)
{
var imageSize = new Vector3(100, 50, 0);
var sprite = new Sprite {
Region = new Rectangle(0, 0, (int)imageSize.X, (int)imageSize.Y), Borders = new Vector4(1, 2, 3, 4)
};
var image = new ImageElement {
Source = (SpriteFromTexture)sprite, StretchType = stretch
};
image.Arrange(new Vector3(float.PositiveInfinity), false);
Assert.Equal(imageSize, image.RenderSize);
image.Arrange(new Vector3(150, float.PositiveInfinity, 10), false);
Assert.Equal(stretch == StretchType.None ? imageSize : new Vector3(150, 75, 0), image.RenderSize);
}
public void TestMeasureOverrideInfiniteValues(StretchType stretch)
{
var imageSize = new Vector3(100, 50, 0);
var Sprite = new Sprite {
Region = new Rectangle(0, 0, (int)imageSize.X, (int)imageSize.Y), Borders = new Vector4(1, 2, 3, 4)
};
var image = new ImageElement {
Source = Sprite, StretchType = stretch
};
image.Measure(new Vector3(float.PositiveInfinity));
Assert.AreEqual(imageSize, image.DesiredSizeWithMargins);
image.Measure(new Vector3(150, float.PositiveInfinity, 10));
Assert.AreEqual(stretch == StretchType.None ? imageSize : new Vector3(150, 75, 0), image.DesiredSizeWithMargins);
}
/// <summary>
/// Stretch shapes in the list
/// </summary>
/// <param name="stretchShapes">The shapes to stretch</param>
/// <param name="stretchAction">The function to use to stretch</param>
/// <param name="defaultReferenceEdge">The function to return the default reference edge</param>
/// <param name="stretchType">The type of stretch to perform</param>
private void Stretch(PowerPoint.ShapeRange stretchShapes, GetAppropriateStretchAction stretchAction,
GetDefaultReferenceEdge defaultReferenceEdge, StretchType stretchType)
{
if (!ValidateSelection(stretchShapes))
{
return;
}
var referenceShape = GetReferenceShape(stretchShapes, defaultReferenceEdge, stretchType);
var referenceEdge = defaultReferenceEdge(new PPShape(referenceShape));
for (var i = 1; i <= stretchShapes.Count; i++)
{
if (referenceShape.Equals(stretchShapes[i]))
{
continue;
}
var stretchShape = new PPShape(stretchShapes[i]);
var sa = stretchAction(referenceEdge, stretchShape);
sa(referenceEdge, stretchShape);
}
}
private PowerPoint.Shape GetReferenceShape(PowerPoint.ShapeRange shapes, GetDefaultReferenceEdge getReferenceEdge,
StretchType stretchType)
{
var refShapeIndex = 1;
if (ReferenceType == StretchRefType.Outermost)
{
var refPpShape = new PPShape(shapes[1]);
for (var i = 2; i <= shapes.Count; i++)
{
var tempPpShape = new PPShape(shapes[i]);
if (((stretchType == StretchType.Left || stretchType == StretchType.Top) &&
getReferenceEdge(refPpShape) > getReferenceEdge(tempPpShape)) ||
((stretchType == StretchType.Right || stretchType == StretchType.Bottom) &&
getReferenceEdge(refPpShape) < getReferenceEdge(tempPpShape)))
{
refPpShape = tempPpShape;
refShapeIndex = i;
}
}
}
return(shapes[refShapeIndex]);
}
public void TestArrangeOverrideInfiniteValues(StretchType stretch)
{
var imageSize = new Vector3(100, 50, 0);
var Sprite = new Sprite { Region = new Rectangle(0, 0, (int)imageSize.X, (int)imageSize.Y), Borders = new Vector4(1, 2, 3, 4) };
var image = new ImageElement { Source = Sprite, StretchType = stretch };
image.Arrange(new Vector3(float.PositiveInfinity), false);
Assert.AreEqual(imageSize, image.RenderSize);
image.Arrange(new Vector3(150, float.PositiveInfinity, 10), false);
Assert.AreEqual(stretch == StretchType.None ? imageSize : new Vector3(150, 75, 0), image.RenderSize);
}
/// <summary>
/// Calculates the actual image size from the size that is available.
/// </summary>
/// <param name="sprite"></param>
/// <param name="availableSizeWithoutMargins"></param>
/// <param name="stretchType"></param>
/// <param name="stretchDirection"></param>
/// <param name="isMeasuring"></param>
/// <returns></returns>
public static Vector3 CalculateImageSizeFromAvailable(Sprite sprite, Vector3 availableSizeWithoutMargins, StretchType stretchType, StretchDirection stretchDirection, bool isMeasuring)
{
if (sprite == null) // no associated image -> no region needed
{
return(Vector3.Zero);
}
var idealSize = sprite.SizeInPixels;
if (idealSize.X <= 0 || idealSize.Y <= 0) // image size null or invalid -> no region needed
{
return(Vector3.Zero);
}
if (float.IsInfinity(availableSizeWithoutMargins.X) && float.IsInfinity(availableSizeWithoutMargins.Y)) // unconstrained available size -> take the best size for the image: the image size
{
return(new Vector3(idealSize, 0));
}
// initialize the desired size with maximum available size
var desiredSize = availableSizeWithoutMargins;
// compute the desired image ratios
var desiredScale = new Vector2(desiredSize.X / idealSize.X, desiredSize.Y / idealSize.Y);
// when the size along a given axis is free take the same ratio as the constrained axis.
if (float.IsInfinity(desiredScale.X))
{
desiredScale.X = desiredScale.Y;
}
if (float.IsInfinity(desiredScale.Y))
{
desiredScale.Y = desiredScale.X;
}
// adjust the scales depending on the type of stretch to apply
switch (stretchType)
{
case StretchType.None:
desiredScale = Vector2.One;
break;
case StretchType.Uniform:
desiredScale.X = desiredScale.Y = Math.Min(desiredScale.X, desiredScale.Y);
break;
case StretchType.UniformToFill:
desiredScale.X = desiredScale.Y = Math.Max(desiredScale.X, desiredScale.Y);
break;
case StretchType.FillOnStretch:
// if we are only measuring we prefer keeping the image resolution than using all the available space.
if (isMeasuring)
{
desiredScale.X = desiredScale.Y = Math.Min(desiredScale.X, desiredScale.Y);
}
break;
case StretchType.Fill:
break;
default:
throw new ArgumentOutOfRangeException(nameof(stretchType));
}
// adjust the scales depending on the stretch directions
switch (stretchDirection)
{
case StretchDirection.Both:
break;
case StretchDirection.DownOnly:
desiredScale.X = Math.Min(desiredScale.X, 1);
desiredScale.Y = Math.Min(desiredScale.Y, 1);
break;
case StretchDirection.UpOnly:
desiredScale.X = Math.Max(1, desiredScale.X);
desiredScale.Y = Math.Max(1, desiredScale.Y);
break;
default:
throw new ArgumentOutOfRangeException(nameof(stretchDirection));
}
// update the desired size based on the desired scales
desiredSize = new Vector3(idealSize.X * desiredScale.X, idealSize.Y * desiredScale.Y, 0f);
if (!isMeasuring || !sprite.HasBorders)
{
return(desiredSize);
}
// consider sprite borders
var borderSum = new Vector2(sprite.BordersInternal.X + sprite.BordersInternal.Z, sprite.BordersInternal.Y + sprite.BordersInternal.W);
if (sprite.Orientation == ImageOrientation.Rotated90)
{
Utilities.Swap(ref borderSum.X, ref borderSum.Y);
}
return(new Vector3(Math.Max(desiredSize.X, borderSum.X), Math.Max(desiredSize.Y, borderSum.Y), desiredSize.Z));
}
private PowerPoint.Shape GetReferenceShape(PowerPoint.ShapeRange shapes, GetDefaultReferenceEdge getReferenceEdge,
StretchType stretchType)
{
var refShapeIndex = 1;
if (ReferenceType == StretchRefType.Outermost)
{
var refPpShape = new PPShape(shapes[1]);
for (var i = 2; i <= shapes.Count; i++)
{
var tempPpShape = new PPShape(shapes[i]);
if (((stretchType == StretchType.Left || stretchType == StretchType.Top) &&
getReferenceEdge(refPpShape) > getReferenceEdge(tempPpShape)) ||
((stretchType == StretchType.Right || stretchType == StretchType.Bottom) &&
getReferenceEdge(refPpShape) < getReferenceEdge(tempPpShape)))
{
refPpShape = tempPpShape;
refShapeIndex = i;
}
}
}
return shapes[refShapeIndex];
}
/// <summary>
/// Stretch shapes in the list
/// </summary>
/// <param name="stretchShapes">The shapes to stretch</param>
/// <param name="stretchAction">The function to use to stretch</param>
/// <param name="defaultReferenceEdge">The function to return the default reference edge</param>
/// <param name="stretchType">The type of stretch to perform</param>
private void Stretch(PowerPoint.ShapeRange stretchShapes, GetAppropriateStretchAction stretchAction,
GetDefaultReferenceEdge defaultReferenceEdge, StretchType stretchType)
{
if (!ValidateSelection(stretchShapes))
{
return;
}
var referenceShape = GetReferenceShape(stretchShapes, defaultReferenceEdge, stretchType);
var referenceEdge = defaultReferenceEdge(new PPShape(referenceShape));
for (var i = 1; i <= stretchShapes.Count; i++)
{
if (referenceShape.Equals(stretchShapes[i]))
{
continue;
}
var stretchShape = new PPShape(stretchShapes[i]);
var sa = stretchAction(referenceEdge, stretchShape);
sa(referenceEdge, stretchShape);
}
}
/// <summary>
/// Calculates the actual image size from the size that is available.
/// </summary>
/// <param name="sprite"></param>
/// <param name="availableSizeWithoutMargins"></param>
/// <param name="stretchType"></param>
/// <param name="stretchDirection"></param>
/// <param name="isMeasuring"></param>
/// <returns></returns>
public static Vector3 CalculateImageSizeFromAvailable(Sprite sprite, Vector3 availableSizeWithoutMargins, StretchType stretchType, StretchDirection stretchDirection, bool isMeasuring)
{
if (sprite == null) // no associated image -> no region needed
return Vector3.Zero;
var idealSize = sprite.SizeInPixels;
if (idealSize.X <= 0 || idealSize.Y <= 0) // image size null or invalid -> no region needed
return Vector3.Zero;
if (float.IsInfinity(availableSizeWithoutMargins.X) && float.IsInfinity(availableSizeWithoutMargins.Y)) // unconstrained available size -> take the best size for the image: the image size
return new Vector3(idealSize, 0);
// initialize the desired size with maximum available size
var desiredSize = availableSizeWithoutMargins;
// compute the desired image ratios
var desiredScale = new Vector2(desiredSize.X / idealSize.X, desiredSize.Y / idealSize.Y);
// when the size along a given axis is free take the same ratio as the constrained axis.
if (float.IsInfinity(desiredScale.X))
desiredScale.X = desiredScale.Y;
if (float.IsInfinity(desiredScale.Y))
desiredScale.Y = desiredScale.X;
// adjust the scales depending on the type of stretch to apply
switch (stretchType)
{
case StretchType.None:
desiredScale = Vector2.One;
break;
case StretchType.Uniform:
desiredScale.X = desiredScale.Y = Math.Min(desiredScale.X, desiredScale.Y);
break;
case StretchType.UniformToFill:
desiredScale.X = desiredScale.Y = Math.Max(desiredScale.X, desiredScale.Y);
break;
case StretchType.FillOnStretch:
// if we are only measuring we prefer keeping the image resolution than using all the available space.
if (isMeasuring)
desiredScale.X = desiredScale.Y = Math.Min(desiredScale.X, desiredScale.Y);
break;
case StretchType.Fill:
break;
default:
throw new ArgumentOutOfRangeException(nameof(stretchType));
}
// adjust the scales depending on the stretch directions
switch (stretchDirection)
{
case StretchDirection.Both:
break;
case StretchDirection.DownOnly:
desiredScale.X = Math.Min(desiredScale.X, 1);
desiredScale.Y = Math.Min(desiredScale.Y, 1);
break;
case StretchDirection.UpOnly:
desiredScale.X = Math.Max(1, desiredScale.X);
desiredScale.Y = Math.Max(1, desiredScale.Y);
break;
default:
throw new ArgumentOutOfRangeException(nameof(stretchDirection));
}
// update the desired size based on the desired scales
desiredSize = new Vector3(idealSize.X * desiredScale.X, idealSize.Y * desiredScale.Y, 0f);
if (!isMeasuring || !sprite.HasBorders)
return desiredSize;
// consider sprite borders
var borderSum = new Vector2(sprite.BordersInternal.X + sprite.BordersInternal.Z, sprite.BordersInternal.Y + sprite.BordersInternal.W);
if (sprite.Orientation == ImageOrientation.Rotated90)
Utilities.Swap(ref borderSum.X, ref borderSum.Y);
return new Vector3(Math.Max(desiredSize.X, borderSum.X), Math.Max(desiredSize.Y, borderSum.Y), desiredSize.Z);
}
public void TestMeasureOverrideInfiniteValues(StretchType stretch)
{
var imageSize = new Vector3(100, 50, 0);
var sprite = new Sprite { Region = new Rectangle(0, 0, (int)imageSize.X, (int)imageSize.Y), Borders = new Vector4(1, 2, 3, 4) };
var image = new ImageElement { Source = (SpriteFromTexture)sprite, StretchType = stretch };
image.Measure(new Vector3(float.PositiveInfinity));
Assert.AreEqual(imageSize, image.DesiredSizeWithMargins);
image.Measure(new Vector3(150, float.PositiveInfinity, 10));
Assert.AreEqual(stretch == StretchType.None ? imageSize : new Vector3(150, 75, 0), image.DesiredSizeWithMargins);
}