Unity中无GC Alloc的CalculateFrustumPlanes

如果你需要在逻辑层做一些预先的剔除操作，可能需要从MainCamera构建视锥体，然后进行简易相交测试，这时候在unity里面用到的函数接口是CalculateFrustumPlanes：

 namespace UnityEngine
 {
     // 摘要:
     //     Utility class for common geometric functions.
     public sealed class GeometryUtility
     {
         public GeometryUtility();

         // 摘要:
         //     Calculates frustum planes.
         public static Plane[] CalculateFrustumPlanes(Camera camera);
         //
         // 摘要:
         //     Calculates frustum planes.
         public static Plane[] CalculateFrustumPlanes(Matrix4x4 worldToProjectionMatrix);
         //
         // 摘要:
         //     Returns true if bounds are inside the plane array.
         public static bool TestPlanesAABB(Plane[] planes, Bounds bounds);
     }
 }

然而它的主要问题是有gc alloc，每次调用都会自己new一个Plane数组，这很明显是不科学的，然而unity迟迟未修复此问题。

下面提供的函数在C#层中重新实现了这个接口，同时没有gcalloc，然而由于在C#中实现的原因，其效率比引擎提供的C++版本慢一倍。C#版本实测一次调用在0.01毫秒左右。所以使用哪一个版本，根据实际需求来是最好的。

　　C#版本的实现：

 public static class GeometryUtilityUser
 {
     /**
      * @warning OutPlanes must be new Plane[6]
      *    Plane Position :
      *       Left
      *       Right
      *       Bottom
      *       Top
      *       Near
      *       Far
     */
     enum EPlaneSide
     {
         Left,
         Right,
         Bottom,
         Top,
         Near,
         Far
     }

     static float[] RootVector = new float[];
     static float[] ComVector = new float[];

     public static void CalculateFrustumPlanes(Camera InCamera, ref Plane[] OutPlanes)
     {
         Matrix4x4 projectionMatrix = InCamera.projectionMatrix;
         Matrix4x4 worldToCameraMatrix = InCamera.worldToCameraMatrix;
         Matrix4x4 worldToProjectionMatrix = projectionMatrix * worldToCameraMatrix;

         RootVector[] = worldToProjectionMatrix[, ];
         RootVector[] = worldToProjectionMatrix[, ];
         RootVector[] = worldToProjectionMatrix[, ];
         RootVector[] = worldToProjectionMatrix[, ];

         ComVector[] = worldToProjectionMatrix[, ];
         ComVector[] = worldToProjectionMatrix[, ];
         ComVector[] = worldToProjectionMatrix[, ];
         ComVector[] = worldToProjectionMatrix[, ];

         CalcPlane(ref OutPlanes[(int)EPlaneSide.Left], ComVector[] + RootVector[], ComVector[] + RootVector[], ComVector[] + RootVector[], ComVector[] + RootVector[]);
         CalcPlane(ref OutPlanes[(int)EPlaneSide.Right], -ComVector[] + RootVector[], -ComVector[] + RootVector[], -ComVector[] + RootVector[], -ComVector[] + RootVector[]);

         ComVector[] = worldToProjectionMatrix[, ];
         ComVector[] = worldToProjectionMatrix[, ];
         ComVector[] = worldToProjectionMatrix[, ];
         ComVector[] = worldToProjectionMatrix[, ];

         CalcPlane(ref OutPlanes[(int)EPlaneSide.Bottom], ComVector[] + RootVector[], ComVector[] + RootVector[], ComVector[] + RootVector[], ComVector[] + RootVector[]);
         CalcPlane(ref OutPlanes[(int)EPlaneSide.Top], -ComVector[] + RootVector[], -ComVector[] + RootVector[], -ComVector[] + RootVector[], -ComVector[] + RootVector[]);

         ComVector[] = worldToProjectionMatrix[, ];
         ComVector[] = worldToProjectionMatrix[, ];
         ComVector[] = worldToProjectionMatrix[, ];
         ComVector[] = worldToProjectionMatrix[, ];

         CalcPlane(ref OutPlanes[(int)EPlaneSide.Near], ComVector[] + RootVector[], ComVector[] + RootVector[], ComVector[] + RootVector[], ComVector[] + RootVector[]);
         CalcPlane(ref OutPlanes[(int)EPlaneSide.Far], -ComVector[] + RootVector[], -ComVector[] + RootVector[], -ComVector[] + RootVector[], -ComVector[] + RootVector[]);

     }

     static void CalcPlane(ref Plane InPlane, float InA, float InB, float InC, float InDistance)
     {
         Vector3 Normal = new Vector3(InA, InB, InC);

         float InverseMagnitude = 1.0f / (float)System.Math.Sqrt(Normal.x * Normal.x + Normal.y * Normal.y + Normal.z * Normal.z);

         InPlane.normal = new Vector3(Normal.x * InverseMagnitude, Normal.y * InverseMagnitude, Normal.z * InverseMagnitude);

         InPlane.distance = InDistance * InverseMagnitude;
     }
 }

下面的代码可用于验证其正确性：

 private Plane[] CalcFrustum(Camera InCamera)
     {
         GeometryUtilityUser.CalculateFrustumPlanes(InCamera, ref CachedPlanes);
 #if UNITY_EDITOR && false
         Plane[] SysPlanes = GeometryUtility.CalculateFrustumPlanes(InCamera);
         for (int i = ; i < SysPlanes.Length; ++i )
         {
             if( !IsEqual(SysPlanes[i], CachedPlanes[i]) )
             {
                 DebugHelper.Assert(false, "Internal error in CalcFrustum");
             }
         }
 #endif
             return CachedPlanes;
     }
     private static bool IsEqual(Plane InFirst, Plane InSecond)
     {
         return IsEqual(InFirst.normal, InSecond.normal) &&
             IsEqual(InFirst.distance, InSecond.distance);
     }
     private static bool IsEqual(Vector3 InFirst, Vector3 InSecond)
     {
         return IsEqual(InFirst.x, InSecond.x) &&
             IsEqual(InFirst.y, InSecond.y) &&
             IsEqual(InFirst.y, InSecond.y);
     }
     private static bool IsEqual(float InFirst, float InSecond)
     {
         return System.Math.Abs(InFirst - InSecond) < 0.001f;
     }
     private Plane[] CachedPlanes = new Plane[];