Exemplo n.º 1
0
        public bool IsSpanningOrIsCloseInFrontOrOnPlane(Plane plane, float allowedClosestDistance)
        {
            BoxPlaneClassificationResult boxClassificationResult = plane.ClassifyOrientedBox(this);

            if (boxClassificationResult == BoxPlaneClassificationResult.Spanning ||
                boxClassificationResult == BoxPlaneClassificationResult.OnPlane)
            {
                return(true);
            }
            if (boxClassificationResult == BoxPlaneClassificationResult.Behind)
            {
                return(false);
            }

            List <Vector3> centerAndCornerPoints = GetCenterAndCornerPoints();

            if (plane.IsAnyPointOnPlane(centerAndCornerPoints))
            {
                return(true);
            }

            Vector3 closestPointInFront;

            if (plane.GetClosestPointInFront(GetCenterAndCornerPoints(), out closestPointInFront))
            {
                return(plane.GetDistanceToPoint(closestPointInFront) <= allowedClosestDistance);
            }

            return(false);
        }
Exemplo n.º 2
0
        public bool IntersectsBox(Box box)
        {
            // Store needed data
            Vector3 boxCenter = box.Center;
            float   eX        = box.Extents.x;
            float   eY        = box.Extents.y;
            float   eZ        = box.Extents.z;

            // The triangle points expressed relative to the center of the box
            Vector3 v0 = _points[0] - boxCenter;
            Vector3 v1 = _points[1] - boxCenter;
            Vector3 v2 = _points[2] - boxCenter;

            // Triangle edges
            Vector3 e0 = v1 - v0;
            Vector3 e1 = v2 - v1;
            Vector3 e2 = v0 - v2;

            // Use the separating axis test for all 9 axes which result from crossing the box's local axes
            // with the triangle esges.
            // Test a00 = <1, 0, 0> X e0 = <0, -e0.z, e0.y>
            Vector3 axis   = new Vector3(0.0f, -e0.z, e0.y);
            float   v0Prj  = Vector3.Dot(v0, axis);
            float   v1Prj  = Vector3.Dot(v1, axis);
            float   v2Prj  = Vector3.Dot(v2, axis);
            float   prjEx  = Mathf.Abs(eY * axis.y) + Mathf.Abs(eZ * axis.z);
            float   minPrj = MathfEx.Min(v0Prj, v1Prj, v2Prj);
            float   maxPrj = MathfEx.Max(v0Prj, v1Prj, v2Prj);

            if (Mathf.Max(-maxPrj, minPrj) > prjEx)
            {
                return(false);
            }

            // Test a01 = <1, 0, 0> X e1 = <0, -e1.z, e1.y>
            axis   = new Vector3(0.0f, -e1.z, e1.y);
            v0Prj  = Vector3.Dot(v0, axis);
            v1Prj  = Vector3.Dot(v1, axis);
            v2Prj  = Vector3.Dot(v2, axis);
            prjEx  = Mathf.Abs(eY * axis.y) + Mathf.Abs(eZ * axis.z);
            minPrj = MathfEx.Min(v0Prj, v1Prj, v2Prj);
            maxPrj = MathfEx.Max(v0Prj, v1Prj, v2Prj);
            if (Mathf.Max(-maxPrj, minPrj) > prjEx)
            {
                return(false);
            }

            // Test a02 = <1, 0, 0> X e2 = <0, -e2.z, e2.y>
            axis   = new Vector3(0.0f, -e2.z, e2.y);
            v0Prj  = Vector3.Dot(v0, axis);
            v1Prj  = Vector3.Dot(v1, axis);
            v2Prj  = Vector3.Dot(v2, axis);
            prjEx  = Mathf.Abs(eY * axis.y) + Mathf.Abs(eZ * axis.z);
            minPrj = MathfEx.Min(v0Prj, v1Prj, v2Prj);
            maxPrj = MathfEx.Max(v0Prj, v1Prj, v2Prj);
            if (Mathf.Max(-maxPrj, minPrj) > prjEx)
            {
                return(false);
            }

            // Test a10 = <0, 1, 0> X e0 = <e0.z, 0, -e0.x>
            axis   = new Vector3(e0.z, 0.0f, -e0.x);
            v0Prj  = Vector3.Dot(v0, axis);
            v1Prj  = Vector3.Dot(v1, axis);
            v2Prj  = Vector3.Dot(v2, axis);
            prjEx  = Mathf.Abs(eX * axis.x) + Mathf.Abs(eZ * axis.z);
            minPrj = MathfEx.Min(v0Prj, v1Prj, v2Prj);
            maxPrj = MathfEx.Max(v0Prj, v1Prj, v2Prj);
            if (Mathf.Max(-maxPrj, minPrj) > prjEx)
            {
                return(false);
            }

            // Test a11 = <0, 1, 0> X e1 = <e1.z, 0, -e1.x>
            axis   = new Vector3(e1.z, 0.0f, -e1.x);
            v0Prj  = Vector3.Dot(v0, axis);
            v1Prj  = Vector3.Dot(v1, axis);
            v2Prj  = Vector3.Dot(v2, axis);
            prjEx  = Mathf.Abs(eX * axis.x) + Mathf.Abs(eZ * axis.z);
            minPrj = MathfEx.Min(v0Prj, v1Prj, v2Prj);
            maxPrj = MathfEx.Max(v0Prj, v1Prj, v2Prj);
            if (Mathf.Max(-maxPrj, minPrj) > prjEx)
            {
                return(false);
            }

            // Test a12 = <0, 1, 0> X e2 = <e2.z, 0, -e2.x>
            axis   = new Vector3(e2.z, 0.0f, -e2.x);
            v0Prj  = Vector3.Dot(v0, axis);
            v1Prj  = Vector3.Dot(v1, axis);
            v2Prj  = Vector3.Dot(v2, axis);
            prjEx  = Mathf.Abs(eX * axis.x) + Mathf.Abs(eZ * axis.z);
            minPrj = MathfEx.Min(v0Prj, v1Prj, v2Prj);
            maxPrj = MathfEx.Max(v0Prj, v1Prj, v2Prj);
            if (Mathf.Max(-maxPrj, minPrj) > prjEx)
            {
                return(false);
            }

            // Test a20 = <0, 0, 1> X e0 = <-e0.y, e0.x, 0>
            axis   = new Vector3(-e0.y, e0.x, 0.0f);
            v0Prj  = Vector3.Dot(v0, axis);
            v1Prj  = Vector3.Dot(v1, axis);
            v2Prj  = Vector3.Dot(v2, axis);
            prjEx  = Mathf.Abs(eX * axis.x) + Mathf.Abs(eY * axis.y);
            minPrj = MathfEx.Min(v0Prj, v1Prj, v2Prj);
            maxPrj = MathfEx.Max(v0Prj, v1Prj, v2Prj);
            if (Mathf.Max(-maxPrj, minPrj) > prjEx)
            {
                return(false);
            }

            // Test a21 = <0, 0, 1> X e1 = <-e1.y, e1.x, 0>
            axis   = new Vector3(-e1.y, e1.x, 0.0f);
            v0Prj  = Vector3.Dot(v0, axis);
            v1Prj  = Vector3.Dot(v1, axis);
            v2Prj  = Vector3.Dot(v2, axis);
            prjEx  = Mathf.Abs(eX * axis.x) + Mathf.Abs(eY * axis.y);
            minPrj = MathfEx.Min(v0Prj, v1Prj, v2Prj);
            maxPrj = MathfEx.Max(v0Prj, v1Prj, v2Prj);
            if (Mathf.Max(-maxPrj, minPrj) > prjEx)
            {
                return(false);
            }

            // Test a22 = <0, 0, 1> X e2 = <-e2.y, e2.x, 0>
            axis   = new Vector3(-e2.y, e2.x, 0.0f);
            v0Prj  = Vector3.Dot(v0, axis);
            v1Prj  = Vector3.Dot(v1, axis);
            v2Prj  = Vector3.Dot(v2, axis);
            prjEx  = Mathf.Abs(eX * axis.x) + Mathf.Abs(eY * axis.y);
            minPrj = MathfEx.Min(v0Prj, v1Prj, v2Prj);
            maxPrj = MathfEx.Max(v0Prj, v1Prj, v2Prj);
            if (Mathf.Max(-maxPrj, minPrj) > prjEx)
            {
                return(false);
            }

            // Check if the triangle's box intersects the box
            Box trianlgeBox = GetEncapsulatingBox();

            if (trianlgeBox.IntersectsBox(box, true))
            {
                return(true);
            }

            // Check if the box spans the triangle plane
            BoxPlaneClassificationResult boxPlaneCalssifyResult = Plane.ClassifyBox(box);

            return(boxPlaneCalssifyResult == BoxPlaneClassificationResult.Spanning || boxPlaneCalssifyResult == BoxPlaneClassificationResult.OnPlane);
        }