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[4];
    static float[] ComVector = new float[4];

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

        RootVector[0] = worldToProjectionMatrix[3, 0];
        RootVector[1] = worldToProjectionMatrix[3, 1];
        RootVector[2] = worldToProjectionMatrix[3, 2];
        RootVector[3] = worldToProjectionMatrix[3, 3];

        ComVector[0] = worldToProjectionMatrix[0, 0];
        ComVector[1] = worldToProjectionMatrix[0, 1];
        ComVector[2] = worldToProjectionMatrix[0, 2];
        ComVector[3] = worldToProjectionMatrix[0, 3];

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

        ComVector[0] = worldToProjectionMatrix[1, 0];
        ComVector[1] = worldToProjectionMatrix[1, 1];
        ComVector[2] = worldToProjectionMatrix[1, 2];
        ComVector[3] = worldToProjectionMatrix[1, 3];

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

        ComVector[0] = worldToProjectionMatrix[2, 0];
        ComVector[1] = worldToProjectionMatrix[2, 1];
        ComVector[2] = worldToProjectionMatrix[2, 2];
        ComVector[3] = worldToProjectionMatrix[2, 3];

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

    }

    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 = 0; 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[6];