Update variable naming convention

adamgraham · adamgraham · commit 6323f8ff2e75 · 2021-10-28T20:55:40.000-05:00
diff --git a/Runtime/CinematicBars.cs b/Runtime/CinematicBars.cs
@@ -13,6 +13,22 @@ namespace Zigurous.UI
     [AddComponentMenu("Zigurous/UI/Misc/Cinematic Bars")]
     public sealed class CinematicBars : MonoBehaviour
     {
+        [SerializeField]
+        [Tooltip("The color of the mattes.")]
+        private Color m_Color = Color.black;
+
+        [SerializeField]
+        [Tooltip("The material of the mattes.")]
+        private Material m_Material = null;
+
+        [SerializeField]
+        [Tooltip("The aspect ratio of the mattes.")]
+        private float m_AspectRatio = 2.35f;
+
+        [SerializeField]
+        [Tooltip("The amount of seconds it takes to animate the mattes.")]
+        private float m_AnimationDuration = 0.5f;
+
         /// <summary>
         /// The top letterbox matte (Read only).
         /// </summary>
@@ -28,61 +44,49 @@ public sealed class CinematicBars : MonoBehaviour
         /// </summary>
         public float matteHeight { get; private set; }
 
-        [SerializeField]
-        [Tooltip("The color of the mattes.")]
-        private Color _color = Color.black;
-
         /// <summary>
         /// The color of the mattes.
         /// </summary>
         public Color color
         {
-            get { return _color; }
-            set { _color = value; UpdateStyles(); }
+            get => m_Color;
+            set { m_Color = value; UpdateStyles(); }
         }
 
-        [SerializeField]
-        [Tooltip("The material of the mattes.")]
-        private Material _material = null;
-
         /// <summary>
         /// The material of the mattes.
         /// </summary>
         public Material material
         {
-            get { return _material; }
-            set { _material = value; UpdateStyles(); }
+            get => m_Material;
+            set { m_Material = value; UpdateStyles(); }
         }
 
-        [SerializeField]
-        [Tooltip("The aspect ratio of the mattes.")]
-        private float _aspectRatio = 2.35f;
-
         /// <summary>
         /// The aspect ratio of the mattes.
         /// </summary>
         public float aspectRatio
         {
-            get { return _aspectRatio; }
-            set { _aspectRatio = value; UpdateMattes(); }
+            get => m_AspectRatio;
+            set { m_AspectRatio = value; UpdateMattes(); }
         }
 
         /// <summary>
         /// The amount of seconds it takes to animate the mattes.
         /// </summary>
-        [Tooltip("The amount of seconds it takes to animate the mattes.")]
-        public float animationDuration = 0.5f;
+        public float animationDuration
+        {
+            get => m_AnimationDuration;
+            set => m_AnimationDuration = value;
+        }
 
         /// <summary>
         /// The coroutine that animates the mattes.
         /// </summary>
-        private Coroutine _animation;
+        private Coroutine coroutine;
 
         #if UNITY_EDITOR
-        /// <summary>
-        /// Whether the current settings have been invalidated.
-        /// </summary>
-        private bool _invalidated;
+        private bool invalidated;
         #endif
 
         private void Awake()
@@ -132,10 +136,12 @@ private void OnDestroy()
             }
         }
 
+        #if UNITY_EDITOR
         private void OnValidate()
         {
-            _invalidated = true;
+            invalidated = true;
         }
+        #endif
 
         private void OnEnable()
         {
@@ -152,16 +158,18 @@ private void OnScreenResize(int width, int height)
             UpdateMattes(animated: false);
         }
 
+        #if UNITY_EDITOR
         private void Update()
         {
-            if (_invalidated)
+            if (invalidated)
             {
                 UpdateStyles();
                 UpdateMattes(animated: false);
 
-                _invalidated = false;
+                invalidated = false;
             }
         }
