feat: GameObjectExtensions, MaterialExtensions, RectTransformExtensions, RendererExtensions

Author: stan-osipov

Runtime/Extensions/UnityEngine/GameObjectExtensions.cs

@@ -0,0 +1,60 @@
+using UnityEngine;
+
+namespace StansAssets.Foundation.Extensions
+{
+    /// <summary>
+    /// Unity `GameObject` extension methods.
+    /// </summary>
+    public static class GameObjectExtensions
+    {
+        /// <summary>
+        /// Set layer to all GameObject children, including inactive.
+        /// </summary>
+        /// <param name="gameObject">Target GameObject.</param>
+        /// <param name="layerNumber">Layer number.</param>
+        public static void SetLayerRecursively(this GameObject gameObject, int layerNumber)
+        {
+            foreach (var trans in gameObject.GetComponentsInChildren<Transform>(true)) 
+                trans.gameObject.layer = layerNumber;
+        }
+        
+        /// <summary>
+        /// Renderer Bounds of the game object.
+        /// </summary>
+        /// <param name="go">GameObject you want calculate bounds for.</param>
+        /// <returns>Calculated game object bounds.</returns>
+        public static Bounds GetRendererBounds(this GameObject go)
+        {
+            return CalculateBounds(go);
+        }
+        
+        static Bounds CalculateBounds(GameObject obj)
+        {
+            var hasBounds = false;
+            var bounds = new Bounds(Vector3.zero, Vector3.zero);
+            var childrenRenderer = obj.GetComponentsInChildren<Renderer>();
+
+
+            var rnd = obj.GetComponent<Renderer>();
+            if (rnd != null)
+            {
+                bounds = rnd.bounds;
+                hasBounds = true;
+            }
+
+            foreach (var child in childrenRenderer)
+                if (!hasBounds)
+                {
+                    bounds = child.bounds;
+                    hasBounds = true;
+                }
+                else
+                {
+                    bounds.Encapsulate(child.bounds);
+                }
+
+            return bounds;
+        }
+    }
+    
+}

Runtime/Extensions/UnityEngine/GameObjectExtensions.cs.meta

@@ -0,0 +1,25 @@
+using UnityEngine;
+
+namespace StansAssets.Foundation.Extensions
+{
+    /// <summary>
+    /// Unity `Material` extension methods.
+    /// </summary>
+    public static class MaterialExtensions
+    {
+        /// <summary>
+        /// Set's alpha channel for the Material `_Color` property
+        /// </summary>
+        /// <param name="material">Material to operate with.</param>
+        /// <param name="value">Alpha channel value.</param>
+        public static void SetAlpha(this Material material, float value)
+        {
+            if (material.HasProperty("_Color"))
+            {
+                var color = material.color;
+                color.a = value;
+                material.color = color;
+            }
+        }
+    }
+}

Runtime/Extensions/UnityEngine/MaterialExtensions.cs

@@ -0,0 +1,46 @@
+using UnityEngine;
+
+namespace StansAssets.Foundation.Extensions
+{
+    /// <summary>
+    /// Unity `RectTransform` extension methods.
+    /// </summary>
+    public static class RectTransformExtensions
+    {
+        /// <summary>
+        /// Resets `anchorMin`, `anchorMax`, `offsetMin`, `offsetMax` to `Vector2.zero`.
+        /// </summary>
+        /// <param name="rectTransform">RectTransform to operate with.</param>
+        public static void Reset(this RectTransform rectTransform)
+        {
+            rectTransform.anchorMin = Vector2.zero;
+            rectTransform.anchorMax = Vector2.one;
+            rectTransform.offsetMin = Vector2.zero;
+            rectTransform.offsetMax = Vector2.zero;
+        }
+        
+        /// <summary>
+        /// Get's the screen rect of provided RectTransform.
+        /// </summary>
+        /// <param name="rectTransform">RectTransform to operate with.</param>
+        /// <returns>Screen rect.</returns>
+        public static Rect GetScreenRect(this RectTransform rectTransform)
+        {
+            var rtCorners = new Vector3[4];
+            rectTransform.GetWorldCorners(rtCorners);
+            var rtRect = new Rect(new Vector2(rtCorners[0].x, rtCorners[0].y), new Vector2(rtCorners[3].x - rtCorners[0].x, rtCorners[1].y - rtCorners[0].y));
+
+            var canvas = rectTransform.GetComponentInParent<Canvas>();
+            var canvasCorners = new Vector3[4];
+            canvas.GetComponent<RectTransform>().GetWorldCorners(canvasCorners);
+            var cRect = new Rect(new Vector2(canvasCorners[0].x, canvasCorners[0].y), new Vector2(canvasCorners[3].x - canvasCorners[0].x, canvasCorners[1].y - canvasCorners[0].y));
+
+            var screenWidth = Screen.width;
+            var screenHeight = Screen.height;
+
+            var size = new Vector2(screenWidth / cRect.size.x * rtRect.size.x, screenHeight / cRect.size.y * rtRect.size.y);
+            var rect = new Rect(screenWidth * ((rtRect.x - cRect.x) / cRect.size.x), screenHeight * ((-cRect.y + rtRect.y) / cRect.size.y), size.x, size.y);
+            return rect;
+        }
+    }
+}

Runtime/Extensions/UnityEngine/RectTransformExtensions.cs

@@ -0,0 +1,32 @@
+using UnityEngine;
+
+namespace StansAssets.Foundation.Extensions
+{
+    /// <summary>
+    /// Unity `Renderer` extension methods.
+    /// </summary>
+    public static class RendererExtensions
+    {
+        /// <summary>
+        /// Methods to check if renderer is visible from a certain point.
+        /// </summary>
+        /// <param name="renderer">Renderer to operate with.</param>
+        /// <param name="camera">Camera instance tha will be used for calculation.</param>
+        /// <returns></returns>
+        public static bool IsVisibleFrom(this Renderer renderer, Camera camera)
+        {
+            var planes = GeometryUtility.CalculateFrustumPlanes(camera);
+            return GeometryUtility.TestPlanesAABB(planes, renderer.bounds);
+        }
+        
+        /// <summary>
+        /// Renderer Bounds of the renderer. Method also take children in consideration.
+        /// </summary>
+        /// <param name="renderer">Renderer to operate with.</param>
+        /// <returns>Calculated renderer bounds.</returns>
+        public static Bounds GetRendererBounds(this Renderer renderer)
+        {
+            return renderer.gameObject.GetRendererBounds();
+        }
+    }
+}