/// <summary>
        /// Intersection test of ray step with given plane.
        /// </summary>
        /// <returns>Whether the ray step intersects the ray step.</returns>
        public static bool RaycastPlanePhysicsStep(RayStep step, Plane plane, out Vector3 hitPoint)
        {
            using (RaycastPlanePhysicsStepPerfMarker.Auto())
            {
                if (plane.Raycast(step, out float intersectDistance))
                {
                    if (intersectDistance <= step.Length)
                    {
                        hitPoint = ((Ray)step).GetPoint(intersectDistance);
                        return(true);
                    }
                }

                hitPoint = Vector3.zero;
                return(false);
            }
        }
示例#2
0
        /// <summary>
        /// Returns a point along an array of RaySteps by distance
        /// </summary>
        public static Vector3 GetPointByDistance(RayStep[] steps, float distance)
        {
            Debug.Assert(steps != null);
            Debug.Assert(steps.Length > 0);

            float   remainingDistance = 0;
            RayStep rayStep           = GetStepByDistance(steps, distance, ref remainingDistance);

            if (remainingDistance > 0)
            {
                return(Vector3.Lerp(rayStep.Origin, rayStep.Terminus, remainingDistance / rayStep.Length));
            }
            else
            {
                return(rayStep.Terminus);
            }
        }
        /// <summary>
        /// Sphere raycasts each physics <see cref="Microsoft.MixedReality.Toolkit.Physics.RayStep"/> within a specified maximum distance.
        /// </summary>
        /// <returns>Whether or not the raycast hit something.</returns>
        public static bool RaycastSpherePhysicsStep(RayStep step, float radius, float maxDistance, LayerMask[] prioritizedLayerMasks, bool focusIndividualCompoundCollider, out RaycastHit physicsHit)
        {
            using (RaycastSpherePhysicsStepPerfMarker.Auto())
            {
                bool result = false;
                if (prioritizedLayerMasks.Length == 1)
                {
                    // If there is only one priority, don't prioritize
                    result = UnityEngine.Physics.SphereCast(step.Origin, radius, step.Direction, out physicsHit, maxDistance, prioritizedLayerMasks[0]);
                }
                else
                {
                    // Raycast across all layers and prioritize
                    int hitCount = UnityEngine.Physics.SphereCastNonAlloc(step.Origin, radius, step.Direction, SphereCastHits, maxDistance, UnityEngine.Physics.AllLayers);
                    result = TryGetPrioritizedPhysicsHit(SphereCastHits, hitCount, prioritizedLayerMasks, focusIndividualCompoundCollider, out physicsHit);
                }

                return(result);
            }
        }
        /// <summary>
        /// Simple raycasts each physics <see cref="Microsoft.MixedReality.Toolkit.Physics.RayStep"/> within a specified maximum distance.
        /// </summary>
        /// <returns>Whether or not the raycast hit something.</returns>
        public static bool RaycastSimplePhysicsStep(RayStep step, float maxDistance, LayerMask[] prioritizedLayerMasks, bool focusIndividualCompoundCollider, out RaycastHit physicsHit)
        {
            using (RaycastSimplePhysicsStepPerfMarker.Auto())
            {
                Debug.Assert(maxDistance > 0, "Length must be longer than zero!");
                Debug.Assert(step.Direction != Vector3.zero, "Invalid step direction!");

                bool result = false;
                if (prioritizedLayerMasks.Length == 1)
                {
                    // If there is only one priority, don't prioritize
                    result = UnityEngine.Physics.Raycast(step.Origin, step.Direction, out physicsHit, maxDistance, prioritizedLayerMasks[0]);
                }
                else
                {
                    // Raycast across all layers and prioritize
                    int hitCount = UnityEngine.Physics.RaycastNonAlloc(step.Origin, step.Direction, RaycastHits, maxDistance, UnityEngine.Physics.AllLayers);
                    result = TryGetPrioritizedPhysicsHit(RaycastHits, hitCount, prioritizedLayerMasks, focusIndividualCompoundCollider, out physicsHit);
                }

                return(result);
            }
        }
