RectTransformFitter anchor and pivot bindings

[oktayturkdagli]

The RectTransformFitter feature is great and very useful. I use this feature except for masking. But in this component anchor and pivot points are not connected, it would be great if we could choose to connect them too.

[oktayturkdagli]

Hmm... I have written a small example with AI. There are offsets and the pivots work as I expected. I think only disabling pivots and anchors is not working :) I'm leaving it here in case it might help.

using UnityEngine;
using UnityEngine.UI;

#if UNITY_EDITOR
using UnityEditor;
#endif

namespace Main
{
    /// <summary>
    /// Binds a RectTransform to another RectTransform and follows its properties.
    /// </summary>
    [ExecuteAlways]
    [DisallowMultipleComponent]
    [RequireComponent(typeof(RectTransform))]
    public class RectTransformBinder : MonoBehaviour, ILayoutIgnorer
    {
        [System.Flags]
        public enum BindingOptions
        {
            None = 0,
            Position = 1 << 0,
            Rotation = 1 << 1,
            Scale = 1 << 2,
            Size = 1 << 3,
            Anchors = 1 << 4,
            Pivot = 1 << 5,
            All = Position | Rotation | Scale | Size | Anchors | Pivot
        }

        [Tooltip("Target RectTransform to follow")] [SerializeField]
        private RectTransform targetRectTransform;

        [Tooltip("Properties to follow")] [SerializeField]
        private BindingOptions bindingOptions = BindingOptions.All;

        [Tooltip("Position offset")] [SerializeField]
        private Vector2 positionOffset;

        [Tooltip("Size offset")] [SerializeField]
        private Vector2 sizeOffset;

        private RectTransform _rectTransform;

        // We should initialize this in each method where it's used instead of storing it as a field
        // This is because DrivenRectTransformTracker is a struct and doesn't maintain state when the script is reloaded

        private void Awake()
        {
            _rectTransform = GetComponent<RectTransform>();
        }

        private void OnEnable()
        {
            _rectTransform = GetComponent<RectTransform>();
            UpdateTracker();
            UpdateRectTransform();
        }

        private void OnDisable()
        {
            // Create a new tracker just to clear it
            DrivenRectTransformTracker tracker = new DrivenRectTransformTracker();
            tracker.Clear();
        }

        private void OnValidate()
        {
            // Update tracker when properties change in the editor
            if (isActiveAndEnabled && _rectTransform)
            {
                UpdateTracker();
            }
        }

        private void LateUpdate()
        {
            if (isActiveAndEnabled && targetRectTransform != null)
            {
                UpdateRectTransform();
            }
        }

        public void UpdateRectTransform()
        {
            if (!_rectTransform || !targetRectTransform)
                return;

            // Check if the target is a child of this transform
            if (targetRectTransform.IsChildOf(_rectTransform))
            {
                Debug.LogWarning("Target RectTransform cannot be a child of this object!", this);
                return;
            }

            // Position
            if ((bindingOptions & BindingOptions.Position) != 0)
            {
                _rectTransform.anchoredPosition = targetRectTransform.anchoredPosition + positionOffset;
            }

            // Rotation
            if ((bindingOptions & BindingOptions.Rotation) != 0)
            {
                _rectTransform.localRotation = targetRectTransform.localRotation;
            }

            // Scale
            if ((bindingOptions & BindingOptions.Scale) != 0)
            {
                _rectTransform.localScale = targetRectTransform.localScale;
            }

            // Size
            if ((bindingOptions & BindingOptions.Size) != 0)
            {
                _rectTransform.sizeDelta = targetRectTransform.sizeDelta + sizeOffset;
            }

            // Anchor points
            if ((bindingOptions & BindingOptions.Anchors) != 0)
            {
                _rectTransform.anchorMin = targetRectTransform.anchorMin;
                _rectTransform.anchorMax = targetRectTransform.anchorMax;
            }

            // Pivot point
            if ((bindingOptions & BindingOptions.Pivot) != 0)
            {
                _rectTransform.pivot = targetRectTransform.pivot;
            }
        }