+        #endif
 
         private void UpdateMattes()
         {
@@ -180,11 +188,11 @@ private void UpdateMattes(bool animated)
 
             if (animated)
             {
-                if (_animation != null) {
-                    StopCoroutine(_animation);
+                if (coroutine != null) {
+                    StopCoroutine(coroutine);
                 }
 
-                _animation = StartCoroutine(Animate(matteHeight, desiredHeight));
+                coroutine = StartCoroutine(Animate(matteHeight, desiredHeight));
             }
             else
             {
diff --git a/Runtime/InverseMask.cs b/Runtime/InverseMask.cs
@@ -12,8 +12,8 @@ namespace Zigurous.UI
     [AddComponentMenu("Zigurous/UI/Effects/Inverse Mask")]
     public sealed class InverseMask : MonoBehaviour
     {
-        private static Material _cutoutMaterial;
-        private static Material _contentMaterial;
+        private static Material m_CutoutMaterial;
+        private static Material m_ContentMaterial;
 
         /// <summary>
         /// The shared material applied to an image that is masking another
@@ -23,22 +23,22 @@ public static Material cutoutMaterial
         {
             get
             {
-                if (_cutoutMaterial == null)
+                if (m_CutoutMaterial == null)
                 {
-                    _cutoutMaterial = new Material(Shader.Find("UI/Default"));
-                    _cutoutMaterial.name = "UIInverseMask-Cutout";
-                    _cutoutMaterial.color = new Color(1f, 1f, 1f, 1f / 256f);
-                    _cutoutMaterial.shaderKeywords = new string[] { "UNITY_UI_ALPHACLIP" };
-                    _cutoutMaterial.SetInt("_Stencil", 1);
-                    _cutoutMaterial.SetInt("_StencilComp", 8);
-                    _cutoutMaterial.SetInt("_StencilOp", 2);
-                    _cutoutMaterial.SetInt("_StencilWriteMask", 255);
-                    _cutoutMaterial.SetInt("_StencilReadMask", 255);
-                    _cutoutMaterial.SetInt("_ColorMask", 0);
-                    _cutoutMaterial.SetInt("_UseUIAlphaClip", 1);
+                    m_CutoutMaterial = new Material(Shader.Find("UI/Default"));
+                    m_CutoutMaterial.name = "UIInverseMask-Cutout";
+                    m_CutoutMaterial.color = new Color(1f, 1f, 1f, 1f / 256f);
+                    m_CutoutMaterial.shaderKeywords = new string[] { "UNITY_UI_ALPHACLIP" };
+                    m_CutoutMaterial.SetInt("_Stencil", 1);
+                    m_CutoutMaterial.SetInt("_StencilComp", 8);
+                    m_CutoutMaterial.SetInt("_StencilOp", 2);
+                    m_CutoutMaterial.SetInt("_StencilWriteMask", 255);
+                    m_CutoutMaterial.SetInt("_StencilReadMask", 255);
+                    m_CutoutMaterial.SetInt("_ColorMask", 0);
+                    m_CutoutMaterial.SetInt("_UseUIAlphaClip", 1);
                 }
 
-                return _cutoutMaterial;
+                return m_CutoutMaterial;
             }
         }
 
@@ -51,38 +51,38 @@ public static Material contentMaterial
         {
             get
             {
-                if (_contentMaterial == null)
+                if (m_ContentMaterial == null)
                 {
-                    _contentMaterial = new Material(Shader.Find("UI/Default"));
-                    _contentMaterial.name = "UIInverseMask-Content";
-                    _contentMaterial.color = Color.white;
-                    _contentMaterial.SetInt("_Stencil", 2);
-                    _contentMaterial.SetInt("_StencilComp", 3);
-                    _contentMaterial.SetInt("_StencilOp", 0);
-                    _contentMaterial.SetInt("_StencilWriteMask", 0);
-                    _contentMaterial.SetInt("_StencilReadMask", 1);
-                    _contentMaterial.SetInt("_ColorMask", 15);
-                    _contentMaterial.SetInt("_UseUIAlphaClip", 0);
+                    m_ContentMaterial = new Material(Shader.Find("UI/Default"));
+                    m_ContentMaterial.name = "UIInverseMask-Content";
+                    m_ContentMaterial.color = Color.white;
+                    m_ContentMaterial.SetInt("_Stencil", 2);
+                    m_ContentMaterial.SetInt("_StencilComp", 3);
+                    m_ContentMaterial.SetInt("_StencilOp", 0);
+                    m_ContentMaterial.SetInt("_StencilWriteMask", 0);
+                    m_ContentMaterial.SetInt("_StencilReadMask", 1);
+                    m_ContentMaterial.SetInt("_ColorMask", 15);
+                    m_ContentMaterial.SetInt("_UseUIAlphaClip", 0);
                 }
 
-                return _contentMaterial;
+                return m_ContentMaterial;
             }
         }
 
         #if UNITY_EDITOR
-        private bool _invalidated;
+        private bool invalidated;
 
         private void OnValidate()
         {
-            _invalidated = true;
+            invalidated = true;
         }
 
         private void Update()
         {
-            if (_invalidated)
+            if (invalidated)
             {
                 Apply();
-                _invalidated = false;
+                invalidated = false;
             }
         }
         #endif
diff --git a/Runtime/Letterboxing.cs b/Runtime/Letterboxing.cs
@@ -11,6 +11,14 @@ namespace Zigurous.UI
     [AddComponentMenu("Zigurous/UI/Misc/Letterboxing")]
     public sealed class Letterboxing : MonoBehaviour
     {
+        [SerializeField]
+        [Tooltip("The aspect ratio of the mattes.")]
+        private float m_AspectRatio = 2.35f;
+
+        [SerializeField]
+        [Tooltip("The amount of seconds it takes to animate the mattes.")]
+        private float m_AnimationDuration = 0.5f;
+
         /// <summary>
         /// The camera being letterboxed (Read only).
         /// </summary>
@@ -21,35 +29,31 @@ public sealed class Letterboxing : MonoBehaviour
         /// </summary>
         public float viewportHeight => camera.rect.height;
 
-        [SerializeField]
-        [Tooltip("The aspect ratio of the mattes.")]
-        private float _aspectRatio = 2.35f;
-
         /// <summary>
         /// The aspect ratio of the mattes.
         /// </summary>
         public float aspectRatio
         {
-            get { return _aspectRatio; }
-            set { _aspectRatio = value; UpdateViewport(); }
+            get => m_AspectRatio;
+            set { m_AspectRatio = value; UpdateViewport(); }
         }
 
         /// <summary>
         /// The amount of seconds it takes to animate the mattes.
         /// </summary>
-        [Tooltip("The amount of seconds it takes to animate the mattes.")]
-        public float animationDuration = 0.5f;
+        public float animationDuration
+        {
+            get => m_AnimationDuration;
+            set => m_AnimationDuration = value;
+        }
 
         /// <summary>
         /// The coroutine that animates the mattes.
         /// </summary>
-        private Coroutine _animation;
+        private Coroutine coroutine;
 
         #if UNITY_EDITOR
-        /// <summary>
-        /// Whether the current settings have been invalidated.
-        /// </summary>
-        private bool _invalidated;
+        private bool invalidated;
         #endif
 
         private void Awake()
@@ -69,10 +73,12 @@ private void OnDestroy()
             }
         }
 
+        #if UNITY_EDITOR
         private void OnValidate()
         {
-            _invalidated = true;
+            invalidated = true;
         }
+        #endif
 
         private void OnEnable()
         {
@@ -89,15 +95,17 @@ private void OnScreenResize(int width, int height)
             UpdateViewport(animated: false);
         }
 
+        #if UNITY_EDITOR
         private void Update()
         {
-            if (_invalidated)
+            if (invalidated)
             {
                 UpdateViewport(animated: false);
 
-                _invalidated = false;
+                invalidated = false;
             }
         }
+        #endif
 
         private void UpdateViewport()
         {
@@ -116,11 +124,11 @@ private void UpdateViewport(bool animated)
 
             if (animated)
             {
-                if (_animation != null) {
-                    StopCoroutine(_animation);
+                if (coroutine != null) {
+                    StopCoroutine(coroutine);
                 }
 
-                _animation = StartCoroutine(Animate(viewportHeight, desiredHeight));
+                coroutine = StartCoroutine(Animate(viewportHeight, desiredHeight));
             }
             else
             {
diff --git a/Runtime/ScreenSizeListener.cs b/Runtime/ScreenSizeListener.cs

Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,8 @@ namespace Zigurous.UI`
`12`	`12`	`[AddComponentMenu("Zigurous/UI/Effects/Inverse Mask")]`
`13`	`13`	`public sealed class InverseMask : MonoBehaviour`
`14`	`14`	`{`
`15`		`- private static Material _cutoutMaterial;`
`16`		`- private static Material _contentMaterial;`
	`15`	`+ private static Material m_CutoutMaterial;`
	`16`	`+ private static Material m_ContentMaterial;`
`17`	`17`
`18`	`18`	`/// <summary>`
`19`	`19`	`/// The shared material applied to an image that is masking another`
`@@ -23,22 +23,22 @@ public static Material cutoutMaterial`
`23`	`23`	`{`
`24`	`24`	`get`
`25`	`25`	`{`
`26`		`- if (_cutoutMaterial == null)`
	`26`	`+ if (m_CutoutMaterial == null)`
`27`	`27`	`{`
`28`		`- _cutoutMaterial = new Material(Shader.Find("UI/Default"));`
`29`		`- _cutoutMaterial.name = "UIInverseMask-Cutout";`
`30`		`- _cutoutMaterial.color = new Color(1f, 1f, 1f, 1f / 256f);`
`31`		`- _cutoutMaterial.shaderKeywords = new string[] { "UNITY_UI_ALPHACLIP" };`
`32`		`- _cutoutMaterial.SetInt("_Stencil", 1);`
`33`		`- _cutoutMaterial.SetInt("_StencilComp", 8);`
`34`		`- _cutoutMaterial.SetInt("_StencilOp", 2);`
`35`		`- _cutoutMaterial.SetInt("_StencilWriteMask", 255);`
`36`		`- _cutoutMaterial.SetInt("_StencilReadMask", 255);`
`37`		`- _cutoutMaterial.SetInt("_ColorMask", 0);`
`38`		`- _cutoutMaterial.SetInt("_UseUIAlphaClip", 1);`
	`28`	`+ m_CutoutMaterial = new Material(Shader.Find("UI/Default"));`
	`29`	`+ m_CutoutMaterial.name = "UIInverseMask-Cutout";`
	`30`	`+ m_CutoutMaterial.color = new Color(1f, 1f, 1f, 1f / 256f);`
	`31`	`+ m_CutoutMaterial.shaderKeywords = new string[] { "UNITY_UI_ALPHACLIP" };`
	`32`	`+ m_CutoutMaterial.SetInt("_Stencil", 1);`
	`33`	`+ m_CutoutMaterial.SetInt("_StencilComp", 8);`
	`34`	`+ m_CutoutMaterial.SetInt("_StencilOp", 2);`
	`35`	`+ m_CutoutMaterial.SetInt("_StencilWriteMask", 255);`
	`36`	`+ m_CutoutMaterial.SetInt("_StencilReadMask", 255);`
	`37`	`+ m_CutoutMaterial.SetInt("_ColorMask", 0);`
	`38`	`+ m_CutoutMaterial.SetInt("_UseUIAlphaClip", 1);`
`39`	`39`	`}`
`40`	`40`
`41`		`- return _cutoutMaterial;`
	`41`	`+ return m_CutoutMaterial;`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`
`@@ -51,38 +51,38 @@ public static Material contentMaterial`
`51`	`51`	`{`
`52`	`52`	`get`
`53`	`53`	`{`
`54`		`- if (_contentMaterial == null)`
	`54`	`+ if (m_ContentMaterial == null)`
`55`	`55`	`{`
`56`		`- _contentMaterial = new Material(Shader.Find("UI/Default"));`
`57`		`- _contentMaterial.name = "UIInverseMask-Content";`
`58`		`- _contentMaterial.color = Color.white;`
`59`		`- _contentMaterial.SetInt("_Stencil", 2);`
`60`		`- _contentMaterial.SetInt("_StencilComp", 3);`
`61`		`- _contentMaterial.SetInt("_StencilOp", 0);`
`62`		`- _contentMaterial.SetInt("_StencilWriteMask", 0);`
`63`		`- _contentMaterial.SetInt("_StencilReadMask", 1);`
`64`		`- _contentMaterial.SetInt("_ColorMask", 15);`
`65`		`- _contentMaterial.SetInt("_UseUIAlphaClip", 0);`
	`56`	`+ m_ContentMaterial = new Material(Shader.Find("UI/Default"));`
	`57`	`+ m_ContentMaterial.name = "UIInverseMask-Content";`
	`58`	`+ m_ContentMaterial.color = Color.white;`
	`59`	`+ m_ContentMaterial.SetInt("_Stencil", 2);`
	`60`	`+ m_ContentMaterial.SetInt("_StencilComp", 3);`
	`61`	`+ m_ContentMaterial.SetInt("_StencilOp", 0);`
	`62`	`+ m_ContentMaterial.SetInt("_StencilWriteMask", 0);`
	`63`	`+ m_ContentMaterial.SetInt("_StencilReadMask", 1);`
	`64`	`+ m_ContentMaterial.SetInt("_ColorMask", 15);`
	`65`	`+ m_ContentMaterial.SetInt("_UseUIAlphaClip", 0);`
`66`	`66`	`}`
`67`	`67`
`68`		`- return _contentMaterial;`
	`68`	`+ return m_ContentMaterial;`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`#if UNITY_EDITOR`
`73`		`- private bool _invalidated;`
	`73`	`+ private bool invalidated;`
`74`	`74`
`75`	`75`	`private void OnValidate()`
`76`	`76`	`{`
`77`		`- _invalidated = true;`
	`77`	`+ invalidated = true;`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`private void Update()`
`81`	`81`	`{`
`82`		`- if (_invalidated)`
	`82`	`+ if (invalidated)`
`83`	`83`	`{`
`84`	`84`	`Apply();`
`85`		`- _invalidated = false;`
	`85`	`+ invalidated = false;`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,14 @@ namespace Zigurous.UI`
`11`	`11`	`[AddComponentMenu("Zigurous/UI/Misc/Letterboxing")]`
`12`	`12`	`public sealed class Letterboxing : MonoBehaviour`
`13`	`13`	`{`
	`14`	`+ [SerializeField]`
	`15`	`+ [Tooltip("The aspect ratio of the mattes.")]`
	`16`	`+ private float m_AspectRatio = 2.35f;`
	`17`	`+`
	`18`	`+ [SerializeField]`
	`19`	`+ [Tooltip("The amount of seconds it takes to animate the mattes.")]`
	`20`	`+ private float m_AnimationDuration = 0.5f;`
	`21`	`+`
`14`	`22`	`/// <summary>`
`15`	`23`	`/// The camera being letterboxed (Read only).`
`16`	`24`	`/// </summary>`
`@@ -21,35 +29,31 @@ public sealed class Letterboxing : MonoBehaviour`
`21`	`29`	`/// </summary>`
`22`	`30`	`public float viewportHeight => camera.rect.height;`
`23`	`31`
`24`		`- [SerializeField]`
`25`		`- [Tooltip("The aspect ratio of the mattes.")]`
`26`		`- private float _aspectRatio = 2.35f;`
`27`		`-`
`28`	`32`	`/// <summary>`
`29`	`33`	`/// The aspect ratio of the mattes.`
`30`	`34`	`/// </summary>`
`31`	`35`	`public float aspectRatio`
`32`	`36`	`{`
`33`		`- get { return _aspectRatio; }`
`34`		`- set { _aspectRatio = value; UpdateViewport(); }`
	`37`	`+ get => m_AspectRatio;`
	`38`	`+ set { m_AspectRatio = value; UpdateViewport(); }`
`35`	`39`	`}`
`36`	`40`
`37`	`41`	`/// <summary>`
`38`	`42`	`/// The amount of seconds it takes to animate the mattes.`
`39`	`43`	`/// </summary>`
`40`		`- [Tooltip("The amount of seconds it takes to animate the mattes.")]`
`41`		`- public float animationDuration = 0.5f;`
	`44`	`+ public float animationDuration`
	`45`	`+ {`
	`46`	`+ get => m_AnimationDuration;`
	`47`	`+ set => m_AnimationDuration = value;`
	`48`	`+ }`
`42`	`49`
`43`	`50`	`/// <summary>`
`44`	`51`	`/// The coroutine that animates the mattes.`
`45`	`52`	`/// </summary>`
`46`		`- private Coroutine _animation;`
	`53`	`+ private Coroutine coroutine;`
`47`	`54`
`48`	`55`	`#if UNITY_EDITOR`
`49`		`- /// <summary>`
`50`		`- /// Whether the current settings have been invalidated.`
`51`		`- /// </summary>`
`52`		`- private bool _invalidated;`
	`56`	`+ private bool invalidated;`
`53`	`57`	`#endif`
`54`	`58`
`55`	`59`	`private void Awake()`
`@@ -69,10 +73,12 @@ private void OnDestroy()`
`69`	`73`	`}`
`70`	`74`	`}`
`71`	`75`
	`76`	`+ #if UNITY_EDITOR`
`72`	`77`	`private void OnValidate()`
`73`	`78`	`{`
`74`		`- _invalidated = true;`
	`79`	`+ invalidated = true;`
`75`	`80`	`}`
	`81`	`+ #endif`
`76`	`82`
`77`	`83`	`private void OnEnable()`
`78`	`84`	`{`
`@@ -89,15 +95,17 @@ private void OnScreenResize(int width, int height)`
`89`	`95`	`UpdateViewport(animated: false);`
`90`	`96`	`}`
`91`	`97`
	`98`	`+ #if UNITY_EDITOR`
`92`	`99`	`private void Update()`
`93`	`100`	`{`
`94`		`- if (_invalidated)`
	`101`	`+ if (invalidated)`
`95`	`102`	`{`
`96`	`103`	`UpdateViewport(animated: false);`
`97`	`104`
`98`		`- _invalidated = false;`
	`105`	`+ invalidated = false;`
`99`	`106`	`}`
`100`	`107`	`}`
	`108`	`+ #endif`
`101`	`109`
`102`	`110`	`private void UpdateViewport()`
`103`	`111`	`{`
`@@ -116,11 +124,11 @@ private void UpdateViewport(bool animated)`
`116`	`124`
`117`	`125`	`if (animated)`
`118`	`126`	`{`
`119`		`- if (_animation != null) {`
`120`		`- StopCoroutine(_animation);`
	`127`	`+ if (coroutine != null) {`
	`128`	`+ StopCoroutine(coroutine);`
`121`	`129`	`}`
`122`	`130`
`123`		`- _animation = StartCoroutine(Animate(viewportHeight, desiredHeight));`
	`131`	`+ coroutine = StartCoroutine(Animate(viewportHeight, desiredHeight));`
`124`	`132`	`}`
`125`	`133`	`else`
`126`	`134`	`{`