【原】3D游戲中的算法--MMO游戲全視角3D相機，全地形中視覺障礙物自動縮進調整

大家好，歡迎大家多多交流，轉載請注明出處，謝謝。

我來博客園的第一篇博客，想寫的東西很多，基於目前工作手里的內容，先上一篇算法的。

上周做了個3D自由相機功能，需要對地形和牆壁進行自動縮進動畫，效果經過多款游戲對比，決定編寫《萬王之王》的相機效果。

我發現很多同學，基礎知識都不錯，但是自己寫的話，卻不知道怎么去實現具體算法和方案，其實這種情況不用着急，養成好的需求分析習慣會幫助你提前解決很多難題。但是需求分析再好，對於算法來說，基礎知識的掌握更加重要。

所以下面幾個步驟是解決問題的流程。

第一步：首先就是自身基礎了，關於3d向量的掌握，必須達到一定層次，否則很難處理好這種復雜環境下的算法策略，如果算法不好的，接着看，或許能讓你有所提高。

第二步：其次就是對於相機功能的需求分析，需求分析是通過游戲還有和游戲策划溝通的結果，需求分析的准確與否決定了我們最終的結果，否則需求分析的錯誤或者不明確會帶來代碼策略的錯誤，影響工期。

第三步：很多同學到這里可能以為要開始動手寫代碼了，不着急，這里建議大家先整理游戲中相關流程，確定自己方案可行性，然后編寫偽代碼或者方案流程。偽代碼能提前實驗邏輯的可行性和紕漏，總覽全局，避免實際編寫代碼過程中的盲目或者片面引起的時間成本。

第四步：接下來可以開始編寫你的代碼了。

 

相機涉及數學知識：

 涉及的數學知識不多，作為游戲開發人員，這些知識點事必備技能，如果有不熟悉或者不知道的，一定要及時補充知識。

  1：主要是對3d空間的理解，空間點，空間向量，空間角度的概念。

  2：熟悉3D向量相關計算，余弦公式，角度計算，三角函數，向量投影計算和物理意義

  3：熟悉笛卡爾坐標系，熟悉點乘積和叉乘積計算和物理意思，知道右手定則，平面法線等知識。 

 

相機需求：

1：3D自由相機通用功能，滑動屏幕可以隨意調整方向和縮進顯示距離。

2：在1基礎上對相機進行遮擋碰撞處理，相機和角色中間有阻擋時相機自動越過障礙物（漸進運動方式），並且保持相機視域內不在物體內部（穿牆情況）。

3：相機離開遮擋的時候回復原來自由相機設置距離，並且動態回復到合適位置。

4：對任意形狀的阻擋（牆面，地面，任意角度斜坡）進行處理后不穿強。

5：發生視覺遮擋時，縮進的速度與滑動屏幕的速度成正比（這樣體驗會好，慢慢轉動相機，遇到視覺阻擋時，正常縮進動畫，當快速滑動屏幕時，就需要快速縮進相機，以防止視線穿牆）

 

方案：

   1：射線檢測，因為需要考慮各種地形的角度，所以射線檢測方案修改成，視椎體射線檢測方案，請看函數NearClipPlanePoints。（相機視口的4個點分別向目標點打射線進行檢測，碰撞點取距離角色最近的）

   2：相機提前預檢測，提前計算下一幀相機碰撞，再相機被遮擋實際發生前，進行預測。

   3：相機終點調整，使用最優碰撞點進行調整，調整算法考慮到相機視口寬度，使相視口機完全避免邊界與碰撞點穿插。

   4：相機終點確認后，對相機進行平滑過渡動畫的方式往目標點移動。

   5：平滑過渡速率和觸摸拖動角度變化速率成正比，防止滑動太大穿牆，也增加體驗。

實現參考圖：

如下圖，椎體為四條碰撞檢測射線：

穿牆后，相機進行調整以后的截圖：

實現效果：參考 萬王之王，一樣的效果。

