Example #1
0
        public bool Raycast(Ray3D ray, out float t)
        {
            if (ray.IntersectsPlane(_plane, out t))
            {
                Vector3 intersectionPoint = ray.GetPoint(t);
                return(ContainsPoint(intersectionPoint));
            }

            return(false);
        }
Example #2
0
        public bool IntersectsRay(Ray3D ray, out float t)
        {
            Plane   circlePlane  = Plane;
            Vector3 circleCenter = Center;
            float   scaledRadius = ScaledRadius;

            // Note: 'IntersectsPlane' not enough. Also check for containment????
            if (ray.IntersectsPlane(circlePlane, out t))
            {
                return(true);
            }
            else
            if (ray.Direction.IsPerpendicularTo(circlePlane.normal))
            {
                // Project the circle center onto the ray direction segment. If the distance between the circle center
                // and the projected center is <= the circle's radius, the ray might intersect the circle. Otherwise,
                // the ray can not possibly intersect the circle.
                Segment3D segment = new Segment3D(ray);
                Vector3   centerProjectedOnRayDir     = circleCenter.CalculateProjectionPointOnSegment(segment.StartPoint, segment.EndPoint);
                Vector3   fromCenterToProjectedCenter = centerProjectedOnRayDir - circleCenter;
                float     triAdjSideLength1           = fromCenterToProjectedCenter.magnitude;
                if (triAdjSideLength1 > scaledRadius)
                {
                    return(false);
                }

                // At this point it is possible that the ray might intersect the circle. Calcluate how much
                // we have to move from the center projection to a point on the circle along the reverse of
                // the ray direction vector. We will store this amount in 'triAdjSideLength2'.
                float triAdjSideLength2 = Mathf.Sqrt(scaledRadius * scaledRadius - triAdjSideLength1 * triAdjSideLength1);

                // Now check if moving from the projected center along the reverse ray direction by an amount equal to
                // 'triAdjSideLength2', we end up on a point which resides on the ray direction segment.
                Vector3 normalizedRayDirection = ray.Direction;
                normalizedRayDirection.Normalize();
                Vector3 targetPoint = centerProjectedOnRayDir - triAdjSideLength2 * normalizedRayDirection;
                if (targetPoint.IsOnSegment(segment.StartPoint, segment.EndPoint))
                {
                    // The point sits on the segment, which means that the ray intersects the circle.
                    // Now we need to calculate the intersection offset.
                    t = (targetPoint - ray.Origin).magnitude / ray.Direction.magnitude;
                    return(true);
                }
            }

            return(false);
        }
