Change serialized property naming convention

adamgraham · adamgraham · commit ccbb2bf5534d · 2021-10-28T18:58:02.000-05:00
diff --git a/Editor/AnimatorParameterPropertyDrawer.cs b/Editor/AnimatorParameterPropertyDrawer.cs
@@ -6,28 +6,20 @@ namespace Zigurous.Animation.Editor
     [CustomPropertyDrawer(typeof(AnimatorParameter))]
     public sealed class AnimatorParameterPropertyDrawer : PropertyDrawer
     {
-        private SerializedProperty _name;
-        private SerializedProperty _hash;
-
         public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
         {
-            if (_name == null) {
-                _name = property.FindPropertyRelative("_name");
-            }
-
-            if (_hash == null) {
-                _hash = property.FindPropertyRelative("_hash");
-            }
+            SerializedProperty name = property.FindPropertyRelative("m_Name");
+            SerializedProperty hash = property.FindPropertyRelative("m_Hash");
 
             EditorGUI.BeginProperty(position, label, property);
             position = EditorGUI.PrefixLabel(position, GUIUtility.GetControlID(FocusType.Passive), label);
 
-            string name = EditorGUI.TextField(position, _name.stringValue);
+            string nameValue = EditorGUI.TextField(position, name.stringValue);
 
-            if (name != _name.stringValue)
+            if (nameValue != name.stringValue)
             {
-                _name.stringValue = name;
-                _hash.intValue = Animator.StringToHash(name);
+                name.stringValue = nameValue;
+                hash.intValue = Animator.StringToHash(nameValue);
             }
 
             EditorGUI.EndProperty();
diff --git a/Editor/Timing01PropertyDrawer.cs b/Editor/Timing01PropertyDrawer.cs
@@ -8,9 +8,6 @@ public sealed class Timing01PropertyDrawer : PropertyDrawer
     {
         private const float horizontalSpacing = 4f;
 
-        private SerializedProperty _start;
-        private SerializedProperty _end;
-
         public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
         {
             // Start drawing the property
@@ -27,16 +24,16 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
             EditorGUI.indentLevel = 0;
 
             // Create references to child fields
-            if (_start == null) _start = property.FindPropertyRelative("_start");
-            if (_end == null) _end = property.FindPropertyRelative("_end");
+            SerializedProperty start = property.FindPropertyRelative("m_Start");
+            SerializedProperty end = property.FindPropertyRelative("m_End");
 
             // Calculate the bounds of the child fields
             Rect rect = new Rect(position);
             rect.width = (position.width - horizontalSpacing) / 2f;
 
             // Draw the child fields
-            rect = SliderWithChangeCheck(_start, rect, "Start");
-            rect = SliderWithChangeCheck(_end, rect, "End");
+            rect = SliderWithChangeCheck(start, rect, "Start");
+            rect = SliderWithChangeCheck(end, rect, "End");
 
             // Set sizes back to their original values
             EditorGUI.indentLevel = originalIndent;
diff --git a/Editor/TimingPropertyDrawer.cs b/Editor/TimingPropertyDrawer.cs
@@ -8,9 +8,6 @@ public sealed class TimingPropertyDrawer : PropertyDrawer
     {
         private const float horizontalSpacing = 4f;
 
-        private SerializedProperty _start;
-        private SerializedProperty _end;
-
         public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
         {
             // Start drawing the property
@@ -27,16 +24,16 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
             EditorGUI.indentLevel = 0;
 
             // Create references to child fields
-            if (_start == null) _start = property.FindPropertyRelative("start");
-            if (_end == null) _end = property.FindPropertyRelative("end");
+            SerializedProperty start = property.FindPropertyRelative("m_Start");
+            SerializedProperty end = property.FindPropertyRelative("m_End");
 
             // Calculate the bounds of the child fields
             Rect rect = new Rect(position);
             rect.width = (position.width - horizontalSpacing) / 2f;
 
             // Draw the child fields
-            rect = FloatFieldWithChangeCheck(_start, rect);
-            rect = FloatFieldWithChangeCheck(_end, rect);
+            rect = FloatFieldWithChangeCheck(start, rect);
+            rect = FloatFieldWithChangeCheck(end, rect);
 
             // Set sizes back to their original values
             EditorGUI.indentLevel = originalIndent;
diff --git a/Editor/TimingRange01PropertyDrawer.cs b/Editor/TimingRange01PropertyDrawer.cs
@@ -8,9 +8,6 @@ public sealed class TimingRange01PropertyDrawer : PropertyDrawer
     {
         private const float horizontalSpacing = 4f;
 
-        private SerializedProperty _min;
-        private SerializedProperty _max;
-
         public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
         {
             // Start drawing the property
@@ -27,16 +24,16 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
             EditorGUI.indentLevel = 0;
 
             // Create references to child fields
-            if (_min == null) _min = property.FindPropertyRelative("_min");
-            if (_max == null) _max = property.FindPropertyRelative("_max");
+            SerializedProperty min = property.FindPropertyRelative("m_Min");
+            SerializedProperty max = property.FindPropertyRelative("m_Max");
 
             // Calculate the bounds of the child fields
             Rect rect = new Rect(position);
             rect.width = (position.width - horizontalSpacing) / 2f;
 
             // Draw the child fields
-            rect = SliderWithChangeCheck(_min, rect, "Min");
-            rect = SliderWithChangeCheck(_max, rect, "Max");
+            rect = SliderWithChangeCheck(min, rect, "Min");
+            rect = SliderWithChangeCheck(max, rect, "Max");
 
             // Set sizes back to their original values
             EditorGUI.indentLevel = originalIndent;
diff --git a/Editor/TimingRangePropertyDrawer.cs b/Editor/TimingRangePropertyDrawer.cs
@@ -8,9 +8,6 @@ public sealed class TimingRangePropertyDrawer : PropertyDrawer
     {
         private const float horizontalSpacing = 4f;
 
-        private SerializedProperty _min;
-        private SerializedProperty _max;
-
         public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
         {
             // Start drawing the property
@@ -27,16 +24,16 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
             EditorGUI.indentLevel = 0;
 
             // Create references to child fields
-            if (_min == null) _min = property.FindPropertyRelative("min");
-            if (_max == null) _max = property.FindPropertyRelative("max");
+            SerializedProperty min = property.FindPropertyRelative("m_Min");
+            SerializedProperty max = property.FindPropertyRelative("m_Max");
 
             // Calculate the bounds of the child fields
             Rect rect = new Rect(position);
             rect.width = (position.width - horizontalSpacing) / 2f;
 
             // Draw the child fields
-            rect = FloatFieldWithChangeCheck(_min, rect);
-            rect = FloatFieldWithChangeCheck(_max, rect);
+            rect = FloatFieldWithChangeCheck(min, rect);
+            rect = FloatFieldWithChangeCheck(max, rect);
 
             // Set sizes back to their original values
             EditorGUI.indentLevel = originalIndent;
diff --git a/Runtime/DataStructures/AnimatorParameter.cs b/Runtime/DataStructures/AnimatorParameter.cs
@@ -14,7 +14,7 @@ public struct AnimatorParameter
     {
         [SerializeField]
         [HideInInspector]
-        private int _hash;
+        private int m_Hash;
 
         /// <summary>
         /// The hash id of the animator parameter (Read only).
@@ -23,27 +23,27 @@ public int hash
         {
             get
             {
-                if (_hash == 0) {
-                    _hash = Animator.StringToHash(_name);
+                if (m_Hash == 0) {
+                    m_Hash = Animator.StringToHash(m_Name);
                 }
-                return _hash;
+                return m_Hash;
             }
         }
 
         [SerializeField]
         [Tooltip("The name of the animator parameter.")]
-        private string _name;
+        private string m_Name;
 
         /// <summary>
         /// The name of the animator parameter.
         /// </summary>
         public string name
         {
-            get => _name;
+            get => m_Name;
             set
             {
-                _name = value;
-                _hash = Animator.StringToHash(value);
+                m_Name = value;
+                m_Hash = Animator.StringToHash(value);
             }
         }
 
@@ -53,8 +53,8 @@ public string name
         /// <param name="name">The name of the animator parameter.</param>
         public AnimatorParameter(string name)
         {
-            _name = name;
-            _hash = Animator.StringToHash(name);
+            m_Name = name;
+            m_Hash = Animator.StringToHash(name);
         }
 
         /// <summary>
diff --git a/Runtime/DataStructures/SmoothDamp.cs b/Runtime/DataStructures/SmoothDamp.cs
@@ -10,16 +10,16 @@ namespace Zigurous.Animation
     [System.Serializable]
     public abstract class SmoothDamp<T>
     {
-        protected T _value;
-        protected T _velocity;
+        protected T m_Value;
+        protected T m_Velocity;
 
         /// <summary>
         /// The current value (Read only).
         /// </summary>
         public T value
         {
-            get { return _value; }
-            protected set { _value = value; }
+            get { return m_Value; }
+            protected set { m_Value = value; }
         }
 
         /// <summary>
@@ -28,8 +28,8 @@ public T value
         /// </summary>
         public T velocity
         {
-            get { return _velocity; }
-            protected set { _velocity = value; }
+            get { return m_Velocity; }
+            protected set { m_Velocity = value; }
         }
 
         /// <summary>
diff --git a/Runtime/DataStructures/SmoothDampFloat.cs b/Runtime/DataStructures/SmoothDampFloat.cs
@@ -16,7 +16,7 @@ public class SmoothDampFloat : SmoothDamp<float>
         /// <returns>The new current value.</returns>
         public override float Update(float target)
         {
-            value = Mathf.SmoothDamp(value, target, ref _velocity, smoothTime, maxSpeed);
+            value = Mathf.SmoothDamp(value, target, ref m_Velocity, smoothTime, maxSpeed);
             return value;
         }
 
@@ -29,7 +29,7 @@ public override float Update(float target)
         /// <returns>The new current value.</returns>
         public override float Update(float target, float deltaTime)
         {
-            value = Mathf.SmoothDamp(value, target, ref _velocity, smoothTime, maxSpeed, deltaTime);
+            value = Mathf.SmoothDamp(value, target, ref m_Velocity, smoothTime, maxSpeed, deltaTime);
             return value;
         }
 
diff --git a/Runtime/DataStructures/SmoothDampVector2.cs b/Runtime/DataStructures/SmoothDampVector2.cs
@@ -16,7 +16,7 @@ public class SmoothDampVector2 : SmoothDamp<Vector2>
         /// <returns>The new current value.</returns>
         public override Vector2 Update(Vector2 target)
         {
-            value = Vector2.SmoothDamp(value, target, ref _velocity, smoothTime, maxSpeed);
+            value = Vector2.SmoothDamp(value, target, ref m_Velocity, smoothTime, maxSpeed);
             return value;
         }
 
@@ -29,7 +29,7 @@ public override Vector2 Update(Vector2 target)
         /// <returns>The new current value.</returns>
         public override Vector2 Update(Vector2 target, float deltaTime)
         {
-            value = Vector2.SmoothDamp(value, target, ref _velocity, smoothTime, maxSpeed, deltaTime);
+            value = Vector2.SmoothDamp(value, target, ref m_Velocity, smoothTime, maxSpeed, deltaTime);
             return value;
         }
 
diff --git a/Runtime/DataStructures/SmoothDampVector3.cs b/Runtime/DataStructures/SmoothDampVector3.cs
@@ -16,7 +16,7 @@ public class SmoothDampVector3 : SmoothDamp<Vector3>
         /// <returns>The new current value.</returns>
         public override Vector3 Update(Vector3 target)
         {
-            value = Vector3.SmoothDamp(value, target, ref _velocity, smoothTime, maxSpeed);
+            value = Vector3.SmoothDamp(value, target, ref m_Velocity, smoothTime, maxSpeed);
             return value;
         }
 
@@ -29,7 +29,7 @@ public override Vector3 Update(Vector3 target)
         /// <returns>The new current value.</returns>
         public override Vector3 Update(Vector3 target, float deltaTime)
         {
-            value = Vector3.SmoothDamp(value, target, ref _velocity, smoothTime, maxSpeed, deltaTime);
+            value = Vector3.SmoothDamp(value, target, ref m_Velocity, smoothTime, maxSpeed, deltaTime);
             return value;
         }
 
diff --git a/Runtime/DataStructures/Timing.cs b/Runtime/DataStructures/Timing.cs
@@ -8,17 +8,31 @@ namespace Zigurous.Animation
     [System.Serializable]
     public struct Timing
     {
+        [SerializeField]
+        [Tooltip("The start time of the animation.")]
+        private float m_Start;
+
         /// <summary>
         /// The start time of the animation.
         /// </summary>
-        [Tooltip("The start time of the animation.")]
-        public float start;
+        public float start
+        {
+            get => m_Start;
+            set => m_Start = value;
+        }
+
+        [SerializeField]
+        [Tooltip("The end time of the animation.")]
+        private float m_End;
 
         /// <summary>
         /// The end time of the animation.
         /// </summary>
-        [Tooltip("The end time of the animation.")]
-        public float end;
+        public float end
+        {
+            get => m_End;
+            set => m_End = value;
+        }
 
         /// <summary>
         /// Creates a new timing with the specified values.
@@ -27,8 +41,8 @@ public struct Timing
         /// <param name="end">The end time of the animation.</param>
         public Timing(float start, float end)
         {
-            this.start = start;
-            this.end = end;
+            m_Start = start;
+            m_End = end;
         }
 
         /// <summary>
diff --git a/Runtime/DataStructures/Timing01.cs b/Runtime/DataStructures/Timing01.cs
@@ -11,29 +11,29 @@ public struct Timing01
         [SerializeField]
         [Tooltip("The start time of the animation, between 0 and 1.")]
         [Range(0f, 1f)]
-        private float _start;
+        private float m_Start;
 
         /// <summary>
         /// The start time of the animation, between 0 and 1.
         /// </summary>
         public float start
         {
-            get => _start;
-            set => _start = Mathf.Clamp01(value);
+            get => m_Start;
+            set => m_Start = Mathf.Clamp01(value);
         }
 
         [SerializeField]
         [Tooltip("The end time of the animation, between 0 and 1.")]
         [Range(0f, 1f)]
-        private float _end;
+        private float m_End;
 
         /// <summary>
         /// The end time of the animation, between 0 and 1.
         /// </summary>
         public float end
         {
-            get => _end;
-            set => _end = Mathf.Clamp01(value);
+            get => m_End;
+            set => m_End = Mathf.Clamp01(value);
         }
 
         /// <summary>
@@ -43,8 +43,8 @@ public float end
         /// <param name="end">The end time of the animation, between 0 and 1.</param>
         public Timing01(float start, float end)
         {
-            _start = Mathf.Clamp01(start);
-            _end = Mathf.Clamp01(end);
+            m_Start = Mathf.Clamp01(start);
+            m_End = Mathf.Clamp01(end);
         }
 
         /// <summary>
diff --git a/Runtime/DataStructures/TimingRange.cs b/Runtime/DataStructures/TimingRange.cs
diff --git a/Runtime/DataStructures/TimingRange01.cs b/Runtime/DataStructures/TimingRange01.cs
diff --git a/Runtime/FollowPath.cs b/Runtime/FollowPath.cs
diff --git a/Runtime/SmoothFollow.cs b/Runtime/SmoothFollow.cs
diff --git a/Runtime/SmoothLookAt.cs b/Runtime/SmoothLookAt.cs

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public struct AnimatorParameter`
`14`	`14`	`{`
`15`	`15`	`[SerializeField]`
`16`	`16`	`[HideInInspector]`
`17`		`- private int _hash;`
	`17`	`+ private int m_Hash;`
`18`	`18`
`19`	`19`	`/// <summary>`
`20`	`20`	`/// The hash id of the animator parameter (Read only).`
`@@ -23,27 +23,27 @@ public int hash`
`23`	`23`	`{`
`24`	`24`	`get`
`25`	`25`	`{`
`26`		`- if (_hash == 0) {`
`27`		`- _hash = Animator.StringToHash(_name);`
	`26`	`+ if (m_Hash == 0) {`
	`27`	`+ m_Hash = Animator.StringToHash(m_Name);`
`28`	`28`	`}`
`29`		`- return _hash;`
	`29`	`+ return m_Hash;`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`[SerializeField]`
`34`	`34`	`[Tooltip("The name of the animator parameter.")]`
`35`		`- private string _name;`
	`35`	`+ private string m_Name;`
`36`	`36`
`37`	`37`	`/// <summary>`
`38`	`38`	`/// The name of the animator parameter.`
`39`	`39`	`/// </summary>`
`40`	`40`	`public string name`
`41`	`41`	`{`
`42`		`- get => _name;`
	`42`	`+ get => m_Name;`
`43`	`43`	`set`
`44`	`44`	`{`
`45`		`- _name = value;`
`46`		`- _hash = Animator.StringToHash(value);`
	`45`	`+ m_Name = value;`
	`46`	`+ m_Hash = Animator.StringToHash(value);`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`@@ -53,8 +53,8 @@ public string name`
`53`	`53`	`/// <param name="name">The name of the animator parameter.</param>`
`54`	`54`	`public AnimatorParameter(string name)`
`55`	`55`	`{`
`56`		`- _name = name;`
`57`		`- _hash = Animator.StringToHash(name);`
	`56`	`+ m_Name = name;`
	`57`	`+ m_Hash = Animator.StringToHash(name);`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -10,16 +10,16 @@ namespace Zigurous.Animation`
`10`	`10`	`[System.Serializable]`
`11`	`11`	`public abstract class SmoothDamp<T>`
`12`	`12`	`{`
`13`		`- protected T _value;`
`14`		`- protected T _velocity;`
	`13`	`+ protected T m_Value;`
	`14`	`+ protected T m_Velocity;`
`15`	`15`
`16`	`16`	`/// <summary>`
`17`	`17`	`/// The current value (Read only).`
`18`	`18`	`/// </summary>`
`19`	`19`	`public T value`
`20`	`20`	`{`
`21`		`- get { return _value; }`
`22`		`- protected set { _value = value; }`
	`21`	`+ get { return m_Value; }`
	`22`	`+ protected set { m_Value = value; }`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`/// <summary>`
`@@ -28,8 +28,8 @@ public T value`
`28`	`28`	`/// </summary>`
`29`	`29`	`public T velocity`
`30`	`30`	`{`
`31`		`- get { return _velocity; }`
`32`		`- protected set { _velocity = value; }`
	`31`	`+ get { return m_Velocity; }`
	`32`	`+ protected set { m_Velocity = value; }`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public class SmoothDampFloat : SmoothDamp<float>`
`16`	`16`	`/// <returns>The new current value.</returns>`
`17`	`17`	`public override float Update(float target)`
`18`	`18`	`{`
`19`		`- value = Mathf.SmoothDamp(value, target, ref _velocity, smoothTime, maxSpeed);`
	`19`	`+ value = Mathf.SmoothDamp(value, target, ref m_Velocity, smoothTime, maxSpeed);`
`20`	`20`	`return value;`
`21`	`21`	`}`
`22`	`22`
`@@ -29,7 +29,7 @@ public override float Update(float target)`
`29`	`29`	`/// <returns>The new current value.</returns>`
`30`	`30`	`public override float Update(float target, float deltaTime)`
`31`	`31`	`{`
`32`		`- value = Mathf.SmoothDamp(value, target, ref _velocity, smoothTime, maxSpeed, deltaTime);`
	`32`	`+ value = Mathf.SmoothDamp(value, target, ref m_Velocity, smoothTime, maxSpeed, deltaTime);`
`33`	`33`	`return value;`
`34`	`34`	`}`
`35`	`35`