代碼實現：代碼中關鍵步驟已經有注釋，核心函數是CameraMovement。

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using Invector;
using System;
public class vThirdPersonCamera : MonoBehaviour
{
    public enum CameraState
    {
        Drag,
        Auto,
        AutoFixY,
    }
    public static vThirdPersonCamera Create()
    {
        var go = new GameObject("vThirdPersonCamera");
        vThirdPersonCamera comp = go.AddComponent<vThirdPersonCamera>();
        GameObject.DontDestroyOnLoad(go);
        return comp;
    }
    #region inspector properties
    [Tooltip("Lerp speed between Camera States")]
    public float smoothCameraRotation = 12f;
    public float smoothCameraRotationAuto = 1;
    private float m_currentCameraRotation;
    [Tooltip("What layer will be culled")]
    public LayerMask cullingLayer = 1 << 0;//碰撞檢測用的layer，請根據自己游戲進行設置。
    public float rightOffset = 0f;
    public float defaultDistance = 12.5f;
    public float height = 2f; 
    private float defaultHeight = 2f;
    public float smoothFollow = 5f;
    public float cameraAutoRotationSensitivity = 3f;
    public float xMouseSensitivity = 0.2f;//3f;
    public float yMouseSensitivity = 0.2f;//3f;
    public float yMinLimit = -70;
    public float yMaxLimit = 80f;
    public const float MinDistance = 0f;
    public const float MaxDistance = 35;
    public float currentDistance = 0;
    public float zoomSensitivity = 0.05f;
    public Transform cameraTransform;
    //public Transform otherTargetTransform;//相機動畫鎖定目標Trans
    #endregion
    #region hide properties
    [HideInInspector]
    public float offSetPlayerPivot;
    //[HideInInspector]
    [HideInInspector]
    public Vector2 movementSpeed;
    private Vector3 currentPlayerPos;
    private Vector3 currentPlayerDirection;
    private Vector3 currentPlayerDirectionRight;
    private Transform targetLookAt;    //目標觀察點
    private Transform nextTargetLookAt;//目標觀察點
    private Vector3 currentTargetPos;
    private Vector3 lookPoint;
    private Vector3 nextLookPoint;
    private Vector3 current_cPos;
    private Vector3 desired_cPos;
    private Vector3 nextTargetCameraPos = Vector3.zero;
    private Vector3 nextCameraPos = Vector3.zero;
    private Camera _camera;
    private float distance = 0f;
    private float mouseY = 0f;
    private float mouseX = 0f;
    private float currentHeight;
    private float cullingDistance;
    //private float checkHeightRadius = 0.4f;
    private float clipPlaneMargin = 0f;
    private float forward = -1f;
    private float xMinLimit = -360f;
    private float xMaxLimit = 360f;
    private RaycastHit hitInfo;
    private float distanceTime = 0f;
    private float curSmoothFollow = 5f;
    private CameraState mState = CameraState.Drag;
    private float clipOffset = 1f;//相機視口區域射線檢測區擴大
    public CameraState State
    {
        get
        {
            return mState;
        }
        set
        {
            if (value == mState)
                return;
            mState = value;
            UpdateState();
        }
    }
    #endregion
    #region 相機基礎功能函數區--------------------------------------------------------------------------------
    private void UpdateState()
    {
        switch (mState)
        {
            case CameraState.Auto:
                m_currentCameraRotation = smoothCameraRotationAuto;
                break;
            case CameraState.AutoFixY:
                break;
            default:
                m_currentCameraRotation = smoothCameraRotation;
                break;
        }
    }
    public float GetMouseX()
    {
        return mouseX;
    }
    public float GetMouseY()
    {
        return mouseY;
    }
    public void SetRotateY(float targetX)
    {
        mouseX = targetX;
    }
    public void Release()
    {
        if (targetLookAt != null)
        {
            GameObject.Destroy(targetLookAt);
            targetLookAt = null;
        }
        if (nextTargetLookAt != null)
        {
            GameObject.Destroy(nextTargetLookAt);
            nextTargetLookAt = null;
        }
    }
    public void Init()
    {
        cullingLayer = 1 << (int)PublicConst.E_Layer.Layer_Road;
        currentTargetPos = new Vector3(currentPlayerPos.x, currentPlayerPos.y + offSetPlayerPivot, currentPlayerPos.z);
        if (targetLookAt == null)
        {
            targetLookAt = new GameObject("targetLookAt").transform;
            GameObject.DontDestroyOnLoad(targetLookAt);
        }
        if (nextTargetLookAt == null)
        {
            nextTargetLookAt = new GameObject("nextTargetLookAt").transform;
            GameObject.DontDestroyOnLoad(nextTargetLookAt);
        }
        targetLookAt.position = currentTargetPos;
        targetLookAt.rotation = Quaternion.Euler(mouseY, mouseX, 0);
        nextTargetLookAt.position = currentTargetPos;
        nextTargetLookAt.rotation = Quaternion.Euler(mouseY, mouseX, 0);
        defaultDistance = Mathf.Clamp(defaultDistance, MinDistance, MaxDistance);
        if (State == CameraState.AutoFixY)
        {
            currentDistance = distance = camera2DDistance;
        }
        else
        {
            currentDistance = distance = defaultDistance;
        }
        currentHeight = height;
        UpdateState();
    }
    public void SetCamera(Camera cam, Transform cameraRootTrans, int xRot, int yRot)
    {
        mouseY = xRot;
        mouseX = yRot;
        _camera = cam;
        cameraTransform = cameraRootTrans;
        Init();
    }
    /// <summary>
    /// 相機看向角色的高度值，目的是看向人臉
    /// 1：不同高度的角色，需要配置這個值
    /// 2：在坐騎上 高度 = 坐騎坐墊高度 + 角色高度*0.5
    /// </summary>
    /// <param name="_height">高度 （單位 米）</param>
    public void SetHeight(float pHeight)
    {
        if(pHeight <= 0)
        {
            LiteCommon.BLog.E("相機中角色高度設置錯誤！ 值<=0!");
            height = defaultHeight;
            return;
        }
        height = pHeight;
    }
    /// <summary>
    /// 相機在lateUpdate中的持續更新
    /// </summary>
    public void UpdatePosition()
    {
        CameraMovement();
    }
    /// <summary>
    /// 持續縮進相機距離（觸控滑動交互）
    /// </summary>
    /// <param name="delta"></param>
    public void UpdateZoomFactor(float delta)
    {
        currentDistance -= delta * zoomSensitivity;
        currentDistance = Mathf.Clamp(currentDistance, MinDistance, MaxDistance);
    }
    /// <summary>
    /// 持續旋轉相機角度（觸控滑動交互）
    /// </summary>
    /// <param name="delta"></param>
    public void UpdateRotate(Vector2 delta)
    {
        RotateCamera(delta.x, delta.y);
    }
    /// <summary>
    /// 設置相機到固定位置
    /// </summary>
    /// <param name="_fixedAngleX">水平角度</param>
    /// <param name="_fixedAngleY">垂直角度</param>
    /// <param name="distance">相機對目標位置距離</param>
    public void SetCameraPos(float _fixedAngleX, float _fixedAngleY, float distance)
    {
        mouseX = _fixedAngleX;
        mouseY = _fixedAngleY;
        currentDistance = distance;
    }
    /// <summary>
    /// 更新角色位置
    /// </summary>
    /// <param name="pos"></param>
    public void UpdateRolePosition(Vector3 pos)
    {
        currentPlayerPos = pos;
        if (isLookingToOtherTarget)
        {
            if (!isAutoLookingTargetSmooth && otherlookTarget != null)
            {
                //Debug.Log("---->UpdateRolePosition otherlookTarget!");
                currentTargetPos = otherlookTarget.position;
            }
        }
        else
        {
            currentTargetPos = currentPlayerPos;
        }
    }
    /// <summary>
    /// 跟新相機目標對象的方向
    /// </summary>
    /// <param name="directionForward"></param>
    public void UpdateRoleDirection(Vector3 directionForward)
    {
        currentPlayerDirection = directionForward;
        currentPlayerDirectionRight = Vector3.Cross(directionForward, Vector3.up);
    }
    /// <summary>
    /// Camera Update 實時刷新相機方位，並且避免碰撞
    /// </summary>    
    void CameraMovement()
    {
        if (_camera == null)
            return;
        //next position and direction
        //distance = Mathf.Lerp(distance, currentDistance, smoothFollow * Time.deltaTime);
        //cullingDistance = Mathf.Lerp(cullingDistance, distance, Time.deltaTime);
        var camDir = (forward * targetLookAt.forward);
        camDir.Normalize();
        var targetPos = new Vector3(currentTargetPos.x, currentTargetPos.y + offSetPlayerPivot, currentTargetPos.z);
        currentTargetPos = targetPos;
        //look direction
        lookPoint = desired_cPos + targetLookAt.forward * 2f;
        lookPoint += (targetLookAt.right * Vector3.Dot(camDir * (distance), targetLookAt.right));
        //set current real looking height p;osition
        currentHeight = height;
        desired_cPos = targetPos + new Vector3(0, height, 0);
        current_cPos = currentTargetPos + new Vector3(0, currentHeight, 0);
        //next look Target
        nextTargetLookAt.position = desired_cPos;
        Quaternion newNextRot = Quaternion.Euler(mouseY, mouseX, 0);
        nextTargetLookAt.rotation = newNextRot;
        //next camera direction
        var nextCamDir = (forward * nextTargetLookAt.forward);
        nextCamDir.Normalize();
        //next look direction
        nextLookPoint = desired_cPos + nextTargetLookAt.forward * 2f;
        nextLookPoint += (nextTargetLookAt.right * Vector3.Dot(nextCamDir * (currentDistance), nextTargetLookAt.right));
        nextCameraPos = desired_cPos + (nextCamDir * currentDistance);
        //calculate next ClipPlanePoints
        ClipPlanePoints nextPlanePoints = _camera.NearClipPlanePoints(nextCameraPos, clipPlaneMargin, clipOffset);
        //if hit not success, then next target camera pos --> current camera pos
        //else calculate next target camera pos
        if (CullingRayCast(desired_cPos, nextPlanePoints, out hitInfo, currentDistance, cullingLayer, Color.cyan))
        {
            ///處理相機縮進和穿牆
            Vector3 nextPlayerToHitVec = desired_cPos - hitInfo.point;
            //下一幀和當前幀的弧度，弧度大小可以用來衡量變化快慢，這個快慢將會用來調節縮進速率
            float angleRad = Mathf.PI / 2 - Mathf.Acos(Vector3.Dot((-nextPlayerToHitVec).normalized, hitInfo.normal));
            //換算相機側翼寬度為相機到目標位置方向上的距離，用來避免相機側翼太近導致的穿牆。
            //clipOffset * 0.9f 參數 0.9 使
            float length = Mathf.Abs((nextPlanePoints.width- clipOffset * 0.9f) / Mathf.Tan(angleRad));
            float hitLenth = nextPlayerToHitVec.magnitude;
            if (length > hitLenth)
            {
                length = hitLenth;
            }
            ClipPlanePoints planePoints = _camera.NearClipPlanePoints(cameraTransform.position, clipPlaneMargin, 1f);
            //根據下一個相機位置的弧度，決定相機縮進動畫的速率
            if (CullingViewRayCast(desired_cPos, planePoints, out hitInfo, distance + 0.2f, cullingLayer, Color.cyan))
            {
                curSmoothFollow = smoothFollow * Mathf.Abs(angleRad) * 40f / Mathf.PI;
            }
            else
            {
                curSmoothFollow = smoothFollow;
            }
            //調整相機位置，避免相機邊緣發生穿牆
            Vector3 targetCameraVector = nextPlayerToHitVec - nextPlayerToHitVec.normalized * length;
            cullingDistance = targetCameraVector.magnitude;
            cullingDistance = Mathf.Clamp(cullingDistance, 0f, currentDistance);
            distance = Mathf.Lerp(distance, cullingDistance, curSmoothFollow * Time.deltaTime);
            distance = Mathf.Clamp(distance, MinDistance, MaxDistance);
            distanceTime += curSmoothFollow * Time.deltaTime;
            Vector3 camDirComp = Vector3.Lerp(camDir, nextCamDir, distanceTime);
            cameraTransform.position = desired_cPos + (camDirComp * distance);
            cameraTransform.rotation = Quaternion.LookRotation((desired_cPos) - cameraTransform.position);
        }
        else
        {
            distanceTime = 0;
            distance = Mathf.Lerp(distance, currentDistance, smoothFollow * Time.deltaTime);
            targetLookAt.position = desired_cPos;
            targetLookAt.rotation = Quaternion.Euler(mouseY, mouseX, 0);
            Vector3 desiredCameraPos = desired_cPos + (forward * targetLookAt.forward * distance);
            ClipPlanePoints planePoints = _camera.NearClipPlanePoints(desiredCameraPos, clipPlaneMargin, 1);
            if (!CullingViewRayCast(desired_cPos, planePoints, out hitInfo, distance + 0.2f, cullingLayer, Color.cyan))
            {
                cameraTransform.position = desiredCameraPos;
                cameraTransform.rotation = Quaternion.LookRotation((desired_cPos) - cameraTransform.position);
            }
        }
        Debug.DrawLine(desired_cPos, nextPlanePoints.LowerLeft, Color.red);
        Debug.DrawLine(desired_cPos, nextPlanePoints.LowerRight, Color.red);
        Debug.DrawLine(desired_cPos, nextPlanePoints.UpperRight, Color.red);
        Debug.DrawLine(desired_cPos, nextPlanePoints.UpperLeft, Color.red);
        Debug.DrawLine(nextTargetLookAt.position, nextTargetLookAt.position + nextTargetLookAt.forward, Color.blue);
        Debug.DrawLine(targetLookAt.position, targetLookAt.position + targetLookAt.forward, Color.green);
        movementSpeed = Vector2.zero;
    }
    /// <summary>
    /// 視口投射射線檢測
    /// </summary>
    /// <param name="from">起點</param>
    /// <param name="_to">目標點</param>
    /// <param name="hitInfo">RaycastHit</param>
    /// <param name="distance">距離</param>
    /// <param name="cullingLayer">裁剪層</param>
    /// <param name="color">調試顏色</param>
    /// <returns></returns>
    bool CullingViewRayCast(Vector3 from, ClipPlanePoints _to, out RaycastHit hitInfo, float distance, LayerMask cullingLayer, Color color)
    {
        bool value = false;
        if (Physics.Raycast(from, _to.LowerRight - from, out hitInfo, distance, cullingLayer))
        {
            value = true;
        }
        else if (Physics.Raycast(from, _to.LowerLeft - from, out hitInfo, distance, cullingLayer))
        {
            value = true;
        }
        else if (Physics.Raycast(from, _to.UpperRight - from, out hitInfo, distance, cullingLayer))
        {
            value = true;
        }
        else if (Physics.Raycast(from, _to.UpperLeft - from, out hitInfo, distance, cullingLayer))
        {
            value = true;
        }
        return value;
    }
    /// <summary>
    ///獲取最遠點檢測點離想幾點最遠位置進行檢測
    ///判斷相機在視口邊緣坐標的最遠點
    /// </summary>
    /// <param name="_to"></param>
    /// <param name="from"></param> 
    /// <param name="hitInfo"></param>
    /// <param name="distance"></param>
    /// <param name="cullingLayer"></param>
    /// <returns></returns>
    bool CullingRayCast(Vector3 from, ClipPlanePoints _to, out RaycastHit hitInfo, float distance, LayerMask cullingLayer, Color color)
    {
        bool value = false;
        RaycastHit curHitInfo;
        if (Physics.Raycast(from, _to.LowerRight - from, out hitInfo, distance, cullingLayer))
        {
            value = true;
        }
        if (Physics.Raycast(from, _to.LowerLeft - from, out curHitInfo, distance, cullingLayer))
        {
            if (value)
            {
                if (hitInfo.distance > curHitInfo.distance)
                    hitInfo = curHitInfo;
            }
            else
            {
                hitInfo = curHitInfo;
            }
            value = true;
        }
        if (Physics.Raycast(from, _to.UpperRight - from, out curHitInfo, distance, cullingLayer))
        {
            if (value)
            {
                if (hitInfo.distance > curHitInfo.distance)
                    hitInfo = curHitInfo;
            }
            else
            {
                hitInfo = curHitInfo;
            }
            value = true;
        }
        if (Physics.Raycast(from, _to.UpperLeft - from, out curHitInfo, distance, cullingLayer))
        {
            if (value)
            {
                if (hitInfo.distance > curHitInfo.distance)
                    hitInfo = curHitInfo;
            }
            else
            {
                hitInfo = curHitInfo;
            }
            value = true;
        }
        return value;
    }
    #endregion 相機基礎功能區 End--------------------------------------------------------------------------------
}
 