Example #3
0
        public bool IntersectsTriangle(Triangle3D triangle, out Triangle3DIntersectInfo intersectInfo)
        {
            intersectInfo = new Triangle3DIntersectInfo();
            if (triangle.Normal.IsAlignedWith(Normal))
            {
                return(false);
            }

            float            t;
            List <Segment3D> otherTriSegments = triangle.GetSegments();
            var firstTriIntersectionPoints    = new List <Vector3>();

            foreach (var segment in otherTriSegments)
            {
                Ray3D ray = new Ray3D(segment.StartPoint, segment.EndPoint);
                if (Raycast(ray, out t))
                {
                    firstTriIntersectionPoints.Add(ray.GetPoint(t));
                }
            }

            List <Segment3D> thisTriSegments = GetSegments();
            var secondTriIntersectionPoints  = new List <Vector3>();

            foreach (var segment in thisTriSegments)
            {
                Ray3D ray = new Ray3D(segment.StartPoint, segment.EndPoint);
                if (triangle.Raycast(ray, out t))
                {
                    secondTriIntersectionPoints.Add(ray.GetPoint(t));
                }
            }

            if (firstTriIntersectionPoints.Count != 0 || secondTriIntersectionPoints.Count != 0)
            {
                intersectInfo = new Triangle3DIntersectInfo(this, triangle, firstTriIntersectionPoints, secondTriIntersectionPoints);
                return(true);
            }

            return(false);
        }
        /// <summary>
        /// Calculates and returns the edge rays which connect the points of the specified camera
        /// view volume.
        /// </summary>
        public static Ray3D[] CalculateWorldSpaceVolumeEdgeRays(CameraViewVolume cameraViewVolume)
        {
            var worldSpaceVolumeEdgeRays = new Ray3D[12];

            // Calculate the rays that connect the points on the near plane
            worldSpaceVolumeEdgeRays[0] = new Ray3D(cameraViewVolume.TopLeftPointOnNearPlane, cameraViewVolume.TopRightPointOnNearPlane - cameraViewVolume.TopLeftPointOnNearPlane);
            worldSpaceVolumeEdgeRays[1] = new Ray3D(cameraViewVolume.TopRightPointOnNearPlane, cameraViewVolume.BottomRightPointOnNearPlane - cameraViewVolume.TopRightPointOnNearPlane);
            worldSpaceVolumeEdgeRays[2] = new Ray3D(cameraViewVolume.BottomRightPointOnNearPlane, cameraViewVolume.BottomLeftPointOnNearPlane - cameraViewVolume.BottomRightPointOnNearPlane);
            worldSpaceVolumeEdgeRays[3] = new Ray3D(cameraViewVolume.BottomLeftPointOnNearPlane, cameraViewVolume.TopLeftPointOnNearPlane - cameraViewVolume.BottomLeftPointOnNearPlane);

            // Calculate the rays that connect the points on the far plane
            worldSpaceVolumeEdgeRays[4] = new Ray3D(cameraViewVolume.TopLeftPointOnFarPlane, cameraViewVolume.TopRightPointOnFarPlane - cameraViewVolume.TopLeftPointOnFarPlane);
            worldSpaceVolumeEdgeRays[5] = new Ray3D(cameraViewVolume.TopRightPointOnFarPlane, cameraViewVolume.BottomRightPointOnFarPlane - cameraViewVolume.TopRightPointOnFarPlane);
            worldSpaceVolumeEdgeRays[6] = new Ray3D(cameraViewVolume.BottomRightPointOnFarPlane, cameraViewVolume.BottomLeftPointOnFarPlane - cameraViewVolume.BottomRightPointOnFarPlane);
            worldSpaceVolumeEdgeRays[7] = new Ray3D(cameraViewVolume.BottomLeftPointOnFarPlane, cameraViewVolume.TopLeftPointOnFarPlane - cameraViewVolume.BottomLeftPointOnFarPlane);

            // Calculate the rays that connect the points between the near and far planes
            worldSpaceVolumeEdgeRays[8]  = new Ray3D(cameraViewVolume.TopLeftPointOnNearPlane, cameraViewVolume.TopLeftPointOnFarPlane - cameraViewVolume.TopLeftPointOnNearPlane);
            worldSpaceVolumeEdgeRays[9]  = new Ray3D(cameraViewVolume.TopRightPointOnNearPlane, cameraViewVolume.TopRightPointOnFarPlane - cameraViewVolume.TopRightPointOnNearPlane);
            worldSpaceVolumeEdgeRays[10] = new Ray3D(cameraViewVolume.BottomRightPointOnNearPlane, cameraViewVolume.BottomRightPointOnFarPlane - cameraViewVolume.BottomRightPointOnNearPlane);
            worldSpaceVolumeEdgeRays[11] = new Ray3D(cameraViewVolume.BottomLeftPointOnNearPlane, cameraViewVolume.BottomLeftPointOnFarPlane - cameraViewVolume.BottomLeftPointOnNearPlane);

            return(worldSpaceVolumeEdgeRays);
        }
Example #5
0
 private Ray3D TransformRayInEllipseCircleSpace(Ray3D ray)
 {
     return(new Ray3D(TransformPointInEllipseCircleLocalSpace(ray.Origin), TransformVectorInEllipseCircleLocalSpace(ray.Direction)));
 }
Example #6
0
        public bool IntersectsRay(Ray3D ray)
        {
            float t;

            return(IntersectsRay(ray, out t));
        }