示例#5
0
        /// <summary>
        /// Box raycasts each physics <see cref="Microsoft.MixedReality.Toolkit.Physics.RayStep"/>.
        /// </summary>
        /// <returns>Whether or not the raycast hit something.</returns>
        public static bool RaycastBoxPhysicsStep(RayStep step, Vector3 extents, Vector3 targetPosition, Matrix4x4 matrix, float maxDistance, LayerMask[] prioritizedLayerMasks, int raysPerEdge, bool isOrthographic, bool focusIndividualCompoundCollider, out Vector3[] points, out Vector3[] normals, out bool[] hits)
        {
            if (Application.isEditor && DebugEnabled)
            {
                Debug.DrawLine(step.Origin, step.Origin + step.Direction * 10.0f, Color.green);
            }

            extents /= (raysPerEdge - 1);

            int  halfRaysPerEdge = (int)((raysPerEdge - 1) * 0.5f);
            int  numRays         = raysPerEdge * raysPerEdge;
            bool hitSomething    = false;

            points  = new Vector3[numRays];
            normals = new Vector3[numRays];
            hits    = new bool[numRays];

            int index = 0;

            for (int x = -halfRaysPerEdge; x <= halfRaysPerEdge; x += 1)
            {
                for (int y = -halfRaysPerEdge; y <= halfRaysPerEdge; y += 1)
                {
                    Vector3 offset = matrix.MultiplyVector(new Vector3(x * extents.x, y * extents.y, 0));

                    Vector3 origin    = step.Origin;
                    Vector3 direction = (targetPosition + offset) - step.Origin;

                    if (isOrthographic)
                    {
                        origin   += offset;
                        direction = step.Direction;
                    }

                    RaycastHit rayHit;
                    hits[index] = RaycastSimplePhysicsStep(new RayStep(origin, direction.normalized * maxDistance), prioritizedLayerMasks, focusIndividualCompoundCollider, out rayHit);

                    if (hits[index])
                    {
                        hitSomething   = true;
                        points[index]  = rayHit.point;
                        normals[index] = rayHit.normal;

                        if (Application.isEditor && DebugEnabled)
                        {
                            Debug.DrawLine(origin, points[index], Color.yellow);
                        }
                    }
                    else
                    {
                        if (Application.isEditor && DebugEnabled)
                        {
                            Debug.DrawLine(origin, origin + direction * 3.0f, Color.gray);
                        }
                    }

                    index++;
                }
            }

            return(hitSomething);
        }
示例#6
0
 /// <summary>
 /// Simple raycasts each physics <see cref="Microsoft.MixedReality.Toolkit.Physics.RayStep"/>.
 /// </summary>
 /// <param name="step"></param>
 /// <param name="prioritizedLayerMasks"></param>
 /// <param name="physicsHit"></param>
 /// <returns>Whether or not the raycast hit something.</returns>
 public static bool RaycastSimplePhysicsStep(RayStep step, LayerMask[] prioritizedLayerMasks, bool focusIndividualCompoundCollider, out RaycastHit physicsHit)
 {
     return(RaycastSimplePhysicsStep(step, step.Length, prioritizedLayerMasks, focusIndividualCompoundCollider, out physicsHit));
 }
示例#7
0
 /// <summary>
 /// Simple raycasts each physics <see cref="Microsoft.MixedReality.Toolkit.Physics.RayStep"/>.
 /// </summary>
 /// <param name="step"></param>
 /// <param name="prioritizedLayerMasks"></param>
 /// <param name="physicsHit"></param>
 /// <returns>Whether or not the raycast hit something.</returns>
 public static bool RaycastSimplePhysicsStep(RayStep step, LayerMask[] prioritizedLayerMasks, out RaycastHit physicsHit)
 {
     return(RaycastSimplePhysicsStep(step, step.Length, prioritizedLayerMasks, out physicsHit));
 }
示例#8
0
 /// <summary>
 /// Sphere raycasts each physics <see cref="Microsoft.MixedReality.Toolkit.Physics.RayStep"/>.
 /// </summary>
 /// <param name="step"></param>
 /// <param name="radius"></param>
 /// <param name="prioritizedLayerMasks"></param>
 /// <param name="physicsHit"></param>
 /// <returns>Whether or not the raycast hit something.</returns>
 public static bool RaycastSpherePhysicsStep(RayStep step, float radius, LayerMask[] prioritizedLayerMasks, out RaycastHit physicsHit)
 {
     return(RaycastSpherePhysicsStep(step, radius, step.Length, prioritizedLayerMasks, out physicsHit));
 }