//視口信息數據類
 public static class vExtensions
    {
        public static T[]  Append<T>(this T[] arrayInitial, T[] arrayToAppend) 
        {
            if (arrayToAppend == null)
            {
                throw new ArgumentNullException("The appended object cannot be null");
            }
            if ((arrayInitial is string) || (arrayToAppend is string))
            {
                throw new ArgumentException("The argument must be an enumerable");
            }
            T[] ret = new T[arrayInitial.Length + arrayToAppend.Length];
            arrayInitial.CopyTo(ret, 0);
            arrayToAppend.CopyTo(ret, arrayInitial.Length);
            return ret;
        }
        /// <summary>
        /// Normalized the angle. between -180 and 180 degrees
        /// </summary>
        /// <param Name="eulerAngle">Euler angle.</param>
        public static Vector3 NormalizeAngle(this Vector3 eulerAngle)
        {
            var delta = eulerAngle;
            if (delta.x > 180) delta.x -= 360;
            else if (delta.x < -180) delta.x += 360;
            if (delta.y > 180) delta.y -= 360;
            else if (delta.y < -180) delta.y += 360;
            if (delta.z > 180) delta.z -= 360;
            else if (delta.z < -180) delta.z += 360;
            return new Vector3(delta.x, delta.y, delta.z);//round values to angle;
        }
        public static Vector3 Difference(this Vector3 vector, Vector3 otherVector)
        {
            return otherVector - vector;
        }
        public static void SetActiveChildren(this GameObject gameObjet, bool value)
        {
            foreach (Transform child in gameObjet.transform)
                child.gameObject.SetActive(value);
        }
        public static void SetLayerRecursively(this GameObject obj, int layer)
        {
            obj.layer = layer;
            foreach (Transform child in obj.transform)
            {
                child.gameObject.SetLayerRecursively(layer);
            }
        }
        public static float ClampAngle(float angle, float min, float max)
        {
            do
            {
                if (angle < -360)
                    angle += 360;
                if (angle > 360)
                    angle -= 360;
            } while (angle < -360 || angle > 360);
            return Mathf.Clamp(angle, min, max);
        }      
        public static ClipPlanePoints NearClipPlanePoints(this Camera camera, Vector3 pos, float clipPlaneMargin, float clipOffset = 0f)
        {
            var clipPlanePoints = new ClipPlanePoints();
            clipPlanePoints.center = pos;
            var transform = camera.transform;
            var halfFOV = (camera.fieldOfView / 2) * Mathf.Deg2Rad;
            var aspect = camera.aspect;
            var distance = camera.nearClipPlane;
            var height = distance * Mathf.Tan(halfFOV);
            var width = height * aspect;
            height *= 1 + clipPlaneMargin;
            width *= 1 + clipPlaneMargin;
            clipPlanePoints.width = width * 2;
            clipPlanePoints.heigth = height * 2;
            height += clipOffset;
            width += clipOffset;
            clipPlanePoints.Right = pos + transform.right * width;
            clipPlanePoints.Left  = pos - transform.right * width;
            clipPlanePoints.Top   = pos + transform.up * height;
            clipPlanePoints.Lower = pos - transform.up * height;
            //todo:will delete
            clipPlanePoints.LowerRight = pos + transform.right * width;
            clipPlanePoints.LowerRight -= transform.up * height;
            clipPlanePoints.LowerRight += transform.forward * distance;
            clipPlanePoints.LowerLeft = pos - transform.right * width;
            clipPlanePoints.LowerLeft -= transform.up * height;
            clipPlanePoints.LowerLeft += transform.forward * distance;
            clipPlanePoints.UpperRight = pos + transform.right * width;
            clipPlanePoints.UpperRight += transform.up * height;
            clipPlanePoints.UpperRight += transform.forward * distance;
            clipPlanePoints.UpperLeft = pos - transform.right * width;
            clipPlanePoints.UpperLeft += transform.up * height;
            clipPlanePoints.UpperLeft += transform.forward * distance;
            return clipPlanePoints;
        }
      
        public static BoxPoint GetBoxPoint(this BoxCollider boxCollider)
        {
            BoxPoint bp = new BoxPoint();
            bp.center =  boxCollider.transform.TransformPoint(boxCollider.center)  ;          
            var height = boxCollider.transform.lossyScale.y * boxCollider.size.y;          
            var ray = new Ray(bp.center, boxCollider.transform.up);
           
            bp.top =    ray.GetPoint((height * 0.5f));
            bp.bottom = ray.GetPoint(-(height * 0.5f));
           
            return bp;
        }
        public static Vector3 BoxSize(this BoxCollider boxCollider)
        {
            var length = boxCollider.transform.lossyScale.x * boxCollider.size.x;
            var width = boxCollider.transform.lossyScale.z * boxCollider.size.z;
            var height = boxCollider.transform.lossyScale.y * boxCollider.size.y;
            return  new Vector3(length, height, width);
        }  
        public static bool Contains(this Enum keys, Enum flag)
        {
            if (keys.GetType() != flag.GetType())
                throw new ArgumentException("Type Mismatch");
            return (Convert.ToUInt64(keys) & Convert.ToUInt64(flag)) != 0;
        }
       
    }
    public struct BoxPoint
    {
        public Vector3 top;
        public Vector3 center;
        public Vector3 bottom;
       
    }
    public struct ClipPlanePoints
    {
        public Vector3 UpperLeft;
        public Vector3 UpperRight;
        public Vector3 LowerLeft;
        public Vector3 LowerRight;
        public Vector3 center;
        public Vector3 Right;
        public Vector3 Left;
        public Vector3 Top;
        public Vector3 Lower;
        public float width;
        public float heigth;
    }
}