Help with grid view

[RyanJVR]

Does anyone have an idea as to why my gridview would act like this?

Untitled.video.-.Made.with.Clipchamp.mp4

[RyanJVR]

Inspector Settings

[RyanJVR]

`using Nova;

public class TestGrid : MonoBehaviour
{
public GridView gridView;

private List<TextureItems> textureInventory = new List<TextureItems>();
private List<TexturePaintAtt> FullList = new List<TexturePaintAtt>();

// Start is called before the first frame update
void Start()
{
    LoadData();
    
   gridView.AddDataBinder<TextureItems, TextureListButtonVisuals>(BindContact);
    gridView.SetDataSource(textureInventory);
}

private void BindContact(Data.OnBind<TextureItems> evt, TextureListButtonVisuals visuals, int index)
{      
    TextureItems textureInventory = evt.UserData;

    visuals.textureName.Text = textureInventory.textureName;
    visuals.InitButtonLabel(textureInventory.textureName,textureInventory.hasNormMap,textureInventory.isWater);
    
}

void LoadData()
{
    for(int i = 0; i < FullList.Count; i++)
    {
        TextureItems newItem = new TextureItems();
        
        newItem.textureName = "" + FullList[i].colorName;
        newItem.hasNormMap = FullList[i].hasNormal;
        newItem.isWater = FullList[i].isWater;
        newItem.id = FullList[i].baseId;
        textureInventory.Add(newItem);
    }

    //gridView.Relayout();
}

}`

[RyanJVR]

To possibly save you from reading what I posted below I disabled my transition scripts and tested but still getting the same results. Won't delete bellow code incase.

[adgray1]

Really appreciate the extra code and details!

We're able to reproduce the issue locally, and it's just a bug on our end, which is why I transferred the discussion to Feedback/Bugs. So thank you for bringing this to our attention! Will follow up here once we have a fix!

[RyanJVR]

Thanks

[adgray1]

We believe we have the fix. We'll officially publish it in our next release, but here it is in case you'd prefer to patch it locally:

In GridView.cs, insert the following immediately above the if statement on line 623:

if (DataSourceItemCount % InternalProperty_52 != 0 && MaxLoadedIndex == DataSourceItemCount - 1)
{
    InternalVar_4 -= InternalProperty_52 - (DataSourceItemCount % InternalProperty_52);
}

[RyanJVR]

Thank you, working my end.

[RyanJVR]

