【原】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;
    }
}