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