        private void UpdateTracker()
        {
            // Create a new tracker each time
            DrivenRectTransformTracker tracker = new DrivenRectTransformTracker();

            // Clear any previously driven properties
            tracker.Clear();

            if (!isActiveAndEnabled || !_rectTransform)
                return;

            DrivenTransformProperties drivenProperties = DrivenTransformProperties.None;

            if ((bindingOptions & BindingOptions.Position) != 0)
                drivenProperties |= DrivenTransformProperties.AnchoredPosition;

            if ((bindingOptions & BindingOptions.Rotation) != 0)
                drivenProperties |= DrivenTransformProperties.Rotation;

            if ((bindingOptions & BindingOptions.Scale) != 0)
                drivenProperties |= DrivenTransformProperties.Scale;

            if ((bindingOptions & BindingOptions.Size) != 0)
                drivenProperties |= DrivenTransformProperties.SizeDeltaX | DrivenTransformProperties.SizeDeltaY;

            if ((bindingOptions & BindingOptions.Anchors) != 0)
                drivenProperties |= DrivenTransformProperties.Anchors;

            if ((bindingOptions & BindingOptions.Pivot) != 0)
                drivenProperties |= DrivenTransformProperties.Pivot;

            if (drivenProperties != DrivenTransformProperties.None)
                tracker.Add(this, _rectTransform, drivenProperties);
        }

        // ILayoutIgnorer implementation
        public bool ignoreLayout => true;
    }

#if UNITY_EDITOR
    [CustomEditor(typeof(RectTransformBinder))]
    public class RectTransformBinderEditor : Editor
    {
        private SerializedProperty _targetRectTransformProperty;
        private SerializedProperty _bindingOptionsProperty;
        private SerializedProperty _positionOffsetProperty;
        private SerializedProperty _sizeOffsetProperty;

        private void OnEnable()
        {
            _targetRectTransformProperty = serializedObject.FindProperty("targetRectTransform");
            _bindingOptionsProperty = serializedObject.FindProperty("bindingOptions");
            _positionOffsetProperty = serializedObject.FindProperty("positionOffset");
            _sizeOffsetProperty = serializedObject.FindProperty("sizeOffset");
        }

        public override void OnInspectorGUI()
        {
            serializedObject.Update();

            EditorGUILayout.PropertyField(_targetRectTransformProperty, new GUIContent("Target RectTransform"));
            EditorGUILayout.PropertyField(_bindingOptionsProperty, new GUIContent("Binding Options"));

            // Show position offset only if Position is selected
            if ((_bindingOptionsProperty.intValue & (int)RectTransformBinder.BindingOptions.Position) != 0)
            {
                EditorGUILayout.PropertyField(_positionOffsetProperty, new GUIContent("Position Offset"));
            }

            // Show size offset only if Size is selected
            if ((_bindingOptionsProperty.intValue & (int)RectTransformBinder.BindingOptions.Size) != 0)
            {
                EditorGUILayout.PropertyField(_sizeOffsetProperty, new GUIContent("Size Offset"));
            }

            if (serializedObject.hasModifiedProperties)
            {
                serializedObject.ApplyModifiedProperties();

                // Update tracker if properties change
                RectTransformBinder binder = (RectTransformBinder)target;
                if (binder && binder.isActiveAndEnabled)
                {
                    binder.SendMessage("UpdateTracker");
                }
            }

            // "Update Now" button in Editor
            EditorGUILayout.Space();
            if (GUILayout.Button("Update Now"))
            {
                RectTransformBinder binder = (RectTransformBinder)target;
                // Safer method for manual call
                if (binder && binder.isActiveAndEnabled)
                {
                    binder.UpdateRectTransform();
                }
            }
        }
    }
#endif
}

[oktayturkdagli]

I realize that I am constantly creating annoying issues, thank you very much for your quick feedback and efforts, I will contribute to this project when I have time :)

[mob-sakai]

Thank you! :)