void GetInsetAndEdges(float chWidth, float chHeight, out RectTransform.Edge xInsetEdge, out RectTransform.Edge yInsetEdge, out float xAddInset, out float yAddInset)
{
var gridRect = rectTransform.rect;
xInsetEdge = RectTransform.Edge.Left;
yInsetEdge = RectTransform.Edge.Top;
xAddInset = 0f;
yAddInset = 0f;
if (m_childrenControlSize != AxisOrNone.Horizontal)
{
switch (childAlignment)
{
case TextAnchor.UpperLeft:
case TextAnchor.LowerLeft:
case TextAnchor.MiddleLeft:
xInsetEdge = RectTransform.Edge.Left;
xAddInset = padding.left;
break;
case TextAnchor.UpperRight:
case TextAnchor.LowerRight:
case TextAnchor.MiddleRight:
xInsetEdge = RectTransform.Edge.Right;
xAddInset = padding.right;
break;
case TextAnchor.UpperCenter:
case TextAnchor.MiddleCenter:
case TextAnchor.LowerCenter:
xAddInset = Mathf.Max((gridRect.width - chWidth), padding.horizontal) / 2f;
break;
}
}
if (m_childrenControlSize != AxisOrNone.Vertical)
{
switch (childAlignment)
{
case TextAnchor.UpperLeft:
case TextAnchor.UpperCenter:
case TextAnchor.UpperRight:
yInsetEdge = RectTransform.Edge.Top;
yAddInset = padding.top;
break;
case TextAnchor.LowerLeft:
case TextAnchor.LowerCenter:
case TextAnchor.LowerRight:
yInsetEdge = RectTransform.Edge.Bottom;
yAddInset = padding.bottom;
break;
case TextAnchor.MiddleLeft:
case TextAnchor.MiddleCenter:
case TextAnchor.MiddleRight:
yAddInset = Mathf.Max((gridRect.height - chHeight), padding.vertical) / 2f;
break;
}
}
}
/// <summary>
/// 设置item的位置
/// </summary>
/// <param name="rect">RectTransform</param>
/// <param name="axis">轴</param>
/// <param name="pos">相对的距离</param>
/// <param name="size">item 的大小</param>
protected void SetChildAlongAxis(RectTransform rect, int axis, float pos, float size)
{
if (rect == null)
{
return;
}
RectTransform.Edge edge = axis == 0 ? RectTransform.Edge.Left : RectTransform.Edge.Top;
if (Direction == XLayoutRule.Direction.Horizontal)
{
if (axis == 0 && Order == XLayoutRule.Order.Reverse)
{
edge = RectTransform.Edge.Right;
}
else if (axis == 0 && Order == XLayoutRule.Order.Positive)
{
edge = RectTransform.Edge.Left;
}
}
else if (Direction == XLayoutRule.Direction.Vertical)
{
if (axis == 1 && Order == XLayoutRule.Order.Reverse)
{
edge = RectTransform.Edge.Bottom;
}
else if (axis == 1 && Order == XLayoutRule.Order.Positive)
{
edge = RectTransform.Edge.Top;
}
}
/*相对于父节点的停靠位置*/
rect.SetInsetAndSizeFromParentEdge(edge, pos, size);
}
public static void SetRect(this RectTransform trs, RectTransform.Edge edge, float value)
{
float _left = trs.offsetMin.x;
float _right = -trs.offsetMax.x;
float _top = -trs.offsetMax.y;
float _bottom = trs.offsetMin.y;
switch (edge)
{
case RectTransform.Edge.Left:
_left = value;
break;
case RectTransform.Edge.Right:
_right = value;
break;
case RectTransform.Edge.Top:
_top = value;
break;
case RectTransform.Edge.Bottom:
_bottom = value;
break;
}
trs.SetRect(_left, _top, _right, _bottom);
}
public static Ref <float> ToEdgeInsetRef(this RectTransform transform, RectTransform.Edge edge)
{
CheckTransformNonNull(transform);
return(new Ref <float>(
() => {
switch (edge)
{
case RectTransform.Edge.Bottom:
return transform.offsetMin.y;
case RectTransform.Edge.Left:
return transform.offsetMin.x;
case RectTransform.Edge.Right:
return transform.offsetMax.x;
case RectTransform.Edge.Top:
return transform.offsetMax.y;
}
return 0f;
},
t => {
var size = transform.rect.size;
float lengthSize = size.x;
if (edge == RectTransform.Edge.Top || edge == RectTransform.Edge.Bottom)
{
lengthSize = size.y;
}
transform.SetInsetAndSizeFromParentEdge(edge, t, lengthSize);
}
));
}
public float GetEdgePosition_AsFloat(RectTransform.Edge edge, bool extendToLine = false)
{
var edgeLocal = GetEdgePosition_AsFloat_Local(edge);
var parentAxis = TextMesh.rectTransform.GetAxisPosition_AsFloat(edge.Axis());
return(parentAxis + edgeLocal);
}
public static void LineUp(ICollection <RectTransform> suspects, RectTransform.Edge direction, float padding = 0)
{
var leader = suspects.First();
var followers = suspects.Skip(1);
LineUp(leader, followers, direction, padding);
}
public void Rebuild(int numSlots)
{
slotPrefab.gameObject.SetActive(true);
// Clear prev
if (slots != null)
{
foreach (var v in slots)
{
Destroy(v.gameObject);
}
}
// Add new
slots = new RectTransform[numSlots];
float sizesCumm = 0;
float slotSize = _ScrollbarPanelRT.rect.size[_OneIfVert_ZeroIfHor] / numSlots; // not using the handle's size because of rounding errors with higher <numSlots>
RectTransform.Edge edgeToInsetFrom = _OneIfVert_ZeroIfHor == 1 ? RectTransform.Edge.Top : RectTransform.Edge.Left;
for (int i = 0; i < numSlots; i++)
{
var slot = (Instantiate(slotPrefab.gameObject) as GameObject).GetComponent <RectTransform>();
slots[i] = slot;
slot.SetParent(slotsParent, false);
slot.SetInsetAndSizeFromParentEdgeWithCurrentAnchors(edgeToInsetFrom, sizesCumm, slotSize);
sizesCumm += slotSize;
int copyOfI = i;
slot.GetComponentInChildren <Button>().onClick.AddListener(() => { if (OnSlotSelected != null)
{
OnSlotSelected.Invoke(copyOfI);
}
});
}
slotPrefab.gameObject.SetActive(false);
}
private float GetCurrentInset(RectTransform.Edge edge, RectTransform rect)
{
int cornerIndex = (edge == RectTransform.Edge.Top || edge == RectTransform.Edge.Right) ? 2 : 0;
Vector3[] corners = new Vector3[4];
rect.GetWorldCorners(corners);
Vector3[] parentCorners = new Vector3[4];
parent.GetWorldCorners(parentCorners);
Vector2 localChildCorner = parent.InverseTransformPoint(corners[cornerIndex]);
Vector2 localParentCorner = parent.InverseTransformPoint(parentCorners[cornerIndex]);
switch (edge)
{
case RectTransform.Edge.Left:
return(localChildCorner.x - localParentCorner.x);
case RectTransform.Edge.Right:
return(localParentCorner.x - localChildCorner.x);
case RectTransform.Edge.Top:
return(localParentCorner.y - localChildCorner.y);
case RectTransform.Edge.Bottom:
return(localChildCorner.y - localParentCorner.y);
default:
throw new Exception("Unity team added fifth edge. Why.");
}
}
public static void SetSizeWithEdge(this RectTransform trans,
RectTransform.Edge edge,
float size,
Vector2 originOffsetMax,
Vector2 originOffsetMin,
Vector2 originPosition)
{
switch (edge)
{
case RectTransform.Edge.Bottom:
trans.offsetMin = new Vector2(trans.offsetMin.x, (originOffsetMin.y - size) + originPosition.y);
break;
case RectTransform.Edge.Left:
trans.offsetMin = new Vector2((originOffsetMin.x - size) + originPosition.x, trans.offsetMin.y);
break;
case RectTransform.Edge.Top:
trans.offsetMax = new Vector2(trans.offsetMax.x, (originOffsetMax.y + size) + originPosition.y);
break;
case RectTransform.Edge.Right:
trans.offsetMax = new Vector2((originOffsetMax.x + size) + originPosition.x, trans.offsetMax.y);
break;
}
}
void SetSizeWithEdge(RectTransform target, RectTransform.Edge edge, float size)
{
target.SetSizeWithEdge(edge,
float.IsNaN(size) ? 0 : size,
this.originOffsetMax,
this.originOffsetMin,
this.originPosition);
}
public static float GetEdgePosition_AsFloat(this RectTransform me, RectTransform.Edge edge)
{
var relevantPosition = me.position[edge.Axis().CoordinateIndex()];
var distanceToEdge = me.DistanceFromPivotToEdge(edge);
var edgePosition = relevantPosition + (distanceToEdge * edge.Direction());
return(edgePosition);
}
private void PosisionarControles(GameObject control, float ejey, float ejex, RectTransform.Edge edge)
{
control.transform.SetParent(Ancla.transform);
RectTransform cached = control.GetComponent <RectTransform>();
cached.SetInsetAndSizeFromParentEdge(edge, ejex, cached.sizeDelta.x);
cached.SetInsetAndSizeFromParentEdge(RectTransform.Edge.Top, ejey, 30);
}
/// <summary>
/// Gets the relevant <see cref="RectTransform.Axis"/> for <paramref name="edge"/>, i.e. <see cref="RectTransform.Edge.Bottom"/> -> <see cref="RectTransform.Axis.Vertical"/>.
/// </summary>
/// <param name="edge"></param>
/// <returns></returns>
/// <exception cref="InvalidEnumArgumentException"></exception>
public static RectTransform.Axis Axis(this RectTransform.Edge edge)
{
return(edge switch {
RectTransform.Edge.Left => RectTransform.Axis.Horizontal,
RectTransform.Edge.Right => RectTransform.Axis.Horizontal,
RectTransform.Edge.Top => RectTransform.Axis.Vertical,
RectTransform.Edge.Bottom => RectTransform.Axis.Vertical,
_ => throw EnumUtils.InvalidEnumArgumentException(nameof(edge), edge)
});
private Vector2 CalculateOutPosition(RectTransform.Edge edge)
{
Vector2 startPosition = rectTransform.anchoredPosition;
#region Calculate off-screen position
RectTransform parent = rectTransform.parent.GetComponent <RectTransform>();
float edgePosition = 0;
float edgeDistance = 0;
float parentDist = 0;
float relativeAnchorPosition = 0;
switch (edge)
{
case RectTransform.Edge.Left:
edgePosition = rectTransform.anchoredPosition.x + rectTransform.rect.xMax;
relativeAnchorPosition = Mathf.Lerp(rectTransform.anchorMin.x, rectTransform.anchorMax.x, rectTransform.pivot.x);
parentDist = parent.rect.width * relativeAnchorPosition;
edgeDistance = edgePosition + extraOutMarginal + parentDist;
rectTransform.anchoredPosition -= new Vector2(edgeDistance, 0);
break;
case RectTransform.Edge.Right:
edgePosition = rectTransform.anchoredPosition.x + rectTransform.rect.xMin;
relativeAnchorPosition = 1f - Mathf.Lerp(rectTransform.anchorMin.x, rectTransform.anchorMax.x, rectTransform.pivot.x);
parentDist = parent.rect.width * relativeAnchorPosition;
edgeDistance = edgePosition - extraOutMarginal - parentDist;
rectTransform.anchoredPosition -= new Vector2(edgeDistance, 0);
break;
case RectTransform.Edge.Bottom:
edgePosition = rectTransform.anchoredPosition.y + rectTransform.rect.yMax;
relativeAnchorPosition = Mathf.Lerp(rectTransform.anchorMin.y, rectTransform.anchorMax.y, rectTransform.pivot.y);
parentDist = parent.rect.height * relativeAnchorPosition;
edgeDistance = edgePosition + extraOutMarginal + parentDist;
rectTransform.anchoredPosition -= new Vector2(0, edgeDistance);
break;
case RectTransform.Edge.Top:
edgePosition = rectTransform.anchoredPosition.y + rectTransform.rect.yMin;
relativeAnchorPosition = 1f - Mathf.Lerp(rectTransform.anchorMin.y, rectTransform.anchorMax.y, rectTransform.pivot.y);
parentDist = parent.rect.height * relativeAnchorPosition;
edgeDistance = edgePosition - extraOutMarginal - parentDist;
rectTransform.anchoredPosition -= new Vector2(0, edgeDistance);
break;
}
#endregion
Vector2 result = rectTransform.anchoredPosition;
rectTransform.anchoredPosition = startPosition;
return(result);
}
static int SetInsetAndSizeFromParentEdge(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 4);
RectTransform obj = (RectTransform)LuaScriptMgr.GetUnityObjectSelf(L, 1, "RectTransform");
RectTransform.Edge arg0 = (RectTransform.Edge)LuaScriptMgr.GetNetObject(L, 2, typeof(RectTransform.Edge));
float arg1 = (float)LuaScriptMgr.GetNumber(L, 3);
float arg2 = (float)LuaScriptMgr.GetNumber(L, 4);
obj.SetInsetAndSizeFromParentEdge(arg0, arg1, arg2);
return(0);
}
private static int SetInsetAndSizeFromParentEdge(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 4);
RectTransform rectTransform = (RectTransform)LuaScriptMgr.GetUnityObjectSelf(L, 1, "RectTransform");
RectTransform.Edge edge = (RectTransform.Edge)((int)LuaScriptMgr.GetNetObject(L, 2, typeof(RectTransform.Edge)));
float inset = (float)LuaScriptMgr.GetNumber(L, 3);
float size = (float)LuaScriptMgr.GetNumber(L, 4);
rectTransform.SetInsetAndSizeFromParentEdge(edge, inset, size);
return(0);
}
public static RectTransform Align(this RectTransform me, RectTransform.Edge edge, float target)
{
var edgePosition = me.GetEdgePosition_AsFloat(edge);
var offset = target - edgePosition;
var offsetVector = new Vector3 {
[edge.Axis().CoordinateIndex()] = offset
};
me.position += offsetVector;
return(me);
}
public void ResizeExtension()
{
RectTransform.Edge edge = RectTransform.Edge.Right;
float inset = ZonesViewer.Width - ZonesViewer.ScrollbarWidth;
float width = ((RectTransform)Viewer.transform).rect.width - ZonesViewer.Width + (Viewer.IsExtended ? 0 : inset);
extension.SetInsetAndSizeFromParentEdge(edge, inset, width);
extension.anchorMin = new Vector2(extension.anchorMin.x, 0);
extension.anchorMax = new Vector2(extension.anchorMin.x, 1);
extension.offsetMin = new Vector2(extension.offsetMin.x, 0);
extension.offsetMax = new Vector2(extension.offsetMax.x, 0);
}
public static RectTransform SetEdge(this RectTransform self, RectTransform.Edge edge, float value)
{
switch (edge)
{
case RectTransform.Edge.Left: self.offsetMin = new Vector2(value, self.offsetMin.y); break;
case RectTransform.Edge.Right: self.offsetMax = new Vector2(-value, self.offsetMax.y); break;
case RectTransform.Edge.Top: self.offsetMax = new Vector2(self.offsetMax.x, -value); break;
case RectTransform.Edge.Bottom: self.offsetMin = new Vector2(self.offsetMin.x, value); break;
}
return(self);
}
public static float GetEdge(this RectTransform self, RectTransform.Edge edge)
{
switch (edge)
{
case RectTransform.Edge.Left: return(self.offsetMin.x);
case RectTransform.Edge.Right: return(-self.offsetMax.x);
case RectTransform.Edge.Top: return(-self.offsetMax.y);
case RectTransform.Edge.Bottom: return(self.offsetMin.y);
}
return(0);
}
protected InternalStateGeneric(TParams sourceParams, ItemsDescriptor itemsDescriptor)
{
_SourceParams = sourceParams;
_ItemsDesc = itemsDescriptor;
var lg = sourceParams.content.GetComponent <LayoutGroup>();
if (lg && lg.enabled)
{
lg.enabled = false;
Debug.Log("LayoutGroup on GameObject " + lg.name + " has beed disabled in order to use ScrollRectItemsAdapter8");
}
var contentSizeFitter = sourceParams.content.GetComponent <ContentSizeFitter>();
if (contentSizeFitter && contentSizeFitter.enabled)
{
contentSizeFitter.enabled = false;
Debug.Log("ContentSizeFitter on GameObject " + contentSizeFitter.name + " has beed disabled in order to use ScrollRectItemsAdapter8");
}
var layoutElement = sourceParams.content.GetComponent <LayoutElement>();
if (layoutElement)
{
GameObject.Destroy(layoutElement);
Debug.Log("LayoutElement on GameObject " + contentSizeFitter.name + " has beed DESTROYED in order to use ScrollRectItemsAdapter8");
}
if (sourceParams.scrollRect.horizontal)
{
startEdge = RectTransform.Edge.Left;
endEdge = RectTransform.Edge.Right;
transvStartEdge = RectTransform.Edge.Top;
_GetRTCurrentSizeFn = root => root.rect.width;
}
else
{
startEdge = RectTransform.Edge.Top;
endEdge = RectTransform.Edge.Bottom;
transvStartEdge = RectTransform.Edge.Left;
_GetRTCurrentSizeFn = root => root.rect.height;
}
_SourceParams.UpdateContentPivotFromGravityType();
CacheScrollViewInfo();
}
public static void LineUp(
RectTransform leader,
IEnumerable <RectTransform> followers,
RectTransform.Edge direction,
float padding = 0
)
{
var previousInLine = leader;
foreach (var nextInLine in followers)
{
nextInLine.Align(direction.Inverse(), previousInLine.GetEdgePosition_AsFloat(direction) + direction.Direction() * padding);
previousInLine = nextInLine;
}
}
public void SetInsetAndSizeFromParentEdge(RectTransform.Edge edge, float inset, float size)
{
int axis = (edge != RectTransform.Edge.Top && edge != RectTransform.Edge.Bottom) ? 0 : 1;
bool topOrRightAligned = edge == RectTransform.Edge.Top || edge == RectTransform.Edge.Right;
float value = !topOrRightAligned ? 0 : 1;
Vector2 temp = default(Vector2); // Used to bypass property assignment
// anchorMin
temp = this.anchorMin;
temp[axis] = value;
this.anchorMin = temp;
// anchorMax
temp = this.anchorMax;
temp[axis] = value;
this.anchorMax = temp;
// sizeDelta
temp = this.sizeDelta;
temp[axis] = size;
this.sizeDelta = temp;
// anchoredPosition
temp = this.anchoredPosition;
temp[axis] = ((!topOrRightAligned)
? (inset + size * this.pivot[axis])
: (-inset - size * (1f - this.pivot[axis])));
this.anchoredPosition = temp;
// position
// NOTE: Might be able to defer this until second axis
temp = this.position;
temp[axis] = Misc.AnchoredPositionToWorldPosition((RectTransform)parent, anchoredPosition,
pivot, anchorMin, anchorMax)[axis];
this.position = temp;
// localPosition
// NOTE: Might be able to defer this until second axis
temp = this.localPosition;
temp[axis] = parent.InverseTransformPoint(this.position)[axis];
this.localPosition = temp;
}
private static int SetInsetAndSizeFromParentEdge(IntPtr L)
{
int result;
try
{
ToLua.CheckArgsCount(L, 4);
RectTransform rectTransform = (RectTransform)ToLua.CheckObject(L, 1, typeof(RectTransform));
RectTransform.Edge edge = (RectTransform.Edge)((int)ToLua.CheckObject(L, 2, typeof(RectTransform.Edge)));
float inset = (float)LuaDLL.luaL_checknumber(L, 3);
float size = (float)LuaDLL.luaL_checknumber(L, 4);
rectTransform.SetInsetAndSizeFromParentEdge(edge, inset, size);
result = 0;
}
catch (Exception e)
{
result = LuaDLL.toluaL_exception(L, e, null);
}
return(result);
}
public float GetEdgePosition_AsFloat_Local(RectTransform.Edge edge)
{
switch (edge)
{
case Left:
return(Word.First().bottomLeft.x);
case Right:
return(Word.Last().bottomRight.x);
case Top:
return(Word.Max(letter => letter.topLeft.y));
case Bottom:
return(Word.Min(letter => letter.bottomLeft.y));
default:
throw EnumUtils.InvalidEnumArgumentException(nameof(edge), edge);
}
}
public static Vector2 CalcLocalInsetPosition(RectTransform container, RectTransform.Edge edge, float inset)
{
Vector2 halfSize = container.rect.size / 2;
switch (edge)
{
case RectTransform.Edge.Top:
return((halfSize.y - inset) * Vector2.up);
case RectTransform.Edge.Bottom:
return((halfSize.y - inset) * Vector2.down);
default:
case RectTransform.Edge.Left:
return((halfSize.x - inset) * Vector2.left);
case RectTransform.Edge.Right:
return((halfSize.x - inset) * Vector2.right);
}
}
public static float DistanceFromPivotToEdge(this RectTransform me, RectTransform.Edge edge)
{
switch (edge)
{
case RectTransform.Edge.Left:
return(me.rect.width * me.pivot.x);
case RectTransform.Edge.Right:
return(me.rect.width * (1 - me.pivot.x));
case RectTransform.Edge.Top:
return(me.rect.height * (1 - me.pivot.y));
case RectTransform.Edge.Bottom:
return(me.rect.height * me.pivot.y);
default:
throw new ArgumentOutOfRangeException(nameof(edge), edge, null);
}
}
public void SetInsetAndSizeFromParentEdge(RectTransform.Edge edge, float inset, float size)
{
int index = edge == RectTransform.Edge.Top || edge == RectTransform.Edge.Bottom ? 1 : 0;
bool flag = edge == RectTransform.Edge.Top || edge == RectTransform.Edge.Right;
float num = !flag ? 0.0f : 1f;
Vector2 vector2 = this.anchorMin;
vector2[index] = num;
this.anchorMin = vector2;
vector2 = this.anchorMax;
vector2[index] = num;
this.anchorMax = vector2;
Vector2 sizeDelta = this.sizeDelta;
sizeDelta[index] = size;
this.sizeDelta = sizeDelta;
Vector2 anchoredPosition = this.anchoredPosition;
anchoredPosition[index] = !flag ? inset + size * this.pivot[index] : (float)(-(double)inset - (double)size * (1.0 - (double)this.pivot[index]));
this.anchoredPosition = anchoredPosition;
}
public void SetInsetAndSizeFromParentEdge(RectTransform.Edge edge, float inset, float size)
{
int index = (edge != RectTransform.Edge.Top && edge != RectTransform.Edge.Bottom) ? 0 : 1;
bool flag = edge == RectTransform.Edge.Top || edge == RectTransform.Edge.Right;
float value = (float)((!flag) ? 0 : 1);
Vector2 vector = this.anchorMin;
vector[index] = value;
this.anchorMin = vector;
vector = this.anchorMax;
vector[index] = value;
this.anchorMax = vector;
Vector2 sizeDelta = this.sizeDelta;
sizeDelta[index] = size;
this.sizeDelta = sizeDelta;
Vector2 anchoredPosition = this.anchoredPosition;
anchoredPosition[index] = ((!flag) ? (inset + size * this.pivot[index]) : (-inset - size * (1f - this.pivot[index])));
this.anchoredPosition = anchoredPosition;
}
internal BoxLayoutStatus(PanelDirection direction, RectOffset margins, float size)
{
this.direction = direction;
switch (direction)
{
case PanelDirection.Horizontal:
edge = RectTransform.Edge.Left;
offset = margins.left;
this.size = size - offset - margins.right;
break;
case PanelDirection.Vertical:
edge = RectTransform.Edge.Top;
offset = margins.top;
this.size = size - offset - margins.bottom;
break;
default:
throw new ArgumentException("direction");
}
}
public Vector3 getDesiredPositionDelta( Bounds targetBounds, Vector3 basePosition, Vector3 targetAvgVelocity )
{
var desiredOffset = Vector3.zero;
if( dualForwardFocusType == DualForwardFocusType.ThresholdBased )
{
var deltaPositionFromBounds = Vector3.zero;
var didLastEdgeContactChange = false;
float leftEdge, rightEdge;
if( _currentEdgeFocus == RectTransform.Edge.Left )
{
rightEdge = basePosition.x - width * 0.5f;
leftEdge = rightEdge - dualForwardFocusThresholdExtents * 0.5f;
}
else
{
leftEdge = basePosition.x + width * 0.5f;
rightEdge = leftEdge + dualForwardFocusThresholdExtents * 0.5f;
}
if( leftEdge > targetBounds.center.x )
{
deltaPositionFromBounds.x = targetBounds.center.x - leftEdge;
if( _currentEdgeFocus == RectTransform.Edge.Left )
{
didLastEdgeContactChange = true;
_currentEdgeFocus = RectTransform.Edge.Right;
}
}
else if( rightEdge < targetBounds.center.x )
{
deltaPositionFromBounds.x = targetBounds.center.x - rightEdge;
if( _currentEdgeFocus == RectTransform.Edge.Right )
{
didLastEdgeContactChange = true;
_currentEdgeFocus = RectTransform.Edge.Left;
}
}
var desiredX = _currentEdgeFocus == RectTransform.Edge.Left ? rightEdge : leftEdge;
desiredOffset.x = targetBounds.center.x - desiredX;
// if we didnt switch direction this works much like a normal camera window
if( !didLastEdgeContactChange )
desiredOffset.x = deltaPositionFromBounds.x;
}
else // velocity or direction based
{
var averagedHorizontalVelocity = targetAvgVelocity.x;
// direction switches are determined by velocity
if( averagedHorizontalVelocity > 0f )
_currentEdgeFocus = RectTransform.Edge.Left;
else if( averagedHorizontalVelocity < 0f )
_currentEdgeFocus = RectTransform.Edge.Right;
var desiredX = _currentEdgeFocus == RectTransform.Edge.Left ? basePosition.x - width * 0.5f : basePosition.x + width * 0.5f;
desiredX = targetBounds.center.x - desiredX;
if( dualForwardFocusType == DualForwardFocusType.DirectionBased )
{
desiredOffset.x = desiredX;
}
else
{
var velocityMultiplier = Mathf.Max( 1f, Mathf.Abs( averagedHorizontalVelocity ) );
desiredOffset.x = Mathf.Lerp( 0f, desiredX, Time.deltaTime * velocityInfluenceMultiplier * velocityMultiplier );
}
}
return desiredOffset;
}
