public static bool Raycast(Ray ray, out RaycastHit raycastHit, RaycastData raycastData) => Physics.Raycast( ray: ray, hitInfo: out raycastHit, maxDistance: raycastData._MaxDistance, layerMask: raycastData._LayerMask, queryTriggerInteraction: raycastData._QueryTriggerInteraction );
private RaycastData GetDominantCornerAxis(Vector2 rayOrigin, Vector2 rayXDirection, Vector2 rayYDirection, float rayLength) { float rayXOverlapFraction = GetRayOverlapFraction(rayOrigin, rayXDirection, rayLength); float rayYOverlapFraction = GetRayOverlapFraction(rayOrigin, rayYDirection, rayLength); if (rayXOverlapFraction == 0 && rayYOverlapFraction == 0) { return(new RaycastData()); } RaycastData raycastData = new RaycastData(); float distance = 0; bool rayXIsDominant = rayXOverlapFraction > rayYOverlapFraction; if (rayXIsDominant) { CheckRaycastOther(rayOrigin, rayXDirection, rayLength, layers, out distance); raycastData.Distance = new Vector2(distance, 0); raycastData.Direction = Vector2.right; } else { CheckRaycastOther(rayOrigin, rayXDirection, rayLength, layers, out distance); raycastData.Distance = new Vector2(0, distance); raycastData.Direction = Vector2.up; } return(raycastData); }
protected override void OnUpdate() { foreach (CollisionEntityFilter entity in GetEntities <CollisionEntityFilter>()) { Velocity velocity = entity.VelocityComponent; CollisionData collisionData = entity.CollisionComponent; BoxCollider2D collider = entity.ColliderComponent; collisionData.previousSlopeAngle = collisionData.slopeAngle; ResetCollisionState(collisionData); float2 delta = velocity.Delta; RaycastData raycastData = CalculateRaycastData(collider, collisionData); if (delta.y < 0) { HandleSlopeDecend(ref delta, collider.edgeRadius, collisionData, raycastData); } if (delta.x != 0) { HandleHorizontalCollisions(ref delta, collider.edgeRadius, collisionData, raycastData); } if (delta.y != 0) { HandleVerticalCollision(ref delta, collider.edgeRadius, collisionData, raycastData); } NeutralizeVelocity(ref velocity, collisionData); velocity.Delta = delta; } }
private void Initialize() { if (!character) { character = GameObject.Find("Character"); } if (!boxCollider) { boxCollider = GetComponent <BoxCollider2D>(); } if (SettingsIsNull) { settings = CreateInstance <RaycastSettings>(); } if (InitializePlatformerController) { platformerController = GetComponent <PlatformerController>(); } if (InitializeLayerMaskController) { layerMaskController = GetComponent <LayerMaskController>(); } if (InitializePhysicsController) { physicsController = GetComponent <PhysicsController>(); } if (DataIsNull) { Data = CreateInstance <RaycastData>(); } Data.OnInitialize(ref boxCollider, ref character, settings); }
MeshEdgePosition FindMeshEdgePosition(RaycastData minimumViewCast, RaycastData maximumViewCast) { float minAngle = minimumViewCast.Angle; float maxAngle = maximumViewCast.Angle; Vector3 minPoint = minimumViewCast.Point; Vector3 maxPoint = maximumViewCast.Point; for (int i = 0; i < EdgePrecision; i++) { float angle = (minAngle + maxAngle) / 2; RaycastData newViewCast = RaycastAtAngle(angle); bool thresholdExceeded = Mathf.Abs(minimumViewCast.Distance - newViewCast.Distance) > EdgeThreshold; if (newViewCast.Hit = minimumViewCast.Hit && !thresholdExceeded) { minAngle = angle; minPoint = newViewCast.Point; } else { maxAngle = angle; maxPoint = newViewCast.Point; } } return(new MeshEdgePosition(minPoint, maxPoint)); }
private RaycastData CalculateRaycastData(BoxCollider2D collider, CollisionData collisionData) { RaycastData data = new RaycastData(); float skinWidth = collider.edgeRadius; Bounds bounds = collider.bounds; bounds.Expand(skinWidth * -2f); data.TopLeft = new Vector2(bounds.min.x, bounds.max.y); data.TopRight = bounds.max; data.BottomLeft = bounds.min; data.BottomRight = new Vector2(bounds.max.x, bounds.min.y); int horizontalRayCount = collisionData.HorizontalRayCount; int verticalRayCount = collisionData.VerticalRayCount; float horizontalSpacing = bounds.size.y / (horizontalRayCount - 1); float verticalSpacing = bounds.size.x / (verticalRayCount - 1); data.HorizontalRayCount = horizontalRayCount; data.VerticalRayCount = verticalRayCount; data.HorizontalRaySpacing = horizontalSpacing; data.VerticalRaySpacing = verticalSpacing; return(data); }
protected virtual void DrawMesh() { int steps = Mathf.RoundToInt(MeshDensity * VisionAngle); float stepsAngle = VisionAngle / steps; List <Vector3> viewPoints = new List <Vector3>(); RaycastData oldViewCast = new RaycastData(); for (int i = 0; i <= steps; i++) { float angle = stepsAngle * i + EulerAngles.y - VisionAngle / 2f; RaycastData viewCast = RaycastAtAngle(angle); if (i > 0) { bool thresholdExceeded = Mathf.Abs(oldViewCast.Distance - viewCast.Distance) > EdgeThreshold; if ((oldViewCast.Hit != viewCast.Hit) || (oldViewCast.Hit && viewCast.Hit && thresholdExceeded)) { MeshEdgePosition edge = FindMeshEdgePosition(oldViewCast, viewCast); if (edge.PointA != Vector3.zero) { viewPoints.Add(edge.PointA); } if (edge.PointB != Vector3.zero) { viewPoints.Add(edge.PointB); } } } viewPoints.Add(viewCast.Point); oldViewCast = viewCast; } int numberOfVertices = viewPoints.Count + 1; Vector3[] vertices = new Vector3[numberOfVertices]; int[] triangles = new int[(numberOfVertices - 2) * 3]; vertices[0] = Vector3.zero + Offset; for (int i = 0; i < numberOfVertices - 1; i++) { vertices[i + 1] = this.transform.InverseTransformPoint(viewPoints[i]); if (i < numberOfVertices - 2) { triangles[i * 3] = 0; triangles[i * 3 + 1] = i + 1; triangles[i * 3 + 2] = i + 2; } } _visionMesh.Clear(); _visionMesh.vertices = vertices; _visionMesh.triangles = triangles; _visionMesh.RecalculateNormals(); }
private RaycastData GetCornerBottomLeftRaycastData() { RaycastData bottomLeftCornerRaycastData = GetDominantCornerAxis(bottomLeftCornerPoint.position, leftUpDirection, rightDownDirection, cornerRayLength); Vector2 bottomLeftCornerDirection = new Vector2(bottomLeftCornerRaycastData.Direction.x * -1, bottomLeftCornerRaycastData.Direction.y * -1); return(new RaycastData() { Direction = bottomLeftCornerDirection, Distance = bottomLeftCornerRaycastData.Distance }); }
private RaycastData GetCornerTopLeftRaycastData() { RaycastData topLeftCornerRaycastData = GetDominantCornerAxis(topLeftCornerPoint.position, leftDownDirection, rightUpDirection, cornerRayLength); Vector2 topLeftCornerDirection = new Vector2(topLeftCornerRaycastData.Direction.x * -1, topLeftCornerRaycastData.Direction.y); return(new RaycastData() { Direction = topLeftCornerDirection, Distance = topLeftCornerRaycastData.Distance }); }
public RaycastData GetCombinedDirectionAndCenterDistances() { RaycastData centerRaycastData = GetCenterRaycastData(); Vector2 cornersDirection = GetCornersDirection(); Vector2 combinedDirection = centerRaycastData.Direction + cornersDirection; Vector2 raycastDataDirection = VectorHelper.Clamp(combinedDirection, -1, 1); return(new RaycastData() { Direction = raycastDataDirection, Distance = centerRaycastData.Distance }); }
public RaycastData GetCornersRaycastData() { RaycastData topRightRaycastData = GetCornerTopRightRaycastData(); RaycastData topLeftRaycastData = GetCornerTopLeftRaycastData(); RaycastData bottomRightRaycastData = GetCornerBottomRightRaycastData(); RaycastData bottomLeftRaycastData = GetCornerBottomLeftRaycastData(); Vector2 combinedCornerDirection = topRightRaycastData.Direction + topLeftRaycastData.Direction + bottomRightRaycastData.Direction + bottomLeftRaycastData.Direction; Vector2 raycastDataDirection = VectorHelper.Clamp(combinedCornerDirection, -1, 1); List <Vector2> distances = new List <Vector2>() { topRightRaycastData.Distance, topLeftRaycastData.Distance, bottomRightRaycastData.Distance, bottomLeftRaycastData.Distance, }; Vector2 raycastDataDistance = new Vector2(); foreach (Vector2 distance in distances) { if (distance.x != 0) { raycastDataDistance = new Vector2(distance.x, raycastDataDistance.y); } else if (distance.y != 0) { raycastDataDistance = new Vector2(raycastDataDistance.x, distance.y); } } return(new RaycastData() { Direction = raycastDataDirection, Distance = raycastDataDistance }); }
protected override void Execute() { Vector2 moveDirection; if (playerVelocityRef.Get().IsMovingStandard) { moveDirection = playerVelocityRef.Get().MoveDirection; } else { moveDirection = playerVelocityRef.Get().GetPreviousVelocityDirection(); } Vector2 collisionDirection = playerCollisionDirectionRef.Get().CollisionDirection; RaycastData combinedRaycastData = playerRaycastDirectionRef.Get().GetCombinedDirectionAndCenterDistances(); Vector2 surroundingsDirection = SurroundingDirectionHelper.GetSurroundingsDirection(collisionDirection, combinedRaycastData.Direction); playerMoveDirectionRef.Get().TurnToNextDirection(moveDirection, surroundingsDirection, collisionDirection, combinedRaycastData.Distance); }
/// <summary> /// Get the slope direction between the closest point to a surface and the hit point in the raycast direction. /// </summary> /// <param name="raycastData"></param> /// <param name="surfaceGradient"></param> /// <returns></returns> public static bool tryFindSurfaceGradient(ref RaycastData raycastData, out Vector3 surfaceGradient) { bool success = false; surfaceGradient = Vector3.zero; RaycastHit hit; if (Physics.Raycast(raycastData.sourceTransform.position, raycastData.direction, out hit, raycastData.checkDistance, raycastData.surfaceLayerMask)) { RaycastHit closestSurfacePointHit; if (Physics.Raycast(raycastData.sourceTransform.position, hit.normal * -1, out closestSurfacePointHit, raycastData.checkDistance, raycastData.surfaceLayerMask)) { //Vector3 hitDirection = hit.point - raycastData.sourceTransform.position; surfaceGradient = hit.point - closestSurfacePointHit.point; success = true; } } return(success); }
private IEnumerator OnShowExtra() { foreach (var data in ExtraRatios) { List <GroundController> org = new List <GroundController> (); org.Add(data.gc); recJobRatios [data.extraJob] += data.upRatio; for (int i = 0; i < recAllRatioData.Count; i++) { if (recAllRatioData [i].start.name == data.linkData.ElementAt(0).Key.name&& recAllRatioData [i].end.name == data.linkData.ElementAt(0).Value.name) { RaycastData raycastdata = new RaycastData(); raycastdata = recAllRatioData [i]; raycastdata.ratio += data.upRatio; recAllRatioData [i] = raycastdata; } } for (int i = 0; i < fightController.players.Length; i++) { if (fightController.GetJob("P", i) == data.extraJob) { GroundSEController gse = SEPool.Dequeue(); gse.SetExtraSE(org, playerButtonPos [i], i, data.upRatio); gse.onRecycle = RecycleExtraItem; gse.onExtraUp = ExtraRatioUp; SEingPool.Enqueue(gse); AddCanAttack(i); } } } unShowed = SEingPool.Count; while (SEingPool.Count > 0) { GroundSEController gse = SEingPool.Dequeue(); gse.gameObject.SetActive(true); gse.Run(); yield return(new WaitForSeconds(0.2f)); } }
private void HandleVerticalCollision(ref float2 movementDelta, float skinWidth, CollisionData collisionData, RaycastData raycastData) { float verticalDirection = math.sign(movementDelta.y); float raycastDistance = math.abs(movementDelta.y) + skinWidth; Vector2 raycastOrigin = (verticalDirection == 1) ? raycastData.TopLeft : raycastData.BottomLeft; RaycastHit2D hit; for (int i = 0; i < raycastData.VerticalRayCount; i++) { Vector2 ray = raycastOrigin + (Vector2.right * (raycastData.VerticalRaySpacing * i + movementDelta.x)); Debug.DrawRay(ray, Vector2.up * verticalDirection * raycastDistance, Color.red, 0.1f); hit = Physics2D.Raycast(ray, Vector2.up * verticalDirection, raycastDistance, collisionData.Mask); if (hit) { // ToDo one way playforms / moving platforms movementDelta.y = (hit.distance - skinWidth) * verticalDirection; raycastDistance = hit.distance; if (collisionData.ascendingSlope) { movementDelta.x = movementDelta.y / math.tan(math.radians(collisionData.slopeAngle)) * math.sign(movementDelta.x); } collisionData.Above = (verticalDirection == 1); collisionData.Below = (verticalDirection == -1); } } if (collisionData.ascendingSlope) { float horizontalDirection = math.sign(movementDelta.x); raycastDistance = math.abs(movementDelta.x) + skinWidth; Vector2 ray = ((horizontalDirection == 1) ? raycastData.BottomRight : raycastData.BottomLeft) + (Vector2.up * movementDelta.y); hit = Physics2D.Raycast(ray, Vector2.right * horizontalDirection, raycastDistance, collisionData.Mask); if (hit) { float slopeAngle = Vector2.Angle(hit.normal, Vector2.up); if (slopeAngle != collisionData.slopeAngle) { movementDelta.x = (hit.distance - skinWidth) * horizontalDirection; collisionData.slopeAngle = slopeAngle; } } } }
/// <summary> /// 向六方向射出射線進行偵測. /// </summary> /// <returns>The round.</returns> /// <param name="isPrev">是否還原狀態 <c>true</c> is previous.</param> /// <param name="isTouchUp">是否屏幕碰觸結束<c>true</c> is touch up.</param> /// <param name="isEnd">是否結束此回合<c>true</c> is end.</param> private List <RaycastData> RaycastRound(bool isPrev, bool isTouchUp, bool isEnd, bool isTest = false) { RaycastHit2D[] hits; List <RaycastData> dataList = new List <RaycastData>(); bool hasActived = false; for (int i = 0; i < 6; i++) { hits = transform.parent.GetComponent <GroundRaycastController>().GetRaycastHits(transform.position, new Vector2(Mathf.Sin(Mathf.Deg2Rad * (constAngle + constAngle + i * 60)), Mathf.Cos(Mathf.Deg2Rad * (constAngle + constAngle + i * 60))), 116f * 8); if (hits.Length == 0) { continue; } bool hitNone = false; bool hasOcclusion = false; List <RaycastHit2D> hitGcs = new List <RaycastHit2D>(); for (int j = 0; j < hits.Length; j++) { hitGcs.Add(hits[j]); if ((int)hits[j].transform.GetComponent <GroundController>()._groundType > 0 && (int)hits[j].transform.GetComponent <GroundController>()._groundType < 10) { hasOcclusion = true; } if ((int)hits[j].transform.GetComponent <GroundController>()._groundType == 0 || (int)hits[j].transform.GetComponent <GroundController>()._groundType == 99) { hitNone = true; } else if ((int)hits[j].transform.GetComponent <GroundController>()._groundType == 10) { if (hits[j].transform.GetComponent <GroundController>().charaJob != charaJob) { if (onProtection != null && !hasOcclusion) { onProtection.Invoke(hits[j].transform.GetComponent <GroundController>().charaJob); } } else { if (!hitNone) { if (isPrev) { OnPrevType(hitGcs.ToArray(), isEnd); } else { int ratio = CalculateRatio(hitGcs.ToArray(), charaJob, isTouchUp, isEnd, isTest); if (ratio > 0) { RaycastData data = new RaycastData(); data.start = GetComponent <GroundController>(); data.end = hits[j].transform.GetComponent <GroundController>(); data.ratio = ratio; data.hits = new List <GroundController>(); if (charaJob != 0) { data.CharaJob = charaJob; } for (int h = 0; h < hitGcs.Count - 1; h++) { data.hits.Add(hitGcs[h].collider.GetComponent <GroundController>()); } dataList.Add(data); hasActived = true; } if (j > 0) { if (hits[j].collider.GetComponent <GroundController>().isActived) { hasActived = true; } } } } else { } break; } } } } if (!isPrev) { OnRaycasted(hasActived, isTouchUp); } return(dataList); }
private void SetDependencies() { raycastData = raycastController.Data; physicsData = physicsController.Data; layerMaskData = layerMaskController.Data; }
private void HandleHorizontalCollisions(ref float2 movementDelta, float skinWidth, CollisionData collisionData, RaycastData raycastData) { float horizontalDirection = math.sign(movementDelta.x); float raycastDistance = math.max(math.abs(movementDelta.x) + skinWidth, 2 * skinWidth); Vector2 raycastOrigin = (horizontalDirection == 1) ? raycastData.BottomRight : raycastData.BottomLeft; for (int i = 0; i < raycastData.HorizontalRayCount; i++) { Vector2 ray = raycastOrigin + (Vector2.up * (raycastData.HorizontalRaySpacing * i)); Debug.DrawRay(ray, Vector2.right * horizontalDirection * raycastDistance, Color.red, 0.1f); RaycastHit2D hit = Physics2D.Raycast(ray, Vector2.right * horizontalDirection, raycastDistance, collisionData.Mask); if (hit) { if (hit.distance == 0) { continue; } float slopeAngle = Vector2.Angle(hit.normal, Vector2.up); if (i == 0 && slopeAngle <= collisionData.MaxSlopeAngle) { if (collisionData.decendingSlope) { collisionData.decendingSlope = false; } float distanceToSlope = 0; if (slopeAngle != collisionData.previousSlopeAngle) { distanceToSlope = hit.distance - skinWidth; movementDelta.x -= distanceToSlope * horizontalDirection; } HandleSlopeAscend(ref movementDelta, slopeAngle, collisionData); movementDelta.x += distanceToSlope * horizontalDirection; } if (!collisionData.ascendingSlope || slopeAngle > collisionData.MaxSlopeAngle) { movementDelta.x = (hit.distance - skinWidth) * horizontalDirection; raycastDistance = hit.distance; if (collisionData.ascendingSlope) { movementDelta.y = math.tan(math.radians(collisionData.slopeAngle)) * math.abs(movementDelta.x); } collisionData.Right = (horizontalDirection == 1); collisionData.Left = (horizontalDirection == -1); } } } }
protected virtual void DrawMesh() { if (!ShouldDrawMesh) { return; } int steps = Mathf.RoundToInt(MeshDensity * VisionAngle); float stepsAngle = VisionAngle / steps; _viewPoints.Clear(); for (int i = 0; i <= steps; i++) { float angle = stepsAngle * i + EulerAngles.y - VisionAngle / 2f; _viewCast = RaycastAtAngle(angle); if (i > 0) { bool thresholdExceeded = Mathf.Abs(_oldViewCast.Distance - _viewCast.Distance) > EdgeThreshold; if ((_oldViewCast.Hit != _viewCast.Hit) || (_oldViewCast.Hit && _viewCast.Hit && thresholdExceeded)) { MeshEdgePosition edge = FindMeshEdgePosition(_oldViewCast, _viewCast); if (edge.PointA != Vector3.zero) { _viewPoints.Add(edge.PointA); } if (edge.PointB != Vector3.zero) { _viewPoints.Add(edge.PointB); } } } _viewPoints.Add(_viewCast.Point); _oldViewCast = _viewCast; } int numberOfVertices = _viewPoints.Count + 1; if (numberOfVertices != _numberOfVerticesLastTime) { Array.Resize(ref _vertices, numberOfVertices); Array.Resize(ref _triangles, (numberOfVertices - 2) * 3); } _vertices[0].x = 0; _vertices[0].y = 0; _vertices[0].z = 0; for (int i = 0; i < numberOfVertices - 1; i++) { _vertices[i + 1] = this.transform.InverseTransformPoint(_viewPoints[i]); if (i < numberOfVertices - 2) { _triangles[i * 3] = 0; _triangles[i * 3 + 1] = i + 1; _triangles[i * 3 + 2] = i + 2; } } _visionMesh.Clear(); _visionMesh.vertices = _vertices; _visionMesh.triangles = _triangles; _visionMesh.RecalculateNormals(); _numberOfVerticesLastTime = numberOfVertices; }
public void setRaycastData(RaycastData raycastData) { m_raycastData = raycastData; }
private List <MaskMeshData> RayCast(MaskMeshData.TYPE _type) { LayerMask mask; switch (_type) { case MaskMeshData.TYPE.FULL: mask = m_fullCoverLayerMask; break; case MaskMeshData.TYPE.SEMI: mask = m_semiCoverLayerMask; break; default: throw new ArgumentOutOfRangeException(nameof(_type), _type, null); } var meshDataCollection = new List <MaskMeshData>(); var currentMeshData = new MaskMeshData(_type); var step = m_lineOfSight.m_amplitudeOfSightInDegrees / (m_lineOfSight.m_numberOfRaycast - 1); for (var i = 0; i < m_lineOfSight.m_numberOfRaycast; i++) { var angle = (-m_lineOfSight.m_amplitudeOfSightInDegrees * .5f) + (i * step); var rayCastDirection = Quaternion.Euler(0, angle, 0) * transform.forward; var ray = new UnityEngine.Ray(transform.position, rayCastDirection); var currentRayCastResult = new RaycastData() { m_angle = angle, m_direction = rayCastDirection }; if (!Physics.Raycast(ray, out var hit, m_lineOfSight.m_maxDistance, mask)) { currentRayCastResult.m_hit = false; currentRayCastResult.m_start = transform.position; currentRayCastResult.m_end = ray.GetPoint(m_lineOfSight.m_maxDistance); if (m_previousRaycastData.m_hit) { if (currentMeshData.m_datas.Count > 0) { meshDataCollection.Add(currentMeshData); } } m_previousRaycastData = currentRayCastResult; continue; } currentRayCastResult.m_hit = true; currentRayCastResult.m_start = hit.point; currentRayCastResult.m_end = ray.GetPoint(m_lineOfSight.m_maxDistance); if (m_previousRaycastData.m_hit) { currentMeshData.m_datas.Add(currentRayCastResult); if (i == m_lineOfSight.m_numberOfRaycast - 1) { if (currentMeshData.m_datas.Count > 0) { meshDataCollection.Add(currentMeshData); } } } else { currentMeshData = new MaskMeshData(_type); currentMeshData.m_datas.Add(currentRayCastResult); if (i > 0) { FindEdge(); } } m_previousRaycastData = currentRayCastResult; } return(meshDataCollection); }
//private NativeArray<RaycastHit> m_result; // Start is called before the first frame update void Start() { m_previousRaycastData = new RaycastData(); m_meshDataCollection = new List <MaskMeshData>(); }
private void AddRaycastResult(RaycastData _data) { m_currentMeshData.m_datas.Add(_data); }
private void Dependencies() { raycastData = GetComponent <RaycastController>().Data; platformerData = GetComponent <PlatformerController>().Data; }
private void HandleSlopeDecend(ref float2 movementDelta, float skinWidth, CollisionData collisionData, RaycastData raycastData) { float horizontalDirection = math.sign(movementDelta.x); Vector2 raycastOrigin = (horizontalDirection == 1) ? raycastData.BottomLeft : raycastData.BottomRight; RaycastHit2D hit = Physics2D.Raycast(raycastOrigin, Vector2.down, Mathf.Infinity, collisionData.Mask); if (hit) { float slopeAngle = Vector2.Angle(hit.normal, Vector2.up); float radianSlopeAngle = math.radians(slopeAngle); if (slopeAngle != 0 && slopeAngle <= collisionData.MaxSlopeAngle) { if (math.sign(hit.normal.x) == horizontalDirection) { float moveDistance = math.abs(movementDelta.x); if (hit.distance - skinWidth <= math.tan(radianSlopeAngle) * moveDistance) { movementDelta.x = math.cos(radianSlopeAngle) * moveDistance * horizontalDirection; movementDelta.y -= math.sin(radianSlopeAngle) * moveDistance; collisionData.slopeAngle = slopeAngle; collisionData.decendingSlope = true; collisionData.Below = true; } } } } }
public static bool Raycast(Vector3 origin, Vector3 direction, out RaycastHit raycastHit, RaycastData raycastData) => Physics.Raycast( origin: origin, direction: direction, hitInfo: out raycastHit, maxDistance: raycastData._MaxDistance, layerMask: raycastData._LayerMask, queryTriggerInteraction: raycastData._QueryTriggerInteraction );
private RaycastData GetCornerTopRightRaycastData() { RaycastData topRightCornerRaycastData = GetDominantCornerAxis(topRightCornerPoint.position, rightDownDirection, leftUpDirection, cornerRayLength); return(topRightCornerRaycastData); }