What's the best/easiest way to do something like Bounds.Intersects but accounting for rotation?

This is easy to use if you use mesh.bounds (on a cube), because that's in local space.

Please let me know if you profile, and obtain a performance comparison with and without the "ContainsAny" line.

 namespace UnityEngine
 {
     using System;
     using System.Collections.Generic;
     using System.Linq;
     
     public static class BoundsExtensions
     {
         /// <param name="transform1">Transform of the Game Object associated with bounds1</param>
         /// <param name="transform2">Transform of the Game Object associated with bounds12</param>
         public static bool Intersects(this Bounds bounds1, Bounds bounds2, Transform transform1, Transform transform2)
         {
             Vector3[] bounds1Points = transform2.InverseTransformPoints(bounds1.EnumeratePoints(), transform1).ToArray();
             Vector3[] bounds2Points = transform1.InverseTransformPoints(bounds2.EnumeratePoints(), transform2).ToArray();
 
             // This is redundant, because this will return true in a subset of cases 
             // with edge intersections, but Unity's methods are not in C# and might be faster.
             // Requires profiling.
             if ( bounds1.ContainsAny(bounds2Points) || bounds2.ContainsAny(bounds1Points) )
                return true;
 
             Func<Vector3, Vector3, Bounds, bool> edgeIntersectsBounds = (point1, point2, bounds) =>
             {
                 Ray ray = new Ray(point1, point2 - point1);
                 if ( !bounds.IntersectRay(ray) )
                     return false;
                 
                 ray.origin = point2;
                 ray.direction = -ray.direction;
                 return bounds.IntersectRay(ray);
             };
 
             Func<Vector3[], Bounds, bool> pointsContainIntersectingEdge = (points, bounds) =>
             {
                 for (int i = 0; i < points.Length - 1; i++)
                     if (  points.Skip(i + 1).Any( p => edgeIntersectsBounds(points[i], p, bounds) )  )
                         return true;
 
                 return false;
             };
 
             return pointsContainIntersectingEdge(bounds2Points, bounds1) || pointsContainIntersectingEdge(bounds1Points, bounds2);
         }
         
         public static bool ContainsAny(this Bounds bounds, IEnumerable<Vector3> points)
         {
             return points.Any( p => bounds.Contains(p) );
         }
         
         public static IEnumerable<Vector3> EnumeratePoints(this Bounds bounds)
         {
             yield return bounds.min;
             yield return bounds.max;
             for (int axis = 0; axis < 3; axis++)
             {
                 Vector3 point = bounds.min;
                 point[axis] += bounds.size[axis];
                 yield return point;
                 
                 point = bounds.max;
                 point[axis] -= bounds.size[axis];
                 yield return point;
             }
         }
     }
 }

 namespace UnityEngine
 {    
     using System.Collections.Generic;
     using System.Linq;
     
     public static class TransformExtensions
     {
         /// <summary>
         /// from local to world space
         /// </summary>
         public static IEnumerable<Vector3> TransformPoints(this Transform transform, IEnumerable<Vector3> points)
         {
             return points.Select( p => transform.TransformPoint(p) );
         }
     
         /// <summary>
         /// from world to local space
         /// </summary>
         public static IEnumerable<Vector3> InverseTransformPoints(this Transform transform, IEnumerable<Vector3> points)
         {
             return points.Select( p => transform.InverseTransformPoint(p) );
         }
         
         /// <summary>
         /// Puts points from another Transform's local space into this one's.
         /// </summary>
         public static IEnumerable<Vector3> InverseTransformPoints(this Transform transform, IEnumerable<Vector3> points, Transform otherTransform)
         {
             return transform.InverseTransformPoints( otherTransform.TransformPoints(points) );
         }
     }
 }