Unity UGUI基础之 Scroll View/Scroll Rect 的简单使用，并取消拖拽(滑动内容)效果，拖拽只在Scrollbar 上起作用

小灰灰 2022-10-09 00:46 9阅读 0赞

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70][]

## Unity UGUI基础 之 Scroll View/Scroll Rect 的简单使用，并取消拖拽(滑动内容)效果，拖拽只在Scrollbar 上起作用 ##

**目录**

Unity UGUI基础 之 Scroll View/Scroll Rect 的简单使用，并取消拖拽(滑动内容)效果，拖拽只在Scrollbar 上起作用

一、简单介绍

二、实现原理

三、注意事项

四、效果预览

五、实现步骤

六、关键代码

--------------------

## 一、简单介绍 ##

Unity中的一些基础知识点。

本节简单介绍 Scroll View/Scroll Rect的使用实现滑动查看内容的简单实现，并根据需要，取消 ScrollRect 上的拖拽效果，只在Scrollbar有拖拽效果的简单实现，如果你有新的方式也可以留言，多谢。

## 二、实现原理 ##

1、由于 ScrollRect 脚本继承了 IDrag 相关的接口，重写原来的 ScrollRect  的代码，取消继承

IDrag 相关的接口 即可实现 取消 ScrollRect 上的拖拽效果 的功能，而且保留了 ScrollRect  上的点击等其他交互功能

## 三、注意事项 ##

1、取消 ScrollRect 上的拖拽效果，网上也介绍取消 所有相关的 Raycast Target，这样是可以，但是 ScrollRect 的点击效果也没有（或许网友有其他方法实现点击效果吧，鄙人没有找到，知道的可留言）

2、取消 ScrollRect 上的拖拽效果，网上也介绍使用 CanvasGroup 组件，取消相关交互事件，这样是可以，但是 ScrollRect 的点击效果也没有（或许网友有其他方法实现点击效果吧，鄙人没有找到，知道的可留言）

3、建议重写 ScrollRect 脚本，而不是在源码上修改

## 四、效果预览 ##

![20210622205849329.gif][]

## 五、实现步骤 ##

1、打开Unity，新建一个空工程

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 1][]

2、添加 Scroll View 组件

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 2][]

3、在 Scroll View 的 Content 下添加些 Button 作为测试使用

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 3][]

4、在 content 组件上，添加 Grid Layout Group 组件，作为布局调整分布，添加 ContentSizeFitter 可以自动根据内容调整Content 组件的大小

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 4][]

5、然后，运行就可以实现，Scroll 拖动查看内容了

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 5][]

6、右键 ScrollRect 查看源码

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 6][]

7、取消 ScrollRect  脚本中继承的 IBeginDragHandler, IEndDragHandler, IDragHandler 接口

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 7][]

8、回到 Unity，运行场景，即可实现取消 ScrollRect 上的拖拽效果，只在Scrollbar有拖拽效果

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 8][]

9、建议重写 ScrollRect 脚本，而不是在源码上修改，这里 MyCancelDragScrollRect 重写脚本

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 9][]

## 六、关键代码 ##

1、MyCancelDragScrollRect