`using System.Collections;
using UnityEngine;
using UnityEngine.Events;
using Nova;

[AddComponentMenu("Nova+/UI Transition")]
public class UITransition : TransitionBaseClass
{
    [SerializeField] private string transitionName;
    private bool addedToManager = false;
    
    
    public string TransitionName
    {
        get => transitionName;
        set
        {
            transitionName = value;
            #if UNITY_EDITOR
            Renamne();
            #endif
        }
    }

    [Header("UI Animate In")]
    [SerializeField] InDirection screenEdgeStart;
    [SerializeField] Vector3 offsetInPosition;
    [SerializeField] float animInDuration = 0.3f;
    [SerializeField] float delayIn = 0.0f;
    [SerializeField] private AnimationCurve inCurve = AnimationCurve.EaseInOut(0, 0, 1, 1);
    [SerializeField] private float inRotation  = 0f;
    [SerializeField]private Vector3 inStartScale = new Vector3(1.0f,1.0f,1.0f);
    private Vector3 endScale = new Vector3(1.0f,1.0f,1.0f);

    [SerializeField] Vector3 onScreenPosition;
    private int screenEdgeValueIn;
    
    [Header("UI Animate Out")]
    [SerializeField] OutDirection screenEdgeEnd;
    [SerializeField] Vector3 offsetOutPosition;
    [SerializeField] float animOutDuration = 0.3f;
    [SerializeField] float delayOut = 0.1f;
    [SerializeField] private AnimationCurve outCurve = AnimationCurve.EaseInOut(0, 0, 1, 1);
    [SerializeField] private float outRotation  = 0f;
    [SerializeField] private Vector3 outEndScale = new Vector3(1.0f,1.0f,1.0f);
    
    private int screenEdgeValueOut;

    [Header("Options")]
    [SerializeField] private int radioValue;
    [SerializeField] bool visibleOnStart;
    [SerializeField] bool animateOnStart;
    [SerializeField] bool disableOnHide = true;
    [SerializeField] private float overshoot = 10f;

    [SerializeField] private UnityEvent onInStart;
    [SerializeField] private UnityEvent onInComplete;
    
    [SerializeField] private UnityEvent onOutStart;
    [SerializeField] private UnityEvent onOutComplete;
        
    GameObject _uiObject;
    bool _isVisible, randomSequence = false;
    [SerializeField] private UIBlock screenUIBlock;
    private UIBlock2D uiBlock2d;
    [SerializeField] private UIBlock2D uiBlock2dParent;
    private Transform uiBlock2dTransform;
    private Vector3 _outScale;
    private float originalRotation  = 0.0f;
    
    [SerializeField] private bool overrideAnimation = false;
    [SerializeField] private bool overrideDuration = false;

    private enum InDirection {None, Top, Bottom, Left, Right, TopLeft, TopRight, BottomLeft, BottomRight};
    private enum OutDirection { None, Top, Bottom, Left, Right, TopLeft, TopRight, BottomLeft, BottomRight};
    
    //----------Animation ref--------------------------
    public UIPositionAnimation positionAnimation;
    public UIScaleAnimation scaleAnimation;
    public UIRotationAnimation rotationAnimation;

    private AnimationHandle uiInHandle;
    private AnimationHandle uiOutHandle;
    //--------------------------------------------------
    
    Vector3 _zeroPos, _visibleOutPos, _offScreenPosIn, _offScreenPosOut, _originalPos;
    private float _offScreenValue;
    private Vector3 posIn,posOut;
    private bool currentTransitionIsIn;
    private Vector3 size;
    private bool valueSet;
    private bool groupValueSet;

    private void OnEnable()
    {
        uiBlock2d.CalculateLayout();
        DimensionChangeUpdate.ScreenTransformChanged += UI_LayoutUpdate;
    }
    private void OnDisable()
    {
        DimensionChangeUpdate.ScreenTransformChanged -= UI_LayoutUpdate;
        if (!valueSet)
        {
            SetTransitionValues();
        }
    }

    private void Awake()
    {
        if(uiBlock2d == null)
            uiBlock2d = GetComponent<UIBlock2D>();
        
        if (radioValue == 1)
        {
            if(uiBlock2dParent == null)
                uiBlock2dParent = transform.parent.GetComponent<UIBlock2D>();
        }
        
        if(screenUIBlock == null)
            screenUIBlock = transform.root.GetComponent<UIBlock>(); 
        
        _uiObject = this.gameObject;
        _isVisible = _uiObject.activeInHierarchy;
        uiBlock2dTransform = uiBlock2d.transform;
        
        screenUIBlock.CalculateLayout();
        FindOnScreenPos();
        //SetTransitionValues();
    }
    
    public void SetInValues(float overShootInput, float inRot, Vector3 inScale, Vector3 finalScale, float inDuration, AnimationCurve easeIn, int inDirection)
    {
        if (!overrideDuration)
        {
            animInDuration = inDuration;
        }
        
        if (overrideAnimation) return;

        overshoot = overShootInput;
        inRotation = inRot;
        inCurve = easeIn;
        inStartScale = inScale;
        endScale = finalScale;
        screenEdgeValueIn = inDirection;
        groupValueSet = true;
        //if(uiBlock2d == null)
            //uiBlock2d = GetComponent<UIBlock2D> ();

    }
    public void SetOutValues(float overShootInput, float outRot, Vector3 finalOutScale, float outDuration, AnimationCurve easeOut, int outDirection)
    {
        if (!overrideDuration)
        {
            animOutDuration = outDuration;
        }
        
        if (overrideAnimation) return;
        
        outRotation = outRot;
        outCurve = easeOut;
        outEndScale = finalOutScale;
        overshoot = overShootInput;
        screenEdgeValueOut = outDirection;
        groupValueSet = true;
        //if(uiBlock2d == null)
            //uiBlock2d = GetComponent<UIBlock2D> ();
        
    }
    
    void Start()
    {
        SetTransitionValues();
        SetVisible (visibleOnStart);

        if (animateOnStart)
        {
            PlayTransitionIn();
            onInStart.Invoke();
        }
    }

    void SetTransitionValues()
    {
        if (!groupValueSet)
        {
            screenEdgeValueIn = (int) screenEdgeStart;
            screenEdgeValueOut = (int) screenEdgeEnd;
        }
        SetOverShoot(overshoot);
        if (radioValue == 1)
        {
            if (uiBlock2dParent == null)
            {
                FindViewSize(screenUIBlock);
            }
            else
            {
                FindViewSize(uiBlock2dParent);
            }
        }
        else if(radioValue == 2)
        {
            FindViewSize(uiBlock2d);
        }
        else
        {
            FindViewSize(screenUIBlock);
        }
        
        SetDirectionIn(screenEdgeValueIn, offsetInPosition, onScreenPosition, inStartScale, uiBlock2d, inRotation, out posIn);
        SetDirectionOut(screenEdgeValueOut, offsetOutPosition, onScreenPosition, outEndScale, uiBlock2d, outRotation, out posOut);
        uiBlock2dTransform.localScale = inStartScale;
        valueSet = true;
    }

    void FindOnScreenPos()
    {
        uiBlock2d.CalculateLayout();
        size = screenUIBlock.CalculatedSize.Value;
        if (uiBlock2dTransform.localPosition.x > size.x || uiBlock2dTransform.localPosition.x < -size.x)
        {
            onScreenPosition = Vector3.zero;
        }
        else if (uiBlock2dTransform.localPosition.y > size.y || uiBlock2dTransform.localPosition.y < -size.y)
        {
            onScreenPosition = Vector3.zero;
        }
        else
        {
            onScreenPosition = uiBlock2dTransform.localPosition;
        }
    }

    void UI_LayoutUpdate()
    {
        SetTransitionValues();
        uiBlock2d.transform.localPosition = currentTransitionIsIn ? onScreenPosition : posIn;
        uiBlock2d.transform.localScale = currentTransitionIsIn ? endScale : inStartScale;
    }

    void SetVisible(bool onOff)
    {
        if (_isVisible != onOff) 
        {
            _isVisible = onOff;
            
            if(disableOnHide && !_isVisible)
            {
                if(_uiObject != null)
                {
                    _uiObject.SetActive(false);
                }
                uiBlock2d.transform.localScale = inStartScale;
            }
        }
        else
        {
            uiBlock2d.transform.localPosition = _isVisible ? onScreenPosition : posIn;
        }
        currentTransitionIsIn = _isVisible;
    }
    
    public void PlayTransitionIn()
    {
        //Debug.Log("showUI");
        if(!_isVisible)
        {
            if(_uiObject)
            {
                SetInParametersFromCache();
                _uiObject.SetActive(true);
                //this.gameObject.SetActive(true);
                uiBlock2d.TrySetLocalPosition(posIn);
                uiBlock2d.CalculateLayout();
                _isVisible = true;
                if(_uiObject.activeSelf)
                    StartCoroutine(UI_TransitionIn());
            }
        }
    }
    
    public void PlayTransitionOut()
    {
        _isVisible = false;
        if (!IsActive())
            return;

        scaleAnimation.sStart = endScale;
        scaleAnimation.sEnd = outEndScale;
        positionAnimation.pStart = onScreenPosition;
        positionAnimation.pEnd = posOut;
        rotationAnimation.rStart = uiBlock2dTransform.rotation;
        rotationAnimation.rEnd = Quaternion.Euler(0f, 0f, outRotation);
        positionAnimation.Ease = outCurve;
        scaleAnimation.Ease = outCurve;
        rotationAnimation.Ease = outCurve;
        scaleAnimation.TransformToMove = uiBlock2dTransform;
        positionAnimation.TransformToMove = uiBlock2dTransform;
        rotationAnimation.TransformToMove = uiBlock2dTransform;
        
        if(_uiObject.activeSelf)
            StartCoroutine(UI_TransitionOut());
    }
    
    IEnumerator UI_TransitionOut()
    {
        yield return new WaitForSeconds(delayOut);
        onOutStart.Invoke();
        uiInHandle.Cancel();
        uiOutHandle.Cancel();
        //uiOutHandle = positionAnimation.Run(animOutDuration).Include(scaleAnimation).Include(rotationAnimation);
        if (outRotation != 0f)
        {
            uiOutHandle = positionAnimation.Run(animOutDuration).Include(scaleAnimation).Include(rotationAnimation);
        }
        else
        {
            uiOutHandle = positionAnimation.Run(animOutDuration).Include(scaleAnimation);
        }
        //uiOutHandle.IsComplete();
    
        currentTransitionIsIn = false;
        
        while (!uiOutHandle.IsComplete())
        {
            yield return null;
        }

        onOutComplete.Invoke();
        
        if(!disableOnHide)
            yield break;
        //uiBlock2dTransform.localPosition = 
        //SetInParametersFromCache();
        yield return new WaitForEndOfFrame();
        DisableUI();
        yield return null;
    }
    IEnumerator UI_TransitionIn()
    {
        yield return new WaitForSeconds(delayIn);
        onInStart.Invoke();
        uiOutHandle.Cancel();
        uiInHandle.Cancel();
        if (inRotation != 0f)
        {
            uiInHandle = positionAnimation.Run(animInDuration).Include(scaleAnimation).Include(rotationAnimation);
        }
        else
        {
            uiInHandle = positionAnimation.Run(animInDuration).Include(scaleAnimation);
        }

        currentTransitionIsIn = true;
        while (!uiOutHandle.IsComplete())
        {
            yield return null;
        }
        onInComplete.Invoke();
        yield return null;
    }
    
    public void PlayTransitionBasedOnToggle(bool value)
    {
        if (value)
        {
            PlayTransitionIn();
        }
        else
        {
            PlayTransitionOut();
        }
    }

    public void SetInParametersFromCache()
    {
        uiBlock2dTransform.localScale = inStartScale;
        uiBlock2dTransform.localPosition = posIn;
        uiBlock2d.Position.Value = posIn;

        scaleAnimation.sStart = inStartScale;
        scaleAnimation.sEnd = endScale;
        positionAnimation.pStart = posIn;
        positionAnimation.pEnd = onScreenPosition;
        rotationAnimation.rStart = Quaternion.Euler(0f, 0f, inRotation);
        rotationAnimation.rEnd = Quaternion.Euler(0f, 0f, 0f);
        
        positionAnimation.Ease = inCurve;
        scaleAnimation.Ease = inCurve;
        rotationAnimation.Ease = outCurve;
        
        uiBlock2dTransform.localEulerAngles = new Vector3(0,0,inRotation);
        scaleAnimation.TransformToMove = uiBlock2dTransform;
        positionAnimation.TransformToMove = uiBlock2dTransform;
        rotationAnimation.TransformToMove = uiBlock2dTransform;
    }
    
    public void BypassUI()
    {
        _isVisible = false;
        uiBlock2dTransform.localScale = inStartScale;
        uiBlock2dTransform.localPosition = posIn;
        uiBlock2dTransform.localEulerAngles = new Vector3(0,0,inRotation);
        DisableUI();
    }

    public void DisableUI()
    {
        if(_uiObject)
        {
            _uiObject.SetActive(false);
        }
    }
    
    #if UNITY_EDITOR
    
    private void Reset()
    {
        _uiObject = this.gameObject;
        if (TransitionName == null)
        {
            transitionName = this.gameObject.name;
        }
    }
    private void Renamne()
    {
        this.gameObject.name = transitionName;
        if (!addedToManager)
            return;

        AddToManager();
    }
    
    [ContextMenu("Add to manager")]
    public void AddToManager()
    {
        if (UIPlusManager.Instance == null) return;
        //Debug.Log(this);
        UIPlusManager.Instance.AddTransition(this);
        addedToManager = true;
    }
    
    #endif

    
    
}
`

