UniformScaleTransform.cs

/*
 * Copyright (C) 2020-2023 Tilt Five, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
using UnityEngine;
 
namespace TiltFive
{
    [RequireComponent(typeof(Transform))]
    [ExecuteInEditMode]
    public class UniformScaleTransform : MonoBehaviour
    {
        #region Public Fields

        public float localScale
        {
            get => transform.localScale.x;
            set
            {
                base.transform.localScale = Vector3.one * value;
                _previousScale = base.transform.localScale;
            }
        }

        public Vector3 position
        {
            get => transform.position;
            set => transform.position = value;
        }

        public Quaternion rotation
        {
            get => transform.rotation;
            set => base.transform.rotation = value;
        }
 
        #endregion Public Fields
 
 
        #region Private Fields
 
        private Vector3 _previousScale;
 
        #endregion Private Fields
 
 
        #region Private Functions

        protected void UnifyScale()
        {
            // Compare the current scale against the previous scale.                        
            if (transform.localScale == _previousScale)
            {
                return;
            }
 
            // Get the component that changed the most, and set the scale to that value.
            var deltaScale = transform.localScale - _previousScale;
            var largestPositiveChange = Mathf.Max(deltaScale.x, deltaScale.y, deltaScale.z);
            var largestNegativeChange = Mathf.Min(deltaScale.x, deltaScale.y, deltaScale.z);
            var largestAbsoluteChange = Mathf.Abs(largestPositiveChange) > Mathf.Abs(largestNegativeChange)
                                            ? largestPositiveChange
                                            : largestNegativeChange;
 
            transform.localScale = _previousScale + Vector3.one * largestAbsoluteChange;
            _previousScale = transform.localScale;
        }
 
        #endregion Private Functions
 
 
        #region Unity Functions
 
        public void Awake()
        {
            // Initial pass, in case the transform's scale is already non-uniform before UniformScaleTransform is initialized.
            _previousScale = Vector3.one;
            UnifyScale();
 
            _previousScale = transform.localScale;
        }
 
        // Update is called once per frame
        void Update()
        {
            UnifyScale();
        }
 
        #endregion Unity Functions
    }
}