using System;
    using UnityEngine;
    using UnityEngine.Events;
    using UnityEngine.EventSystems;
    using UnityEngine.UI;
    
    namespace TestSapce {
    
    	[SelectionBase]
    	[ExecuteAlways]
    	[DisallowMultipleComponent]
    	[RequireComponent(typeof(RectTransform))]
    	public class MyCancelDragScrollRect : UIBehaviour, IInitializePotentialDragHandler, IScrollHandler, ICanvasElement, ILayoutElement, ILayoutGroup
    	{
            /// <summary>
            /// A setting for which behavior to use when content moves beyond the confines of its container.
            /// </summary>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.UI;  // Required when Using UI elements.
            ///
            /// public class ExampleClass : MonoBehaviour
            /// {
            ///     public ScrollRect myScrollRect;
            ///     public Scrollbar newScrollBar;
            ///
            ///     //Called when a button is pressed
            ///     public void Example(int option)
            ///     {
            ///         if (option == 0)
            ///         {
            ///             myScrollRect.movementType = ScrollRect.MovementType.Clamped;
            ///         }
            ///         else if (option == 1)
            ///         {
            ///             myScrollRect.movementType = ScrollRect.MovementType.Elastic;
            ///         }
            ///         else if (option == 2)
            ///         {
            ///             myScrollRect.movementType = ScrollRect.MovementType.Unrestricted;
            ///         }
            ///     }
            /// }
            /// </code>
            /// </example>
            public enum MovementType
            {
                /// <summary>
                /// Unrestricted movement. The content can move forever.
                /// </summary>
                Unrestricted,
    
                /// <summary>
                /// Elastic movement. The content is allowed to temporarily move beyond the container, but is pulled back elastically.
                /// </summary>
                Elastic,
    
                /// <summary>
                /// Clamped movement. The content can not be moved beyond its container.
                /// </summary>
                Clamped,
            }
    
            /// <summary>
            /// Enum for which behavior to use for scrollbar visibility.
            /// </summary>
            public enum ScrollbarVisibility
            {
                /// <summary>
                /// Always show the scrollbar.
                /// </summary>
                Permanent,
    
                /// <summary>
                /// Automatically hide the scrollbar when no scrolling is needed on this axis. The viewport rect will not be changed.
                /// </summary>
                AutoHide,
    
                /// <summary>
                /// Automatically hide the scrollbar when no scrolling is needed on this axis, and expand the viewport rect accordingly.
                /// </summary>
                /// <remarks>
                /// When this setting is used, the scrollbar and the viewport rect become driven, meaning that values in the RectTransform are calculated automatically and can't be manually edited.
                /// </remarks>
                AutoHideAndExpandViewport,
            }
    
            [Serializable]
            /// <summary>
            /// Event type used by the ScrollRect.
            /// </summary>
            public class ScrollRectEvent : UnityEvent<Vector2> { }
    
            [SerializeField]
            private RectTransform m_Content;
    
            /// <summary>
            /// The content that can be scrolled. It should be a child of the GameObject with ScrollRect on it.
            /// </summary>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.UI; // Required when Using UI elements.
            ///
            /// public class ExampleClass : MonoBehaviour
            /// {
            ///     public ScrollRect myScrollRect;
            ///     public RectTransform scrollableContent;
            ///
            ///     //Do this when the Save button is selected.
            ///     public void Start()
            ///     {
            ///         // assigns the contect that can be scrolled using the ScrollRect.
            ///         myScrollRect.content = scrollableContent;
            ///     }
            /// }
            /// </code>
            /// </example>
            public RectTransform content { get { return m_Content; } set { m_Content = value; } }
    
            [SerializeField]
            private bool m_Horizontal = true;
    
            /// <summary>
            /// Should horizontal scrolling be enabled?
            /// </summary>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.UI; // Required when Using UI elements.
            ///
            /// public class ExampleClass : MonoBehaviour
            /// {
            ///     public ScrollRect myScrollRect;
            ///
            ///     public void Start()
            ///     {
            ///         // Is horizontal scrolling enabled?
            ///         if (myScrollRect.horizontal == true)
            ///         {
            ///             Debug.Log("Horizontal Scrolling is Enabled!");
            ///         }
            ///     }
            /// }
            /// </code>
            /// </example>
            public bool horizontal { get { return m_Horizontal; } set { m_Horizontal = value; } }
    
            [SerializeField]
            private bool m_Vertical = true;
    
            /// <summary>
            /// Should vertical scrolling be enabled?
            /// </summary>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.UI;  // Required when Using UI elements.
            ///
            /// public class ExampleClass : MonoBehaviour
            /// {
            ///     public ScrollRect myScrollRect;
            ///
            ///     public void Start()
            ///     {
            ///         // Is Vertical scrolling enabled?
            ///         if (myScrollRect.vertical == true)
            ///         {
            ///             Debug.Log("Vertical Scrolling is Enabled!");
            ///         }
            ///     }
            /// }
            /// </code>
            /// </example>
            public bool vertical { get { return m_Vertical; } set { m_Vertical = value; } }
    
            [SerializeField]
            private MovementType m_MovementType = MovementType.Elastic;
    
            /// <summary>
            /// The behavior to use when the content moves beyond the scroll rect.
            /// </summary>
            public MovementType movementType { get { return m_MovementType; } set { m_MovementType = value; } }
    
            [SerializeField]
            private float m_Elasticity = 0.1f;
    
            /// <summary>
            /// The amount of elasticity to use when the content moves beyond the scroll rect.
            /// </summary>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.UI;
            ///
            /// public class ExampleClass : MonoBehaviour
            /// {
            ///     public ScrollRect myScrollRect;
            ///
            ///     public void Start()
            ///     {
            ///         // assigns a new value to the elasticity of the scroll rect.
            ///         // The higher the number the longer it takes to snap back.
            ///         myScrollRect.elasticity = 3.0f;
            ///     }
            /// }
            /// </code>
            /// </example>
            public float elasticity { get { return m_Elasticity; } set { m_Elasticity = value; } }
    
            [SerializeField]
            private bool m_Inertia = true;
    
            /// <summary>
            /// Should movement inertia be enabled?
            /// </summary>
            /// <remarks>
            /// Inertia means that the scrollrect content will keep scrolling for a while after being dragged. It gradually slows down according to the decelerationRate.
            /// </remarks>
            public bool inertia { get { return m_Inertia; } set { m_Inertia = value; } }
    
            [SerializeField]
            private float m_DecelerationRate = 0.135f; // Only used when inertia is enabled
    
            /// <summary>
            /// The rate at which movement slows down.
            /// </summary>
            /// <remarks>
            /// The deceleration rate is the speed reduction per second. A value of 0.5 halves the speed each second. The default is 0.135. The deceleration rate is only used when inertia is enabled.
            /// </remarks>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.UI; // Required when Using UI elements.
            ///
            /// public class ExampleClass : MonoBehaviour
            /// {
            ///     public ScrollRect myScrollRect;
            ///
            ///     public void Start()
            ///     {
            ///         // assigns a new value to the decelerationRate of the scroll rect.
            ///         // The higher the number the longer it takes to decelerate.
            ///         myScrollRect.decelerationRate = 5.0f;
            ///     }
            /// }
            /// </code>
            /// </example>
            public float decelerationRate { get { return m_DecelerationRate; } set { m_DecelerationRate = value; } }
    
            [SerializeField]
            private float m_ScrollSensitivity = 1.0f;
    
            /// <summary>
            /// The sensitivity to scroll wheel and track pad scroll events.
            /// </summary>
            /// <remarks>
            /// Higher values indicate higher sensitivity.
            /// </remarks>
            public float scrollSensitivity { get { return m_ScrollSensitivity; } set { m_ScrollSensitivity = value; } }
    
            [SerializeField]
            private RectTransform m_Viewport;
    
            /// <summary>
            /// Reference to the viewport RectTransform that is the parent of the content RectTransform.
            /// </summary>
            public RectTransform viewport { get { return m_Viewport; } set { m_Viewport = value; SetDirtyCaching(); } }
    
            [SerializeField]
            private Scrollbar m_HorizontalScrollbar;
    
            /// <summary>
            /// Optional Scrollbar object linked to the horizontal scrolling of the ScrollRect.
            /// </summary>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.UI;  // Required when Using UI elements.
            ///
            /// public class ExampleClass : MonoBehaviour
            /// {
            ///     public ScrollRect myScrollRect;
            ///     public Scrollbar newScrollBar;
            ///
            ///     public void Start()
            ///     {
            ///         // Assigns a scroll bar element to the ScrollRect, allowing you to scroll in the horizontal axis.
            ///         myScrollRect.horizontalScrollbar = newScrollBar;
            ///     }
            /// }
            /// </code>
            /// </example>
            public Scrollbar horizontalScrollbar
            {
                get
                {
                    return m_HorizontalScrollbar;
                }
                set
                {
                    if (m_HorizontalScrollbar)
                        m_HorizontalScrollbar.onValueChanged.RemoveListener(SetHorizontalNormalizedPosition);
                    m_HorizontalScrollbar = value;
                    if (m_HorizontalScrollbar)
                        m_HorizontalScrollbar.onValueChanged.AddListener(SetHorizontalNormalizedPosition);
                    SetDirtyCaching();
                }
            }
    
            [SerializeField]
            private Scrollbar m_VerticalScrollbar;
    
            /// <summary>
            /// Optional Scrollbar object linked to the vertical scrolling of the ScrollRect.
            /// </summary>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.UI;  // Required when Using UI elements.
            ///
            /// public class ExampleClass : MonoBehaviour
            /// {
            ///     public ScrollRect myScrollRect;
            ///     public Scrollbar newScrollBar;
            ///
            ///     public void Start()
            ///     {
            ///         // Assigns a scroll bar element to the ScrollRect, allowing you to scroll in the vertical axis.
            ///         myScrollRect.verticalScrollbar = newScrollBar;
            ///     }
            /// }
            /// </code>
            /// </example>
            public Scrollbar verticalScrollbar
            {
                get
                {
                    return m_VerticalScrollbar;
                }
                set
                {
                    if (m_VerticalScrollbar)
                        m_VerticalScrollbar.onValueChanged.RemoveListener(SetVerticalNormalizedPosition);
                    m_VerticalScrollbar = value;
                    if (m_VerticalScrollbar)
                        m_VerticalScrollbar.onValueChanged.AddListener(SetVerticalNormalizedPosition);
                    SetDirtyCaching();
                }
            }
    
            [SerializeField]
            private ScrollbarVisibility m_HorizontalScrollbarVisibility;
    
            /// <summary>
            /// The mode of visibility for the horizontal scrollbar.
            /// </summary>
            public ScrollbarVisibility horizontalScrollbarVisibility { get { return m_HorizontalScrollbarVisibility; } set { m_HorizontalScrollbarVisibility = value; SetDirtyCaching(); } }
    
            [SerializeField]
            private ScrollbarVisibility m_VerticalScrollbarVisibility;
    
            /// <summary>
            /// The mode of visibility for the vertical scrollbar.
            /// </summary>
            public ScrollbarVisibility verticalScrollbarVisibility { get { return m_VerticalScrollbarVisibility; } set { m_VerticalScrollbarVisibility = value; SetDirtyCaching(); } }
    
            [SerializeField]
            private float m_HorizontalScrollbarSpacing;
    
            /// <summary>
            /// The space between the scrollbar and the viewport.
            /// </summary>
            public float horizontalScrollbarSpacing { get { return m_HorizontalScrollbarSpacing; } set { m_HorizontalScrollbarSpacing = value; SetDirty(); } }
    
            [SerializeField]
            private float m_VerticalScrollbarSpacing;
    
            /// <summary>
            /// The space between the scrollbar and the viewport.
            /// </summary>
            public float verticalScrollbarSpacing { get { return m_VerticalScrollbarSpacing; } set { m_VerticalScrollbarSpacing = value; SetDirty(); } }
    
            [SerializeField]
            private ScrollRectEvent m_OnValueChanged = new ScrollRectEvent();
    
            /// <summary>
            /// Callback executed when the position of the child changes.
            /// </summary>
            /// <remarks>
            /// onValueChanged is used to watch for changes in the ScrollRect object.
            /// The onValueChanged call will use the UnityEvent.AddListener API to watch for
            /// changes.  When changes happen script code provided by the user will be called.
            /// The UnityEvent.AddListener API for UI.ScrollRect._onValueChanged takes a Vector2.
            ///
            /// Note: The editor allows the onValueChanged value to be set up manually.For example the
            /// value can be set to run only a runtime.  The object and script function to call are also
            /// provided here.
            ///
            /// The onValueChanged variable can be alternatively set-up at runtime.The script example below
            /// shows how this can be done.The script is attached to the ScrollRect object.
            /// </remarks>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using UnityEngine.UI;
            ///
            /// public class ExampleScript : MonoBehaviour
            /// {
            ///     static ScrollRect scrollRect;
            ///
            ///     void Start()
            ///     {
            ///         scrollRect = GetComponent<ScrollRect>();
            ///         scrollRect.onValueChanged.AddListener(ListenerMethod);
            ///     }
            ///
            ///     public void ListenerMethod(Vector2 value)
            ///     {
            ///         Debug.Log("ListenerMethod: " + value);
            ///     }
            /// }
            /// </code>
            /// </example>
            public ScrollRectEvent onValueChanged { get { return m_OnValueChanged; } set { m_OnValueChanged = value; } }
    
            // The offset from handle position to mouse down position
            private Vector2 m_PointerStartLocalCursor = Vector2.zero;
            protected Vector2 m_ContentStartPosition = Vector2.zero;
    
            private RectTransform m_ViewRect;
    
            protected RectTransform viewRect
            {
                get
                {
                    if (m_ViewRect == null)
                        m_ViewRect = m_Viewport;
                    if (m_ViewRect == null)
                        m_ViewRect = (RectTransform)transform;
                    return m_ViewRect;
                }
            }
    
            protected Bounds m_ContentBounds;
            private Bounds m_ViewBounds;
    
            private Vector2 m_Velocity;
    
            /// <summary>
            /// The current velocity of the content.
            /// </summary>
            /// <remarks>
            /// The velocity is defined in units per second.
            /// </remarks>
            public Vector2 velocity { get { return m_Velocity; } set { m_Velocity = value; } }
    
            private bool m_Dragging;
            private bool m_Scrolling;
    
            private Vector2 m_PrevPosition = Vector2.zero;
            private Bounds m_PrevContentBounds;
            private Bounds m_PrevViewBounds;
            [NonSerialized]
            private bool m_HasRebuiltLayout = false;
    
            private bool m_HSliderExpand;
            private bool m_VSliderExpand;
            private float m_HSliderHeight;
            private float m_VSliderWidth;
    
            [System.NonSerialized] private RectTransform m_Rect;
            private RectTransform rectTransform
            {
                get
                {
                    if (m_Rect == null)
                        m_Rect = GetComponent<RectTransform>();
                    return m_Rect;
                }
            }
    
            private RectTransform m_HorizontalScrollbarRect;
            private RectTransform m_VerticalScrollbarRect;
    
            private DrivenRectTransformTracker m_Tracker;
    
            protected MyCancelDragScrollRect()
            { }
    
            /// <summary>
            /// Rebuilds the scroll rect data after initialization.
            /// </summary>
            /// <param name="executing">The current step in the rendering CanvasUpdate cycle.</param>
            public virtual void Rebuild(CanvasUpdate executing)
            {
                if (executing == CanvasUpdate.Prelayout)
                {
                    UpdateCachedData();
                }
    
                if (executing == CanvasUpdate.PostLayout)
                {
                    UpdateBounds();
                    UpdateScrollbars(Vector2.zero);
                    UpdatePrevData();
    
                    m_HasRebuiltLayout = true;
                }
            }
    
            public virtual void LayoutComplete()
            { }
    
            public virtual void GraphicUpdateComplete()
            { }
    
            void UpdateCachedData()
            {
                Transform transform = this.transform;
                m_HorizontalScrollbarRect = m_HorizontalScrollbar == null ? null : m_HorizontalScrollbar.transform as RectTransform;
                m_VerticalScrollbarRect = m_VerticalScrollbar == null ? null : m_VerticalScrollbar.transform as RectTransform;
    
                // These are true if either the elements are children, or they don't exist at all.
                bool viewIsChild = (viewRect.parent == transform);
                bool hScrollbarIsChild = (!m_HorizontalScrollbarRect || m_HorizontalScrollbarRect.parent == transform);
                bool vScrollbarIsChild = (!m_VerticalScrollbarRect || m_VerticalScrollbarRect.parent == transform);
                bool allAreChildren = (viewIsChild && hScrollbarIsChild && vScrollbarIsChild);
    
                m_HSliderExpand = allAreChildren && m_HorizontalScrollbarRect && horizontalScrollbarVisibility == ScrollbarVisibility.AutoHideAndExpandViewport;
                m_VSliderExpand = allAreChildren && m_VerticalScrollbarRect && verticalScrollbarVisibility == ScrollbarVisibility.AutoHideAndExpandViewport;
                m_HSliderHeight = (m_HorizontalScrollbarRect == null ? 0 : m_HorizontalScrollbarRect.rect.height);
                m_VSliderWidth = (m_VerticalScrollbarRect == null ? 0 : m_VerticalScrollbarRect.rect.width);
            }
    
            protected override void OnEnable()
            {
                base.OnEnable();
    
                if (m_HorizontalScrollbar)
                    m_HorizontalScrollbar.onValueChanged.AddListener(SetHorizontalNormalizedPosition);
                if (m_VerticalScrollbar)
                    m_VerticalScrollbar.onValueChanged.AddListener(SetVerticalNormalizedPosition);
    
                CanvasUpdateRegistry.RegisterCanvasElementForLayoutRebuild(this);
                SetDirty();
            }
    
            protected override void OnDisable()
            {
                CanvasUpdateRegistry.UnRegisterCanvasElementForRebuild(this);
    
                if (m_HorizontalScrollbar)
                    m_HorizontalScrollbar.onValueChanged.RemoveListener(SetHorizontalNormalizedPosition);
                if (m_VerticalScrollbar)
                    m_VerticalScrollbar.onValueChanged.RemoveListener(SetVerticalNormalizedPosition);
    
                m_Dragging = false;
                m_Scrolling = false;
                m_HasRebuiltLayout = false;
                m_Tracker.Clear();
                m_Velocity = Vector2.zero;
                LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
                base.OnDisable();
            }
    
            /// <summary>
            /// See member in base class.
            /// </summary>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.UI;  // Required when Using UI elements.
            ///
            /// public class ExampleClass : MonoBehaviour
            /// {
            ///     public ScrollRect myScrollRect;
            ///
            ///     public void Start()
            ///     {
            ///         //Checks if the ScrollRect called "myScrollRect" is active.
            ///         if (myScrollRect.IsActive())
            ///         {
            ///             Debug.Log("The Scroll Rect is active!");
            ///         }
            ///     }
            /// }
            /// </code>
            /// </example>
            public override bool IsActive()
            {
                return base.IsActive() && m_Content != null;
            }
    
            private void EnsureLayoutHasRebuilt()
            {
                if (!m_HasRebuiltLayout && !CanvasUpdateRegistry.IsRebuildingLayout())
                    Canvas.ForceUpdateCanvases();
            }
    
            /// <summary>
            /// Sets the velocity to zero on both axes so the content stops moving.
            /// </summary>
            public virtual void StopMovement()
            {
                m_Velocity = Vector2.zero;
            }
    
            public virtual void OnScroll(PointerEventData data)
            {
                if (!IsActive())
                    return;
    
                EnsureLayoutHasRebuilt();
                UpdateBounds();
    
                Vector2 delta = data.scrollDelta;
                // Down is positive for scroll events, while in UI system up is positive.
                delta.y *= -1;
                if (vertical && !horizontal)
                {
                    if (Mathf.Abs(delta.x) > Mathf.Abs(delta.y))
                        delta.y = delta.x;
                    delta.x = 0;
                }
                if (horizontal && !vertical)
                {
                    if (Mathf.Abs(delta.y) > Mathf.Abs(delta.x))
                        delta.x = delta.y;
                    delta.y = 0;
                }
    
                if (data.IsScrolling())
                    m_Scrolling = true;
    
                Vector2 position = m_Content.anchoredPosition;
                position += delta * m_ScrollSensitivity;
                if (m_MovementType == MovementType.Clamped)
                    position += CalculateOffset(position - m_Content.anchoredPosition);
    
                SetContentAnchoredPosition(position);
                UpdateBounds();
            }
    
            public virtual void OnInitializePotentialDrag(PointerEventData eventData)
            {
                if (eventData.button != PointerEventData.InputButton.Left)
                    return;
    
                m_Velocity = Vector2.zero;
            }
    
            /// <summary>
            /// Handling for when the content is beging being dragged.
            /// </summary>
            ///<example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.EventSystems; // Required when using event data
            ///
            /// public class ExampleClass : MonoBehaviour, IBeginDragHandler // required interface when using the OnBeginDrag method.
            /// {
            ///     //Do this when the user starts dragging the element this script is attached to..
            ///     public void OnBeginDrag(PointerEventData data)
            ///     {
            ///         Debug.Log("They started dragging " + this.name);
            ///     }
            /// }
            /// </code>
            /// </example>
            public virtual void OnBeginDrag(PointerEventData eventData)
            {
                if (eventData.button != PointerEventData.InputButton.Left)
                    return;
    
                if (!IsActive())
                    return;
    
                UpdateBounds();
    
                m_PointerStartLocalCursor = Vector2.zero;
                RectTransformUtility.ScreenPointToLocalPointInRectangle(viewRect, eventData.position, eventData.pressEventCamera, out m_PointerStartLocalCursor);
                m_ContentStartPosition = m_Content.anchoredPosition;
                m_Dragging = true;
            }
    
            /// <summary>
            /// Handling for when the content has finished being dragged.
            /// </summary>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.EventSystems; // Required when using event data
            ///
            /// public class ExampleClass : MonoBehaviour, IEndDragHandler // required interface when using the OnEndDrag method.
            /// {
            ///     //Do this when the user stops dragging this UI Element.
            ///     public void OnEndDrag(PointerEventData data)
            ///     {
            ///         Debug.Log("Stopped dragging " + this.name + "!");
            ///     }
            /// }
            /// </code>
            /// </example>
            public virtual void OnEndDrag(PointerEventData eventData)
            {
                if (eventData.button != PointerEventData.InputButton.Left)
                    return;
    
                m_Dragging = false;
            }
    
            /// <summary>
            /// Handling for when the content is dragged.
            /// </summary>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.EventSystems; // Required when using event data
            ///
            /// public class ExampleClass : MonoBehaviour, IDragHandler // required interface when using the OnDrag method.
            /// {
            ///     //Do this while the user is dragging this UI Element.
            ///     public void OnDrag(PointerEventData data)
            ///     {
            ///         Debug.Log("Currently dragging " + this.name);
            ///     }
            /// }
            /// </code>
            /// </example>
            public virtual void OnDrag(PointerEventData eventData)
            {
                if (!m_Dragging)
                    return;
    
                if (eventData.button != PointerEventData.InputButton.Left)
                    return;
    
                if (!IsActive())
                    return;
    
                Vector2 localCursor;
                if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(viewRect, eventData.position, eventData.pressEventCamera, out localCursor))
                    return;
    
                UpdateBounds();
    
                var pointerDelta = localCursor - m_PointerStartLocalCursor;
                Vector2 position = m_ContentStartPosition + pointerDelta;
    
                // Offset to get content into place in the view.
                Vector2 offset = CalculateOffset(position - m_Content.anchoredPosition);
                position += offset;
                if (m_MovementType == MovementType.Elastic)
                {
                    if (offset.x != 0)
                        position.x = position.x - RubberDelta(offset.x, m_ViewBounds.size.x);
                    if (offset.y != 0)
                        position.y = position.y - RubberDelta(offset.y, m_ViewBounds.size.y);
                }
    
                SetContentAnchoredPosition(position);
            }
    
            /// <summary>
            /// Sets the anchored position of the content.
            /// </summary>
            protected virtual void SetContentAnchoredPosition(Vector2 position)
            {
                if (!m_Horizontal)
                    position.x = m_Content.anchoredPosition.x;
                if (!m_Vertical)
                    position.y = m_Content.anchoredPosition.y;
    
                if (position != m_Content.anchoredPosition)
                {
                    m_Content.anchoredPosition = position;
                    UpdateBounds();
                }
            }
    
            protected virtual void LateUpdate()
            {
                if (!m_Content)
                    return;
    
                EnsureLayoutHasRebuilt();
                UpdateBounds();
                float deltaTime = Time.unscaledDeltaTime;
                Vector2 offset = CalculateOffset(Vector2.zero);
                if (!m_Dragging && (offset != Vector2.zero || m_Velocity != Vector2.zero))
                {
                    Vector2 position = m_Content.anchoredPosition;
                    for (int axis = 0; axis < 2; axis++)
                    {
                        // Apply spring physics if movement is elastic and content has an offset from the view.
                        if (m_MovementType == MovementType.Elastic && offset[axis] != 0)
                        {
                            float speed = m_Velocity[axis];
                            float smoothTime = m_Elasticity;
                            if (m_Scrolling)
                                smoothTime *= 3.0f;
                            position[axis] = Mathf.SmoothDamp(m_Content.anchoredPosition[axis], m_Content.anchoredPosition[axis] + offset[axis], ref speed, smoothTime, Mathf.Infinity, deltaTime);
                            if (Mathf.Abs(speed) < 1)
                                speed = 0;
                            m_Velocity[axis] = speed;
                        }
                        // Else move content according to velocity with deceleration applied.
                        else if (m_Inertia)
                        {
                            m_Velocity[axis] *= Mathf.Pow(m_DecelerationRate, deltaTime);
                            if (Mathf.Abs(m_Velocity[axis]) < 1)
                                m_Velocity[axis] = 0;
                            position[axis] += m_Velocity[axis] * deltaTime;
                        }
                        // If we have neither elaticity or friction, there shouldn't be any velocity.
                        else
                        {
                            m_Velocity[axis] = 0;
                        }
                    }
    
                    if (m_MovementType == MovementType.Clamped)
                    {
                        offset = CalculateOffset(position - m_Content.anchoredPosition);
                        position += offset;
                    }
    
                    SetContentAnchoredPosition(position);
                }
    
                if (m_Dragging && m_Inertia)
                {
                    Vector3 newVelocity = (m_Content.anchoredPosition - m_PrevPosition) / deltaTime;
                    m_Velocity = Vector3.Lerp(m_Velocity, newVelocity, deltaTime * 10);
                }
    
                if (m_ViewBounds != m_PrevViewBounds || m_ContentBounds != m_PrevContentBounds || m_Content.anchoredPosition != m_PrevPosition)
                {
                    UpdateScrollbars(offset);
                    UISystemProfilerApi.AddMarker("ScrollRect.value", this);
                    m_OnValueChanged.Invoke(normalizedPosition);
                    UpdatePrevData();
                }
                UpdateScrollbarVisibility();
                m_Scrolling = false;
            }
    
            /// <summary>
            /// Helper function to update the previous data fields on a ScrollRect. Call this before you change data in the ScrollRect.
            /// </summary>
            protected void UpdatePrevData()
            {
                if (m_Content == null)
                    m_PrevPosition = Vector2.zero;
                else
                    m_PrevPosition = m_Content.anchoredPosition;
                m_PrevViewBounds = m_ViewBounds;
                m_PrevContentBounds = m_ContentBounds;
            }
    
            private void UpdateScrollbars(Vector2 offset)
            {
                if (m_HorizontalScrollbar)
                {
                    if (m_ContentBounds.size.x > 0)
                        m_HorizontalScrollbar.size = Mathf.Clamp01((m_ViewBounds.size.x - Mathf.Abs(offset.x)) / m_ContentBounds.size.x);
                    else
                        m_HorizontalScrollbar.size = 1;
    
                    m_HorizontalScrollbar.value = horizontalNormalizedPosition;
                }
    
                if (m_VerticalScrollbar)
                {
                    if (m_ContentBounds.size.y > 0)
                        m_VerticalScrollbar.size = Mathf.Clamp01((m_ViewBounds.size.y - Mathf.Abs(offset.y)) / m_ContentBounds.size.y);
                    else
                        m_VerticalScrollbar.size = 1;
    
                    m_VerticalScrollbar.value = verticalNormalizedPosition;
                }
            }
    
            /// <summary>
            /// The scroll position as a Vector2 between (0,0) and (1,1) with (0,0) being the lower left corner.
            /// </summary>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.UI;  // Required when Using UI elements.
            ///
            /// public class ExampleClass : MonoBehaviour
            /// {
            ///     public ScrollRect myScrollRect;
            ///     public Vector2 myPosition = new Vector2(0.5f, 0.5f);
            ///
            ///     public void Start()
            ///     {
            ///         //Change the current scroll position.
            ///         myScrollRect.normalizedPosition = myPosition;
            ///     }
            /// }
            /// </code>
            /// </example>
            public Vector2 normalizedPosition
            {
                get
                {
                    return new Vector2(horizontalNormalizedPosition, verticalNormalizedPosition);
                }
                set
                {
                    SetNormalizedPosition(value.x, 0);
                    SetNormalizedPosition(value.y, 1);
                }
            }
    
            /// <summary>
            /// The horizontal scroll position as a value between 0 and 1, with 0 being at the left.
            /// </summary>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.UI;  // Required when Using UI elements.
            ///
            /// public class ExampleClass : MonoBehaviour
            /// {
            ///     public ScrollRect myScrollRect;
            ///     public Scrollbar newScrollBar;
            ///
            ///     public void Start()
            ///     {
            ///         //Change the current horizontal scroll position.
            ///         myScrollRect.horizontalNormalizedPosition = 0.5f;
            ///     }
            /// }
            /// </code>
            /// </example>
            public float horizontalNormalizedPosition
            {
                get
                {
                    UpdateBounds();
                    if ((m_ContentBounds.size.x <= m_ViewBounds.size.x) || Mathf.Approximately(m_ContentBounds.size.x, m_ViewBounds.size.x))
                        return (m_ViewBounds.min.x > m_ContentBounds.min.x) ? 1 : 0;
                    return (m_ViewBounds.min.x - m_ContentBounds.min.x) / (m_ContentBounds.size.x - m_ViewBounds.size.x);
                }
                set
                {
                    SetNormalizedPosition(value, 0);
                }
            }
    
            /// <summary>
            /// The vertical scroll position as a value between 0 and 1, with 0 being at the bottom.
            /// </summary>
            /// <example>
            /// <code>
            /// using UnityEngine;
            /// using System.Collections;
            /// using UnityEngine.UI;  // Required when Using UI elements.
            ///
            /// public class ExampleClass : MonoBehaviour
            /// {
            ///     public ScrollRect myScrollRect;
            ///     public Scrollbar newScrollBar;
            ///
            ///     public void Start()
            ///     {
            ///         //Change the current vertical scroll position.
            ///         myScrollRect.verticalNormalizedPosition = 0.5f;
            ///     }
            /// }
            /// </code>
            /// </example>
    
            public float verticalNormalizedPosition
            {
                get
                {
                    UpdateBounds();
                    if ((m_ContentBounds.size.y <= m_ViewBounds.size.y) || Mathf.Approximately(m_ContentBounds.size.y, m_ViewBounds.size.y))
                        return (m_ViewBounds.min.y > m_ContentBounds.min.y) ? 1 : 0;
    
                    return (m_ViewBounds.min.y - m_ContentBounds.min.y) / (m_ContentBounds.size.y - m_ViewBounds.size.y);
                }
                set
                {
                    SetNormalizedPosition(value, 1);
                }
            }
    
            private void SetHorizontalNormalizedPosition(float value) { SetNormalizedPosition(value, 0); }
            private void SetVerticalNormalizedPosition(float value) { SetNormalizedPosition(value, 1); }
    
            /// <summary>
            /// >Set the horizontal or vertical scroll position as a value between 0 and 1, with 0 being at the left or at the bottom.
            /// </summary>
            /// <param name="value">The position to set, between 0 and 1.</param>
            /// <param name="axis">The axis to set: 0 for horizontal, 1 for vertical.</param>
            protected virtual void SetNormalizedPosition(float value, int axis)
            {
                EnsureLayoutHasRebuilt();
                UpdateBounds();
                // How much the content is larger than the view.
                float hiddenLength = m_ContentBounds.size[axis] - m_ViewBounds.size[axis];
                // Where the position of the lower left corner of the content bounds should be, in the space of the view.
                float contentBoundsMinPosition = m_ViewBounds.min[axis] - value * hiddenLength;
                // The new content localPosition, in the space of the view.
                float newLocalPosition = m_Content.localPosition[axis] + contentBoundsMinPosition - m_ContentBounds.min[axis];
    
                Vector3 localPosition = m_Content.localPosition;
                if (Mathf.Abs(localPosition[axis] - newLocalPosition) > 0.01f)
                {
                    localPosition[axis] = newLocalPosition;
                    m_Content.localPosition = localPosition;
                    m_Velocity[axis] = 0;
                    UpdateBounds();
                }
            }
    
            private static float RubberDelta(float overStretching, float viewSize)
            {
                return (1 - (1 / ((Mathf.Abs(overStretching) * 0.55f / viewSize) + 1))) * viewSize * Mathf.Sign(overStretching);
            }
    
            protected override void OnRectTransformDimensionsChange()
            {
                SetDirty();
            }
    
            private bool hScrollingNeeded
            {
                get
                {
                    if (Application.isPlaying)
                        return m_ContentBounds.size.x > m_ViewBounds.size.x + 0.01f;
                    return true;
                }
            }
            private bool vScrollingNeeded
            {
                get
                {
                    if (Application.isPlaying)
                        return m_ContentBounds.size.y > m_ViewBounds.size.y + 0.01f;
                    return true;
                }
            }
    
            /// <summary>
            /// Called by the layout system.
            /// </summary>
            public virtual void CalculateLayoutInputHorizontal() { }
    
            /// <summary>
            /// Called by the layout system.
            /// </summary>
            public virtual void CalculateLayoutInputVertical() { }
    
            /// <summary>
            /// Called by the layout system.
            /// </summary>
            public virtual float minWidth { get { return -1; } }
            /// <summary>
            /// Called by the layout system.
            /// </summary>
            public virtual float preferredWidth { get { return -1; } }
            /// <summary>
            /// Called by the layout system.
            /// </summary>
            public virtual float flexibleWidth { get { return -1; } }
    
            /// <summary>
            /// Called by the layout system.
            /// </summary>
            public virtual float minHeight { get { return -1; } }
            /// <summary>
            /// Called by the layout system.
            /// </summary>
            public virtual float preferredHeight { get { return -1; } }
            /// <summary>
            /// Called by the layout system.
            /// </summary>
            public virtual float flexibleHeight { get { return -1; } }
    
            /// <summary>
            /// Called by the layout system.
            /// </summary>
            public virtual int layoutPriority { get { return -1; } }
    
            /// <summary>
            /// Called by the layout system.
            /// </summary>
            public virtual void SetLayoutHorizontal()
            {
                m_Tracker.Clear();
    
                if (m_HSliderExpand || m_VSliderExpand)
                {
                    m_Tracker.Add(this, viewRect,
                        DrivenTransformProperties.Anchors |
                        DrivenTransformProperties.SizeDelta |
                        DrivenTransformProperties.AnchoredPosition);
    
                    // Make view full size to see if content fits.
                    viewRect.anchorMin = Vector2.zero;
                    viewRect.anchorMax = Vector2.one;
                    viewRect.sizeDelta = Vector2.zero;
                    viewRect.anchoredPosition = Vector2.zero;
    
                    // Recalculate content layout with this size to see if it fits when there are no scrollbars.
                    LayoutRebuilder.ForceRebuildLayoutImmediate(content);
                    m_ViewBounds = new Bounds(viewRect.rect.center, viewRect.rect.size);
                    m_ContentBounds = GetBounds();
                }
    
                // If it doesn't fit vertically, enable vertical scrollbar and shrink view horizontally to make room for it.
                if (m_VSliderExpand && vScrollingNeeded)
                {
                    viewRect.sizeDelta = new Vector2(-(m_VSliderWidth + m_VerticalScrollbarSpacing), viewRect.sizeDelta.y);
    
                    // Recalculate content layout with this size to see if it fits vertically
                    // when there is a vertical scrollbar (which may reflowed the content to make it taller).
                    LayoutRebuilder.ForceRebuildLayoutImmediate(content);
                    m_ViewBounds = new Bounds(viewRect.rect.center, viewRect.rect.size);
                    m_ContentBounds = GetBounds();
                }
    
                // If it doesn't fit horizontally, enable horizontal scrollbar and shrink view vertically to make room for it.
                if (m_HSliderExpand && hScrollingNeeded)
                {
                    viewRect.sizeDelta = new Vector2(viewRect.sizeDelta.x, -(m_HSliderHeight + m_HorizontalScrollbarSpacing));
                    m_ViewBounds = new Bounds(viewRect.rect.center, viewRect.rect.size);
                    m_ContentBounds = GetBounds();
                }
    
                // If the vertical slider didn't kick in the first time, and the horizontal one did,
                // we need to check again if the vertical slider now needs to kick in.
                // If it doesn't fit vertically, enable vertical scrollbar and shrink view horizontally to make room for it.
                if (m_VSliderExpand && vScrollingNeeded && viewRect.sizeDelta.x == 0 && viewRect.sizeDelta.y < 0)
                {
                    viewRect.sizeDelta = new Vector2(-(m_VSliderWidth + m_VerticalScrollbarSpacing), viewRect.sizeDelta.y);
                }
            }
    
            /// <summary>
            /// Called by the layout system.
            /// </summary>
            public virtual void SetLayoutVertical()
            {
                UpdateScrollbarLayout();
                m_ViewBounds = new Bounds(viewRect.rect.center, viewRect.rect.size);
                m_ContentBounds = GetBounds();
            }
    
            void UpdateScrollbarVisibility()
            {
                UpdateOneScrollbarVisibility(vScrollingNeeded, m_Vertical, m_VerticalScrollbarVisibility, m_VerticalScrollbar);
                UpdateOneScrollbarVisibility(hScrollingNeeded, m_Horizontal, m_HorizontalScrollbarVisibility, m_HorizontalScrollbar);
            }
    
            private static void UpdateOneScrollbarVisibility(bool xScrollingNeeded, bool xAxisEnabled, ScrollbarVisibility scrollbarVisibility, Scrollbar scrollbar)
            {
                if (scrollbar)
                {
                    if (scrollbarVisibility == ScrollbarVisibility.Permanent)
                    {
                        if (scrollbar.gameObject.activeSelf != xAxisEnabled)
                            scrollbar.gameObject.SetActive(xAxisEnabled);
                    }
                    else
                    {
                        if (scrollbar.gameObject.activeSelf != xScrollingNeeded)
                            scrollbar.gameObject.SetActive(xScrollingNeeded);
                    }
                }
            }
    
            void UpdateScrollbarLayout()
            {
                if (m_VSliderExpand && m_HorizontalScrollbar)
                {
                    m_Tracker.Add(this, m_HorizontalScrollbarRect,
                        DrivenTransformProperties.AnchorMinX |
                        DrivenTransformProperties.AnchorMaxX |
                        DrivenTransformProperties.SizeDeltaX |
                        DrivenTransformProperties.AnchoredPositionX);
                    m_HorizontalScrollbarRect.anchorMin = new Vector2(0, m_HorizontalScrollbarRect.anchorMin.y);
                    m_HorizontalScrollbarRect.anchorMax = new Vector2(1, m_HorizontalScrollbarRect.anchorMax.y);
                    m_HorizontalScrollbarRect.anchoredPosition = new Vector2(0, m_HorizontalScrollbarRect.anchoredPosition.y);
                    if (vScrollingNeeded)
                        m_HorizontalScrollbarRect.sizeDelta = new Vector2(-(m_VSliderWidth + m_VerticalScrollbarSpacing), m_HorizontalScrollbarRect.sizeDelta.y);
                    else
                        m_HorizontalScrollbarRect.sizeDelta = new Vector2(0, m_HorizontalScrollbarRect.sizeDelta.y);
                }
    
                if (m_HSliderExpand && m_VerticalScrollbar)
                {
                    m_Tracker.Add(this, m_VerticalScrollbarRect,
                        DrivenTransformProperties.AnchorMinY |
                        DrivenTransformProperties.AnchorMaxY |
                        DrivenTransformProperties.SizeDeltaY |
                        DrivenTransformProperties.AnchoredPositionY);
                    m_VerticalScrollbarRect.anchorMin = new Vector2(m_VerticalScrollbarRect.anchorMin.x, 0);
                    m_VerticalScrollbarRect.anchorMax = new Vector2(m_VerticalScrollbarRect.anchorMax.x, 1);
                    m_VerticalScrollbarRect.anchoredPosition = new Vector2(m_VerticalScrollbarRect.anchoredPosition.x, 0);
                    if (hScrollingNeeded)
                        m_VerticalScrollbarRect.sizeDelta = new Vector2(m_VerticalScrollbarRect.sizeDelta.x, -(m_HSliderHeight + m_HorizontalScrollbarSpacing));
                    else
                        m_VerticalScrollbarRect.sizeDelta = new Vector2(m_VerticalScrollbarRect.sizeDelta.x, 0);
                }
            }
    
            /// <summary>
            /// Calculate the bounds the ScrollRect should be using.
            /// </summary>
            protected void UpdateBounds()
            {
                m_ViewBounds = new Bounds(viewRect.rect.center, viewRect.rect.size);
                m_ContentBounds = GetBounds();
    
                if (m_Content == null)
                    return;
    
                Vector3 contentSize = m_ContentBounds.size;
                Vector3 contentPos = m_ContentBounds.center;
                var contentPivot = m_Content.pivot;
                AdjustBounds(ref m_ViewBounds, ref contentPivot, ref contentSize, ref contentPos);
                m_ContentBounds.size = contentSize;
                m_ContentBounds.center = contentPos;
    
                if (movementType == MovementType.Clamped)
                {
                    // Adjust content so that content bounds bottom (right side) is never higher (to the left) than the view bounds bottom (right side).
                    // top (left side) is never lower (to the right) than the view bounds top (left side).
                    // All this can happen if content has shrunk.
                    // This works because content size is at least as big as view size (because of the call to InternalUpdateBounds above).
                    Vector2 delta = Vector2.zero;
                    if (m_ViewBounds.max.x > m_ContentBounds.max.x)
                    {
                        delta.x = Math.Min(m_ViewBounds.min.x - m_ContentBounds.min.x, m_ViewBounds.max.x - m_ContentBounds.max.x);
                    }
                    else if (m_ViewBounds.min.x < m_ContentBounds.min.x)
                    {
                        delta.x = Math.Max(m_ViewBounds.min.x - m_ContentBounds.min.x, m_ViewBounds.max.x - m_ContentBounds.max.x);
                    }
    
                    if (m_ViewBounds.min.y < m_ContentBounds.min.y)
                    {
                        delta.y = Math.Max(m_ViewBounds.min.y - m_ContentBounds.min.y, m_ViewBounds.max.y - m_ContentBounds.max.y);
                    }
                    else if (m_ViewBounds.max.y > m_ContentBounds.max.y)
                    {
                        delta.y = Math.Min(m_ViewBounds.min.y - m_ContentBounds.min.y, m_ViewBounds.max.y - m_ContentBounds.max.y);
                    }
                    if (delta.sqrMagnitude > float.Epsilon)
                    {
                        contentPos = m_Content.anchoredPosition + delta;
                        if (!m_Horizontal)
                            contentPos.x = m_Content.anchoredPosition.x;
                        if (!m_Vertical)
                            contentPos.y = m_Content.anchoredPosition.y;
                        AdjustBounds(ref m_ViewBounds, ref contentPivot, ref contentSize, ref contentPos);
                    }
                }
            }
    
            internal static void AdjustBounds(ref Bounds viewBounds, ref Vector2 contentPivot, ref Vector3 contentSize, ref Vector3 contentPos)
            {
                // Make sure content bounds are at least as large as view by adding padding if not.
                // One might think at first that if the content is smaller than the view, scrolling should be allowed.
                // However, that's not how scroll views normally work.
                // Scrolling is *only* possible when content is *larger* than view.
                // We use the pivot of the content rect to decide in which directions the content bounds should be expanded.
                // E.g. if pivot is at top, bounds are expanded downwards.
                // This also works nicely when ContentSizeFitter is used on the content.
                Vector3 excess = viewBounds.size - contentSize;
                if (excess.x > 0)
                {
                    contentPos.x -= excess.x * (contentPivot.x - 0.5f);
                    contentSize.x = viewBounds.size.x;
                }
                if (excess.y > 0)
                {
                    contentPos.y -= excess.y * (contentPivot.y - 0.5f);
                    contentSize.y = viewBounds.size.y;
                }
            }
    
            private readonly Vector3[] m_Corners = new Vector3[4];
            private Bounds GetBounds()
            {
                if (m_Content == null)
                    return new Bounds();
                m_Content.GetWorldCorners(m_Corners);
                var viewWorldToLocalMatrix = viewRect.worldToLocalMatrix;
                return InternalGetBounds(m_Corners, ref viewWorldToLocalMatrix);
            }
    
            internal static Bounds InternalGetBounds(Vector3[] corners, ref Matrix4x4 viewWorldToLocalMatrix)
            {
                var vMin = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
                var vMax = new Vector3(float.MinValue, float.MinValue, float.MinValue);
    
                for (int j = 0; j < 4; j++)
                {
                    Vector3 v = viewWorldToLocalMatrix.MultiplyPoint3x4(corners[j]);
                    vMin = Vector3.Min(v, vMin);
                    vMax = Vector3.Max(v, vMax);
                }
    
                var bounds = new Bounds(vMin, Vector3.zero);
                bounds.Encapsulate(vMax);
                return bounds;
            }
    
            private Vector2 CalculateOffset(Vector2 delta)
            {
                return InternalCalculateOffset(ref m_ViewBounds, ref m_ContentBounds, m_Horizontal, m_Vertical, m_MovementType, ref delta);
            }
    
            internal static Vector2 InternalCalculateOffset(ref Bounds viewBounds, ref Bounds contentBounds, bool horizontal, bool vertical, MovementType movementType, ref Vector2 delta)
            {
                Vector2 offset = Vector2.zero;
                if (movementType == MovementType.Unrestricted)
                    return offset;
    
    
                Vector2 min = contentBounds.min;
                Vector2 max = contentBounds.max;
    
                // min/max offset extracted to check if approximately 0 and avoid recalculating layout every frame (case 1010178)
    
                if (horizontal)
                {
                    min.x += delta.x;
                    max.x += delta.x;
    
                    float maxOffset = viewBounds.max.x - max.x;
                    float minOffset = viewBounds.min.x - min.x;
    
                    if (minOffset < -0.001f)
                        offset.x = minOffset;
                    else if (maxOffset > 0.001f)
                        offset.x = maxOffset;
                }
    
                if (vertical)
                {
                    min.y += delta.y;
                    max.y += delta.y;
    
                    float maxOffset = viewBounds.max.y - max.y;
                    float minOffset = viewBounds.min.y - min.y;
    
                    if (maxOffset > 0.001f)
                        offset.y = maxOffset;
                    else if (minOffset < -0.001f)
                        offset.y = minOffset;
                }
    
                return offset;
            }
    
            /// <summary>
            /// Override to alter or add to the code that keeps the appearance of the scroll rect synced with its data.
            /// </summary>
            protected void SetDirty()
            {
                if (!IsActive())
                    return;
    
                LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
            }
    
            /// <summary>
            /// Override to alter or add to the code that caches data to avoid repeated heavy operations.
            /// </summary>
            protected void SetDirtyCaching()
            {
                if (!IsActive())
                    return;
    
                CanvasUpdateRegistry.RegisterCanvasElementForLayoutRebuild(this);
                LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
    
                m_ViewRect = null;
            }
    
    #if UNITY_EDITOR
            protected override void OnValidate()
            {
                SetDirtyCaching();
            }
    
    #endif
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 10][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70]: /images/20221005/b24de59a079f40e8bdfb2d747cf21595.png
[20210622205849329.gif]: /images/20221005/274b669410dc4ad6b2d3cb9df9c5d1cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 1]: /images/20221005/4260583caa514ec790586dde4a4aace9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 2]: /images/20221005/b5170c95163b4260aeae59cec8ef643f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 3]: /images/20221005/f98d8f55e16d40098b1ece7e6ec2a45a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 4]: /images/20221005/71ab52edc00145388022862be9fa6ed5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 5]: /images/20221005/68a6357519b54224aadb663ee73bbc5f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 6]: /images/20221005/9085e45dd1c4495b8265793366901dc3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 7]: /images/20221005/af954443d4ec44efbaaa6e1ea1f3c751.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 8]: /images/20221005/ea32baf076b84159b64c1cd6d1f18a2a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 9]: /images/20221005/468b5f57d0cf45c6983d6b544cd54187.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 10]: /images/20221005/6485b56642f645109c4a5f68da53ced9.png