[RyanJVR]

`using UnityEngine;
using UnityEngine.EventSystems;
using Nova;

public class TransitionBaseClass : UIBehaviour
{
    public float overShootValue;

    Vector2 visiblePos, offScreenPosIn, offScreenPosOut;
    private float offScreenValue;
    private float sumValue;
    private float sumValueY;
    private float sizeDiff;
    private float offScreenValueY;
    private float uiSizeX;
    private float uiSizeY;
    
    private float uiOffsetX;
    private float uiOffsetY;

    private Vector2 canvasSize;
    private Vector2 ellementSize;
 
    public void SetOverShoot(float overshootInput)
    {
        overShootValue = overshootInput;
    }
    
    public void FindParentSize(UIBlock2D ParentBlock)
    {
        var size = ParentBlock.CalculatedSize.Value;
        uiSizeX = size.x;
        uiSizeY = size.y;
    }
    public void FindViewSize(UIBlock CanvasBlock)
    {
        var size = CanvasBlock.CalculatedSize.Value;
        uiSizeX = size.x;
        uiSizeY = size.y;
    }
    
    public void SetDirectionIn(int inDirection,Vector3 offsetPos, Vector3 onScreenPos, Vector3 outScale, UIBlock2D block2d, float rotation, out Vector3 offScreenPosStart)
    {
        offScreenPosStart = onScreenPos;
        ellementSize = block2d.CalculatedSize.Value;
        offScreenValue = 0f;
        offScreenValueY = 0f;
        
        if (rotation > 1 || rotation < -1)
        {
            if (ellementSize.y != ellementSize.x)
            {
                sizeDiff = ellementSize.y - ellementSize.x;
            }
            else
            {
                sizeDiff = 0.0f;
            }
        }
        else
        {
            sizeDiff = 0.0f;
        }

        uiOffsetX = (offsetPos.x / 100) * uiSizeX;
        uiOffsetY = (offsetPos.y / 100) * uiSizeY;
        
        switch (inDirection)
        {
            case 0:
                offScreenPosStart = onScreenPos;
                break;
            case 1:
                sumValue = overShootValue + (uiSizeY + sizeDiff);
                offScreenValue += sumValue;
                offScreenPosIn.Set(onScreenPos.x + uiOffsetX, onScreenPos.y + (offScreenValue + uiOffsetY));
                block2d.transform.position =  offScreenPosIn;
                offScreenPosStart = offScreenPosIn;
                break;
            case 2:
                sumValue = overShootValue + (uiSizeY + sizeDiff);
                offScreenValue -= sumValue;
                offScreenPosIn.Set(onScreenPos.x + uiOffsetX, onScreenPos.y  + (offScreenValue + uiOffsetY));
                block2d.transform.position = offScreenPosIn;
                offScreenPosStart = offScreenPosIn;
                break;
            case 3:
                sumValue = overShootValue + (uiSizeX + sizeDiff);
                offScreenValue -= sumValue;
                offScreenPosIn.Set(onScreenPos.x + (offScreenValue + uiOffsetX), onScreenPos.y + uiOffsetY);
                block2d.transform.position = offScreenPosIn;
                offScreenPosStart = offScreenPosIn;
                break;
            case 4:
                sumValue = overShootValue + (uiSizeX + sizeDiff);
                offScreenValue += sumValue;
                offScreenPosIn.Set(onScreenPos.x + (offScreenValue + uiOffsetX), onScreenPos.y + uiOffsetY);
                block2d.Position.XY = offScreenPosIn;
                offScreenPosStart = offScreenPosIn;
                break;
            case 5:
                sumValue = overShootValue + (uiSizeX + sizeDiff);
                offScreenValue -= sumValue;
                sumValueY = overShootValue + (uiSizeY + sizeDiff);
                offScreenValueY += sumValueY;
                offScreenPosIn.Set(onScreenPos.x + (offScreenValue + uiOffsetX), onScreenPos.y + (offScreenValueY + uiOffsetY));
                block2d.transform.position = offScreenPosIn;
                offScreenPosStart = offScreenPosIn;
                break;
            case 6:
                sumValue = overShootValue + (uiSizeX + sizeDiff);
                offScreenValue += sumValue;
                sumValueY = overShootValue + (uiSizeY + sizeDiff);
                offScreenValueY += sumValueY;
                offScreenPosIn.Set(onScreenPos.x + (offScreenValue + uiOffsetX), onScreenPos.y + (offScreenValueY + uiOffsetY));
                block2d.transform.position = offScreenPosIn;
                offScreenPosStart = offScreenPosIn;
                break;
            case 7:
                sumValue = overShootValue + (uiSizeX + sizeDiff);
                offScreenValue -= sumValue;
                sumValueY = overShootValue + (uiSizeY + sizeDiff);
                offScreenValueY -= sumValueY;
                offScreenPosIn.Set(onScreenPos.x + (offScreenValue + uiOffsetX), onScreenPos.y + (offScreenValueY + uiOffsetY));
                block2d.transform.position = offScreenPosIn;
                offScreenPosStart = offScreenPosIn;
                break;
            case 8:
                sumValue = overShootValue + (uiSizeX + sizeDiff);
                offScreenValue += sumValue;
                sumValueY = overShootValue + (uiSizeY + sizeDiff);
                offScreenValueY -= sumValueY;
                offScreenPosIn.Set(onScreenPos.x + (offScreenValue + uiOffsetX), onScreenPos.y + (offScreenValueY + uiOffsetY));
                block2d.transform.position = offScreenPosIn;
                offScreenPosStart = offScreenPosIn;
                //Debug.Log(offScreenPosIn);
                break;
        }

    }

    public void SetDirectionOut (int outDirection, Vector3 offsetPos, Vector3 onScreenPos, Vector3 outScale, UIBlock2D block2d, float rotation, out Vector3 offScreenPosEnd)
    {
        offScreenPosEnd = onScreenPos;
        ellementSize = block2d.CalculatedSize.Value;
        offScreenValue = 0f;
        offScreenValueY = 0f;
        
        if (rotation > 1 || rotation < -1)
        {
            if (ellementSize.y != ellementSize.x)
            {
                sizeDiff = ellementSize.y - ellementSize.x;
            }
            else
            {
                sizeDiff = 0.0f;
            }
        }
        else
        {
            sizeDiff = 0.0f;
        }
        
        uiOffsetX = (offsetPos.x / 100) * uiSizeX;
        uiOffsetY = (offsetPos.y / 100) * uiSizeY;
        
        switch (outDirection) {
            case 0:
                offScreenPosEnd = onScreenPos;
                break;
            case 1:
                sumValue = overShootValue + (uiSizeY + sizeDiff);
                offScreenValue += sumValue;
                offScreenPosOut.Set (onScreenPos.x + uiOffsetX, onScreenPos.y + (offScreenValue + uiOffsetY));
                offScreenPosEnd = offScreenPosOut;
                break;
            case 2:
                sumValue = overShootValue + (uiSizeY + sizeDiff);
                offScreenValue -= sumValue;
                offScreenPosOut.Set (onScreenPos.x + uiOffsetX, onScreenPos.y + (offScreenValue + uiOffsetY));
                offScreenPosEnd = offScreenPosOut;
                break;
            case 3:
                sumValue = overShootValue + (uiSizeX + sizeDiff);
                offScreenValue -= sumValue;
                offScreenPosOut.Set (onScreenPos.x + (offScreenValue + uiOffsetX), onScreenPos.y + uiOffsetY);
                offScreenPosEnd = offScreenPosOut;
                break;
            case 4:
                sumValue = overShootValue + (uiSizeX + sizeDiff);
                offScreenValue += sumValue;
                offScreenPosOut.Set (onScreenPos.x + (offScreenValue + uiOffsetX), onScreenPos.y + uiOffsetY);
                offScreenPosEnd = offScreenPosOut;
                break;
            case 5:
                sumValue = overShootValue + (uiSizeX + sizeDiff);
                offScreenValue -= sumValue;
                sumValueY = overShootValue + (uiSizeY + sizeDiff);
                offScreenValueY += sumValueY;
                offScreenPosOut.Set (onScreenPos.x + (offScreenValue + uiOffsetX), onScreenPos.y + (offScreenValueY + uiOffsetY));
                offScreenPosEnd = offScreenPosOut;
                break;
            case 6:
                sumValue = overShootValue + (uiSizeX + sizeDiff);
                offScreenValue += sumValue;
                sumValueY = overShootValue + (uiSizeY + sizeDiff);
                offScreenValueY += sumValueY;
                offScreenPosOut.Set(onScreenPos.x + (offScreenValue + uiOffsetX), onScreenPos.y + (offScreenValueY + uiOffsetY));
                offScreenPosEnd = offScreenPosOut;
                break;
            case 7:
                sumValue = overShootValue + (uiSizeX + sizeDiff);
                offScreenValue -= sumValue;
                sumValueY = overShootValue + (uiSizeY + sizeDiff);
                offScreenValueY -= sumValueY;
                offScreenPosOut.Set(onScreenPos.x + (offScreenValue + uiOffsetX), onScreenPos.y + (offScreenValueY + uiOffsetY));
                offScreenPosEnd = offScreenPosOut;
                break;
            case 8:
                sumValue = overShootValue + (uiSizeX + sizeDiff);
                offScreenValue += sumValue;
                sumValueY = overShootValue + (uiSizeY + sizeDiff);
                offScreenValueY -= sumValueY;
                offScreenPosOut.Set(onScreenPos.x + (offScreenValue + uiOffsetX), onScreenPos.y + (offScreenValueY + uiOffsetY));
                offScreenPosEnd = offScreenPosOut;
                //Debug.Log(offScreenPosOut);
                break;
        }
    }  
}
`

[RyanJVR]

Inspector view for some added context. Do you need to see the animation code too?

[dkonik]

v1.2.3 has just been published with the fix for this!