root
/
Net.Like.Xue.Tokyo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Net.Like.Xue.Tokyo/Assets/Plugins/Draw XXL/scripts/internal utilities/UtilitiesDXXL_Physics2D.cs

1816 lines
135 KiB
C#
Raw Blame History

namespace DrawXXL
{
using UnityEngine;
using System.Collections.Generic;
public class UtilitiesDXXL_Physics2D
{
public static RaycastHit2D[] preallocatedRayHit2DResultsArray_copiedFromList = new RaycastHit2D[DrawPhysics2D.MaxNumberOfPreallocatedHits];
public static Collider2D[] preallocatedCollider2DResultsArray_copiedFromList = new Collider2D[DrawPhysics2D.MaxNumberOfPreallocatedHits];
public static void DrawRaycastTillFirstHit(bool hasHit, Vector2 originV2, Vector2 directionV2, float maxDistance, RaycastHit2D hitInfo2D, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.ApproximatelyZero(directionV2))
{
UtilitiesDXXL_DrawBasics2D.PointFallback(originV2, GetZPosForDrawVisualisation(), "[<color=#adadadFF><icon=logMessage></color> DrawRaycast2D with direction of zero]<br>" + nameText, DrawPhysics2D.colorForNonHittingCasts, 0.0f, durationInSec, hiddenByNearerObjects);
return;
}
float distanceOfFarestHit = GetDistanceOfSingleHit(hasHit, hitInfo2D);
DrawRayOfRaycast(hasHit ? 1 : 0, originV2, directionV2, maxDistance, nameText, distanceOfFarestHit, durationInSec, hiddenByNearerObjects);
if (hasHit)
{
DrawRaycastHitInfo(hitInfo2D, 0, nameText, durationInSec, hiddenByNearerObjects);
}
}
public static void DrawRaycastPotMultipleHits(Vector2 originV2, Vector2 directionV2, float maxDistance, RaycastHit2D[] hitInfos2D, int numberOfUsedSlotsInHitInfoArray, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.ApproximatelyZero(directionV2))
{
UtilitiesDXXL_DrawBasics2D.PointFallback(originV2, GetZPosForDrawVisualisation(), "[<color=#adadadFF><icon=logMessage></color> DrawRaycast2D with direction of zero]<br>" + nameText, DrawPhysics2D.colorForNonHittingCasts, 0.0f, durationInSec, hiddenByNearerObjects);
return;
}
float distanceOfFarestHit = GetDistanceOfFarestHit(hitInfos2D, numberOfUsedSlotsInHitInfoArray);
DrawRayOfRaycast(numberOfUsedSlotsInHitInfoArray, originV2, directionV2, maxDistance, nameText, distanceOfFarestHit, durationInSec, hiddenByNearerObjects);
for (int i = 0; i < numberOfUsedSlotsInHitInfoArray; i++)
{
DrawRaycastHitInfo(hitInfos2D[i], i, nameText, durationInSec, hiddenByNearerObjects);
}
}
static void DrawRayOfRaycast(int hitCount, Vector2 originV2, Vector2 directionV2, float maxDistance, string nameText, float distanceOfFarestHit, float durationInSec, bool hiddenByNearerObjects)
{
bool hasHit = hitCount > 0;
Color color = hasHit ? DrawPhysics2D.colorForHittingCasts : DrawPhysics2D.colorForNonHittingCasts;
Vector3 direction_normalized = UtilitiesDXXL_Math.GetNormalized_afterScalingIntoRegionOfFloatPrecicion(new Vector3(directionV2.x, directionV2.y, 0.0f));
bool hasUnlimitedLength = float.IsInfinity(maxDistance);
float absMaxDistance = Mathf.Abs(maxDistance);
float lengthOfRayDirIndicator = Mathf.Min(1.0f, 0.9f * absMaxDistance);
maxDistance = Mathf.Min(maxDistance, 100000.0f);
maxDistance = Mathf.Max(maxDistance, -100000.0f);
Vector3 origin = new Vector3(originV2.x, originV2.y, GetZPosForDrawVisualisation());
Vector3 endPos = origin + direction_normalized * maxDistance;
Line_fadeableAnimSpeed.InternalDraw(origin, endPos, color, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, 0.0f, null, default, false, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
//at origin:
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
float width_ofBase = 0.1f * lengthOfRayDirIndicator;
DrawShapes.Pyramid(origin, lengthOfRayDirIndicator, 0.0f, width_ofBase, color, direction_normalized, Vector3.up, DrawShapes.Shape2DType.square, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, false, durationInSec, hiddenByNearerObjects);
}
else
{
string rayText = GetRayText(nameText, hitCount, maxDistance, "<size=27>Raycast 2D</size><br><size=5> </size><br>number of hits: ");
DrawEngineBasics.RayLineExtended2D(origin, direction_normalized * lengthOfRayDirIndicator, color, 0.0f, rayText, GetZPosForDrawVisualisation(), 0.0f, false, 0.01f, 0.0f, durationInSec, hiddenByNearerObjects);
}
//overdraw line after last hit:
if (hasHit)
{
if (maxDistance < 0.0f)
{
//unity.RaycastHit2D always returns positve values for "distance", also if the cast goes backward due to negative "maxDistance"
distanceOfFarestHit = -distanceOfFarestHit;
}
Line_fadeableAnimSpeed.InternalDraw(origin + direction_normalized * distanceOfFarestHit, endPos, DrawPhysics2D.colorForCastLineBeyondHit, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, 0.0f, null, default, false, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
}
//end cap:
if (hasUnlimitedLength == false)
{
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
DrawShapes.Decagon(endPos, 0.025f, hasHit ? DrawPhysics2D.colorForCastLineBeyondHit : DrawPhysics2D.colorForNonHittingCasts, direction_normalized, default, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.invisible, false, false, durationInSec, hiddenByNearerObjects);
}
}
}
static void DrawRaycastHitInfo(RaycastHit2D hitInfo2D, int i_hit, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.VectorIsInvalid(hitInfo2D.point) || UtilitiesDXXL_Math.VectorIsInvalid(hitInfo2D.normal))
{
Debug.LogError("Draw XXL: A 'Physics2D.RayCast()' returned an invalid hit position (namely " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + ") or normal (namely " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.normal) + "). The drawn cast visualization may be incorrect.");
}
else
{
bool saveDrawnLines = i_hit >= DrawPhysics2D.hitResultsWithMoreDetailedDisplay;
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.high_withFullDetails) { saveDrawnLines = true; }
Vector3 impactPos_v3 = UtilitiesDXXL_DrawBasics2D.Position_V2toV3(hitInfo2D.point, hitInfo2D.transform.position.z);
//dashed connection line along z:
if (UtilitiesDXXL_Math.CheckIf_twoFloatsAreApproximatelyEqual(hitInfo2D.transform.position.z, GetZPosForDrawVisualisation()) == false)
{
float absZDistance = Mathf.Abs(hitInfo2D.transform.position.z - GetZPosForDrawVisualisation());
Vector3 impactPos_projectedOntoDrawVisualisation_V3 = UtilitiesDXXL_DrawBasics2D.Position_V2toV3(hitInfo2D.point, GetZPosForDrawVisualisation());
Color color_forDashedLineAlongZ = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(DrawPhysics2D.colorForHittingCasts, 0.6f);
DrawBasics.LineStyle lineStyleAlongZ = (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes) ? DrawBasics.LineStyle.solid : DrawBasics.LineStyle.dashedLong;
Line_fadeableAnimSpeed.InternalDraw(impactPos_v3, impactPos_projectedOntoDrawVisualisation_V3, color_forDashedLineAlongZ, 0.0f, null, lineStyleAlongZ, absZDistance, 0.0f, null, default, false, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
}
//Normal:
Vector3 normal_V3 = UtilitiesDXXL_DrawBasics2D.Direction_V2toV3(hitInfo2D.normal);
Color color_ofNormal = Get_color_ofNormal();
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
DrawBasics2D.LineFrom(impactPos_v3, normal_V3, color_ofNormal, 0.0f, null, DrawBasics.LineStyle.solid, hitInfo2D.transform.position.z, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
}
else
{
float relConeLength_ofNormalVector = 0.17f;
string normalText = (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes) ? null : (saveDrawnLines ? "normal" : "normal<br><size=4>of hit surface</size>");
UtilitiesDXXL_DrawBasics.Set_coneLength_interpretation_forStraightVectors_reversible(DrawBasics.LengthInterpretation.relativeToLineLength);
DrawBasics2D.VectorFrom(impactPos_v3, normal_V3, color_ofNormal, saveDrawnLines ? 0.0f : 0.006f, normalText, relConeLength_ofNormalVector, false, hitInfo2D.transform.position.z, false, 0.0f, false, 0.0f, durationInSec, hiddenByNearerObjects);
UtilitiesDXXL_DrawBasics.Reverse_coneLength_interpretation_forStraightVectors();
}
//Normal Socket and Text Description:
switch (DrawPhysics2D.visualizationQuality)
{
case DrawPhysics.VisualizationQuality.high_withFullDetails:
DrawNormalSocketAndText_highQuality(impactPos_v3, normal_V3, color_ofNormal, hitInfo2D, i_hit, nameText, saveDrawnLines, durationInSec, hiddenByNearerObjects);
break;
case DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes:
DrawNormalSocketAndText_mediumQuality(impactPos_v3, normal_V3, color_ofNormal, nameText, durationInSec, hiddenByNearerObjects);
break;
case DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes:
//normal socket:
DrawShapes.Square(impactPos_v3, 0.12f, color_ofNormal, normal_V3, default, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.invisible, false, false, durationInSec, hiddenByNearerObjects);
break;
default:
break;
}
}
}
static void DrawNormalSocketAndText_highQuality(Vector3 impactPos_v3, Vector3 normal_V3, Color color_ofNormal, RaycastHit2D hitInfo2D, int i_hit, string nameText, bool saveDrawnLines, float durationInSec, bool hiddenByNearerObjects)
{
//normal socket:
DrawShapes.Decagon(impactPos_v3, 0.03f, color_ofNormal, normal_V3, default, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.invisible, false, false, durationInSec, hiddenByNearerObjects);
//text description:
float textOffsetDistance = DrawPhysics2D.scaleFactor_forCastHitTextSize;
string text;
if (DrawPhysics2D.drawCastNameTag_atHitPositions && nameText != null && nameText.Length != 0)
{
text = (saveDrawnLines ? (nameText + " / #" + i_hit + ":<br>hit GO: " + hitInfo2D.transform.gameObject.name + "<br>pos = " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + "<br>dist = " + hitInfo2D.distance) : (UtilitiesDXXL_Physics.GetStrokeWidthMarkupStartStringForHitPosDesctiptionHeaders(nameText) + nameText + " / hit #" + i_hit + ":</sw><br>GameObject that was hit: " + hitInfo2D.transform.gameObject.name + "<br>position = " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + "<br>distance = " + hitInfo2D.distance));
}
else
{
text = (saveDrawnLines ? ("hit #" + i_hit + ":<br>hit GO: " + hitInfo2D.transform.gameObject.name + "<br>pos = " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + "<br>dist = " + hitInfo2D.distance) : ("<sw=80000>Raycast2D hit #" + i_hit + ":</sw><br>GameObject that was hit: " + hitInfo2D.transform.gameObject.name + "<br>position = " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + "<br>distance = " + hitInfo2D.distance));
}
TrySet_default_textOffsetDirection_forPointTags_reversible();
DrawBasics2D.PointTag(hitInfo2D.point, text, DrawPhysics2D.colorForCastsHitText, 0.0f, textOffsetDistance, default(Vector2), hitInfo2D.transform.position.z, 1.0f, false, durationInSec, hiddenByNearerObjects);
TryReverse_default_textOffsetDirection_forPointTags();
}
static void DrawNormalSocketAndText_mediumQuality(Vector3 impactPos_v3, Vector3 normal_V3, Color color_ofNormal, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
//normal socket:
DrawShapes.Decagon(impactPos_v3, 0.03f, color_ofNormal, normal_V3, default, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.invisible, false, false, durationInSec, hiddenByNearerObjects);
//text description:
if (DrawPhysics2D.drawCastNameTag_atHitPositions && nameText != null && nameText.Length != 0)
{
UtilitiesDXXL_Text.Write(nameText, impactPos_v3, DrawPhysics2D.colorForCastsHitText, 0.1f * DrawPhysics2D.scaleFactor_forCastHitTextSize, Vector3.right, Vector3.up, DrawText.TextAnchorDXXL.LowerLeftOfFirstLine, DrawBasics.LineStyle.invisible, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, true, durationInSec, hiddenByNearerObjects, false, false, true);
}
}
public static void DrawRaycast3DTillFirstHit(bool hasHit, Ray ray, float maxDistance, RaycastHit2D hitInfo2D, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.ApproximatelyZero(ray.direction))
{
UtilitiesDXXL_DrawBasics.PointFallback(ray.origin, "[<color=#adadadFF><icon=logMessage></color> DrawRay3D against 2D colliders with direction of zero]<br>" + nameText, DrawPhysics2D.colorForNonHittingCasts, 0.0f, durationInSec, hiddenByNearerObjects);
return;
}
float distanceOfFarestHit = GetDistanceOfSingleHit(hasHit, hitInfo2D);
DrawRayOfRaycast3D(hasHit ? 1 : 0, ray, maxDistance, nameText, distanceOfFarestHit, durationInSec, hiddenByNearerObjects);
if (hasHit)
{
DrawRaycast3DHitInfo(hitInfo2D, 0, nameText, durationInSec, hiddenByNearerObjects);
}
}
public static void DrawRaycast3DPotMultipleHits(Ray ray, float maxDistance, RaycastHit2D[] hitInfos2D, int numberOfUsedSlotsInHitInfoArray, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.ApproximatelyZero(ray.direction))
{
UtilitiesDXXL_DrawBasics.PointFallback(ray.origin, "[<color=#adadadFF><icon=logMessage></color> DrawRay3D against 2D colliders with direction of zero]<br>" + nameText, DrawPhysics2D.colorForNonHittingCasts, 0.0f, durationInSec, hiddenByNearerObjects);
return;
}
float distanceOfFarestHit = GetDistanceOfFarestHit(hitInfos2D, numberOfUsedSlotsInHitInfoArray);
DrawRayOfRaycast3D(numberOfUsedSlotsInHitInfoArray, ray, maxDistance, nameText, distanceOfFarestHit, durationInSec, hiddenByNearerObjects);
for (int i = 0; i < numberOfUsedSlotsInHitInfoArray; i++)
{
DrawRaycast3DHitInfo(hitInfos2D[i], i, nameText, durationInSec, hiddenByNearerObjects);
}
}
static void DrawRayOfRaycast3D(int hitCount, Ray ray, float maxDistance, string nameText, float distanceOfFarestHit, float durationInSec, bool hiddenByNearerObjects)
{
bool hasHit = hitCount > 0;
Color color = hasHit ? DrawPhysics2D.colorForHittingCasts : DrawPhysics2D.colorForNonHittingCasts;
Vector3 direction_normalized = UtilitiesDXXL_Math.GetNormalized_afterScalingIntoRegionOfFloatPrecicion(ray.direction);
bool hasUnlimitedLength = float.IsInfinity(maxDistance);
float absMaxDistance = Mathf.Abs(maxDistance);
float lengthOfRayDirIndicator = Mathf.Min(1.0f, 0.9f * absMaxDistance);
maxDistance = Mathf.Min(maxDistance, 100000.0f);
maxDistance = Mathf.Max(maxDistance, -100000.0f);
Vector3 endPos = ray.origin + direction_normalized * maxDistance;
Line_fadeableAnimSpeed.InternalDraw(ray.origin, endPos, color, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, 0.0f, null, default, false, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
//at origin:
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
float width_ofBase = 0.1f * lengthOfRayDirIndicator;
DrawShapes.Pyramid(ray.origin, lengthOfRayDirIndicator, width_ofBase, width_ofBase, color, direction_normalized, Vector3.up, DrawShapes.Shape2DType.square, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, false, durationInSec, hiddenByNearerObjects);
}
else
{
string rayText = GetRayText(nameText, hitCount, maxDistance, "<size=27>Ray3D against<br>2D colliders</size><br><size=5> </size><br>number of hits: ");
DrawEngineBasics.RayLineExtended(ray.origin, direction_normalized * lengthOfRayDirIndicator, color, 0.0f, rayText, 0.0f, false, 0.01f, 0.0f, durationInSec, hiddenByNearerObjects);
}
//overdraw line after last hit:
if (hasHit)
{
if (maxDistance < 0.0f)
{
//unity.RaycastHit2D always returns positve values for "distance", also if the cast goes backward due to negative "maxDistance"
distanceOfFarestHit = -distanceOfFarestHit;
}
Line_fadeableAnimSpeed.InternalDraw(ray.origin + direction_normalized * distanceOfFarestHit, endPos, DrawPhysics2D.colorForCastLineBeyondHit, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, 0.0f, null, default, false, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
}
//end cap:
if (hasUnlimitedLength == false)
{
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
DrawShapes.Decagon(endPos, 0.025f, hasHit ? DrawPhysics2D.colorForCastLineBeyondHit : DrawPhysics2D.colorForNonHittingCasts, direction_normalized, default, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.invisible, false, false, durationInSec, hiddenByNearerObjects);
}
}
}
static string GetRayText(string nameText, int hitCount, float maxDistance, string fallbackTextFragment_forNoSpecifiedName)
{
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
return null;
}
else
{
string rayText;
if (DrawPhysics2D.drawCastNameTag_atCastOrigin && nameText != null && nameText.Length != 0)
{
rayText = (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes) ? UtilitiesDXXL_Physics.GetSizeMarkupStartStringForCastNames(nameText) + nameText + "</size><br><size=5> </size><br>hits: " + hitCount : UtilitiesDXXL_Physics.GetSizeMarkupStartStringForCastNames(nameText) + nameText + "</size><br><size=5> </size><br>number of hits: " + hitCount;
}
else
{
rayText = (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes) ? "hits: " + hitCount : fallbackTextFragment_forNoSpecifiedName + hitCount;
}
if (maxDistance < 0.0f)
{
rayText = "[<color=#e2aa00FF><icon=warning></color> negative ray direction]<br>" + rayText;
}
return rayText;
}
}
static void DrawRaycast3DHitInfo(RaycastHit2D hitInfo2D, int i_hit, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.VectorIsInvalid(hitInfo2D.point))
{
Debug.LogError("Draw XXL: A 'Physics2D.Cast()' returned an invalid hit position (namely " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + "). The drawn cast visualization may be incorrect.");
}
else
{
bool saveDrawnLines = i_hit >= DrawPhysics2D.hitResultsWithMoreDetailedDisplay;
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.high_withFullDetails) { saveDrawnLines = true; }
Vector3 impactPos_v3 = UtilitiesDXXL_DrawBasics2D.Position_V2toV3(hitInfo2D.point, hitInfo2D.transform.position.z);
Color color_ofImpactPosCircle = (DrawPhysics2D.colorForHittingCasts.grayscale < 0.175f) ? Color.Lerp(DrawPhysics2D.colorForHittingCasts, Color.white, 0.7f) : Color.Lerp(DrawPhysics2D.colorForHittingCasts, Color.black, 0.7f);
switch (DrawPhysics2D.visualizationQuality)
{
case DrawPhysics.VisualizationQuality.high_withFullDetails:
DrawNormalSocketAndText_forRaycast3D_highQuality(hitInfo2D, i_hit, nameText, impactPos_v3, color_ofImpactPosCircle, saveDrawnLines, durationInSec, hiddenByNearerObjects);
break;
case DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes:
DrawNormalSocketAndText_forRaycast3D_mediumQuality(nameText, impactPos_v3, color_ofImpactPosCircle, durationInSec, hiddenByNearerObjects);
break;
case DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes:
DrawShapes.Square(impactPos_v3, 0.03f, color_ofImpactPosCircle, Vector3.forward, default, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.invisible, false, false, durationInSec, hiddenByNearerObjects);
break;
default:
break;
}
}
}
static void DrawNormalSocketAndText_forRaycast3D_highQuality(RaycastHit2D hitInfo2D, int i_hit, string nameText, Vector3 impactPos_v3, Color color_ofImpactPosCircle, bool saveDrawnLines, float durationInSec, bool hiddenByNearerObjects)
{
DrawShapes.Decagon(impactPos_v3, 0.03f, color_ofImpactPosCircle, Vector3.forward, default, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.invisible, false, false, durationInSec, hiddenByNearerObjects);
//text description:
float textOffsetDistance = DrawPhysics2D.scaleFactor_forCastHitTextSize;
string text;
if (DrawPhysics2D.drawCastNameTag_atHitPositions && nameText != null && nameText.Length != 0)
{
text = (saveDrawnLines ? (nameText + " / #" + i_hit + ":<br>hit GO: " + hitInfo2D.transform.gameObject.name + "<br>pos = " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + "<br>dist = " + hitInfo2D.distance) : (UtilitiesDXXL_Physics.GetStrokeWidthMarkupStartStringForHitPosDesctiptionHeaders(nameText) + nameText + " / hit #" + i_hit + ":</sw><br>GameObject that was hit: " + hitInfo2D.transform.gameObject.name + "<br>position = " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + "<br>distance = " + hitInfo2D.distance));
}
else
{
text = (saveDrawnLines ? ("hit #" + i_hit + ":<br>hit GO: " + hitInfo2D.transform.gameObject.name + "<br>pos = " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + "<br>dist = " + hitInfo2D.distance) : ("<sw=80000>Ray3D against 2D colliders / hit #" + i_hit + ":</sw><br>GameObject that was hit: " + hitInfo2D.transform.gameObject.name + "<br>position = " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + "<br>distance = " + hitInfo2D.distance));
}
TrySet_default_textOffsetDirection_forPointTags_reversible();
DrawBasics2D.PointTag(hitInfo2D.point, text, DrawPhysics2D.colorForCastsHitText, 0.0f, textOffsetDistance, default(Vector2), hitInfo2D.transform.position.z, 1.0f, false, durationInSec, hiddenByNearerObjects);
TryReverse_default_textOffsetDirection_forPointTags();
}
static void DrawNormalSocketAndText_forRaycast3D_mediumQuality(string nameText, Vector3 impactPos_v3, Color color_ofImpactPosCircle, float durationInSec, bool hiddenByNearerObjects)
{
DrawShapes.Decagon(impactPos_v3, 0.03f, color_ofImpactPosCircle, Vector3.forward, default, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.invisible, false, false, durationInSec, hiddenByNearerObjects);
//text description:
if (DrawPhysics2D.drawCastNameTag_atHitPositions && nameText != null && nameText.Length != 0)
{
UtilitiesDXXL_Text.Write(nameText, impactPos_v3, DrawPhysics2D.colorForCastsHitText, 0.1f * DrawPhysics2D.scaleFactor_forCastHitTextSize, Vector3.right, Vector3.up, DrawText.TextAnchorDXXL.LowerLeftOfFirstLine, DrawBasics.LineStyle.invisible, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, true, durationInSec, hiddenByNearerObjects, false, false, true);
}
}
public static void DrawCirclecastTillFirstHit(float circleRadius, bool hasHit, Vector2 origin_V2, Vector2 direction_V2, float maxDistance, RaycastHit2D hitInfo2D, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.ApproximatelyZero(direction_V2))
{
UtilitiesDXXL_DrawBasics2D.PointFallback(origin_V2, GetZPosForDrawVisualisation(), "[<color=#adadadFF><icon=logMessage></color> DrawCircleCast2D with direction of zero]<br>" + nameText, DrawPhysics2D.colorForNonHittingCasts, 0.0f, durationInSec, hiddenByNearerObjects);
return;
}
bool radiusIsZero = UtilitiesDXXL_Math.ApproximatelyZero(circleRadius);
bool circleRadiusTooSmall = circleRadius < 0.00011f; //Unity returns no hits, if a radius is equal or smaller than "0.0001f"
circleRadius = Mathf.Abs(circleRadius);
float distanceOfFarestHit = GetDistanceOfSingleHit(hasHit, hitInfo2D);
DrawRayOfCirclecast(circleRadius, circleRadiusTooSmall, radiusIsZero, hasHit ? 1 : 0, origin_V2, direction_V2, maxDistance, nameText, distanceOfFarestHit, durationInSec, hiddenByNearerObjects);
if (hasHit)
{
DrawCirclecastHitInfo(circleRadius, hitInfo2D, 0, nameText, durationInSec, hiddenByNearerObjects);
}
}
public static void DrawCirclecastPotMultipleHits(float circleRadius, Vector2 origin_V2, Vector2 direction_V2, float maxDistance, RaycastHit2D[] hitInfos2D, int numberOfUsedSlotsInHitInfoArray, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.ApproximatelyZero(direction_V2))
{
UtilitiesDXXL_DrawBasics2D.PointFallback(origin_V2, GetZPosForDrawVisualisation(), "[<color=#adadadFF><icon=logMessage></color> DrawCircleCast2D with direction of zero]<br>" + nameText, DrawPhysics2D.colorForNonHittingCasts, 0.0f, durationInSec, hiddenByNearerObjects);
return;
}
bool radiusIsZero = UtilitiesDXXL_Math.ApproximatelyZero(circleRadius);
bool circleRadiusTooSmall = circleRadius < 0.00011f; //Unity returns no hits, if a radius is equal or smaller than "0.0001f"
circleRadius = Mathf.Abs(circleRadius);
float distanceOfFarestHit = GetDistanceOfFarestHit(hitInfos2D, numberOfUsedSlotsInHitInfoArray);
DrawRayOfCirclecast(circleRadius, circleRadiusTooSmall, radiusIsZero, numberOfUsedSlotsInHitInfoArray, origin_V2, direction_V2, maxDistance, nameText, distanceOfFarestHit, durationInSec, hiddenByNearerObjects);
for (int i = 0; i < numberOfUsedSlotsInHitInfoArray; i++)
{
DrawCirclecastHitInfo(circleRadius, hitInfos2D[i], i, nameText, durationInSec, hiddenByNearerObjects);
}
}
public static void DrawBoxcastTillFirstHit(bool hasHit, Vector2 origin_V2, Vector2 size_V2, float angleDegCC, Vector2 direction_V2, float maxDistance, RaycastHit2D hitInfo2D, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.ApproximatelyZero(direction_V2))
{
UtilitiesDXXL_DrawBasics2D.PointFallback(origin_V2, GetZPosForDrawVisualisation(), "[<color=#adadadFF><icon=logMessage></color> DrawBoxcast2D with direction of zero]<br>" + nameText, DrawPhysics2D.colorForNonHittingCasts, 0.0f, durationInSec, hiddenByNearerObjects);
return;
}
bool atLeastOneBoxDimIsSmallerThan0d00011 = (size_V2.x < 0.00011f) || (size_V2.y < 0.00011f); //Unity returns no hits, if a box dimension is equal or smaller than "0.0001f"
float distanceOfFarestHit = GetDistanceOfSingleHit(hasHit, hitInfo2D);
DrawRayOfBoxcast(hasHit ? 1 : 0, origin_V2, size_V2, angleDegCC, atLeastOneBoxDimIsSmallerThan0d00011, direction_V2, maxDistance, nameText, distanceOfFarestHit, durationInSec, hiddenByNearerObjects);
if (hasHit)
{
DrawBoxcastHitInfo(size_V2, angleDegCC, hitInfo2D, 0, nameText, durationInSec, hiddenByNearerObjects);
}
}
public static void DrawBoxcastPotMultipleHits(Vector2 origin_V2, Vector2 size_V2, float angleDegCC, Vector2 direction_V2, float maxDistance, RaycastHit2D[] hitInfos2D, int numberOfUsedSlotsInHitInfoArray, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.ApproximatelyZero(direction_V2))
{
UtilitiesDXXL_DrawBasics2D.PointFallback(origin_V2, GetZPosForDrawVisualisation(), "[<color=#adadadFF><icon=logMessage></color> DrawBoxcast2D with direction of zero]<br>" + nameText, DrawPhysics2D.colorForNonHittingCasts, 0.0f, durationInSec, hiddenByNearerObjects);
return;
}
bool atLeastOneBoxDimIsSmallerThan0d00011 = (size_V2.x < 0.00011f) || (size_V2.y < 0.00011f); //Unity returns no hits, if a box dimension is equal or smaller than "0.0001f"
float distanceOfFarestHit = GetDistanceOfFarestHit(hitInfos2D, numberOfUsedSlotsInHitInfoArray);
DrawRayOfBoxcast(numberOfUsedSlotsInHitInfoArray, origin_V2, size_V2, angleDegCC, atLeastOneBoxDimIsSmallerThan0d00011, direction_V2, maxDistance, nameText, distanceOfFarestHit, durationInSec, hiddenByNearerObjects);
for (int i = 0; i < numberOfUsedSlotsInHitInfoArray; i++)
{
DrawBoxcastHitInfo(size_V2, angleDegCC, hitInfos2D[i], i, nameText, durationInSec, hiddenByNearerObjects);
}
}
public static void DrawCapsulecastTillFirstHit(bool hasHit, Vector2 origin_V2, Vector2 size_V2, Vector2 direction_V2, CapsuleDirection2D capsuleDirection, float angleDegCC, float maxDistance, RaycastHit2D hitInfo2D, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.ApproximatelyZero(direction_V2))
{
UtilitiesDXXL_DrawBasics2D.PointFallback(origin_V2, GetZPosForDrawVisualisation(), "[<color=#adadadFF><icon=logMessage></color> DrawCapsulecast2D with direction of zero]<br>" + nameText, DrawPhysics2D.colorForNonHittingCasts, 0.0f, durationInSec, hiddenByNearerObjects);
return;
}
bool atLeastOneBoxDimIsSmallerThan0d00011 = (size_V2.x < 0.00011f) || (size_V2.y < 0.00011f); //Unity returns no hits, if a capsule dimension is equal or smaller than "0.0001f"
float distanceOfFarestHit = GetDistanceOfSingleHit(hasHit, hitInfo2D);
DrawRayOfCapsulecast(origin_V2, size_V2, atLeastOneBoxDimIsSmallerThan0d00011, capsuleDirection, angleDegCC, hasHit ? 1 : 0, direction_V2, maxDistance, nameText, distanceOfFarestHit, durationInSec, hiddenByNearerObjects);
if (hasHit)
{
DrawCapsulecastHitInfo(size_V2, capsuleDirection, angleDegCC, hitInfo2D, 0, nameText, durationInSec, hiddenByNearerObjects);
}
}
public static void DrawCapsulecastPotMultipleHits(Vector2 origin_V2, Vector2 size_V2, Vector2 direction_V2, CapsuleDirection2D capsuleDirection, float angleDegCC, float maxDistance, RaycastHit2D[] hitInfos2D, int numberOfUsedSlotsInHitInfoArray, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.ApproximatelyZero(direction_V2))
{
UtilitiesDXXL_DrawBasics2D.PointFallback(origin_V2, GetZPosForDrawVisualisation(), "[<color=#adadadFF><icon=logMessage></color> DrawCapsulecast2D with direction of zero]<br>" + nameText, DrawPhysics2D.colorForNonHittingCasts, 0.0f, durationInSec, hiddenByNearerObjects);
return;
}
bool atLeastOneBoxDimIsSmallerThan0d00011 = (size_V2.x < 0.00011f) || (size_V2.y < 0.00011f); //Unity returns no hits, if a capsule dimension is equal or smaller than "0.0001f"
float distanceOfFarestHit = GetDistanceOfFarestHit(hitInfos2D, numberOfUsedSlotsInHitInfoArray);
DrawRayOfCapsulecast(origin_V2, size_V2, atLeastOneBoxDimIsSmallerThan0d00011, capsuleDirection, angleDegCC, numberOfUsedSlotsInHitInfoArray, direction_V2, maxDistance, nameText, distanceOfFarestHit, durationInSec, hiddenByNearerObjects);
for (int i = 0; i < numberOfUsedSlotsInHitInfoArray; i++)
{
DrawCapsulecastHitInfo(size_V2, capsuleDirection, angleDegCC, hitInfos2D[i], i, nameText, durationInSec, hiddenByNearerObjects);
}
}
static Vector2 volumeCastOutlineVertice1_local;
static Vector2 volumeCastOutlineVertice2_local;
static Vector2 volumeCastOutlineVertice1_projectedIntoPerpToCastDirPlane_local;
static Vector2 volumeCastOutlineVertice2_projectedIntoPerpToCastDirPlane_local;
static float distanceOfOutlineVerticesToOrigin_alongCastsUp;
static void DrawRayOfCirclecast(float circleRadius, bool circleRadiusTooSmall, bool radiusIsZero, int hitCount, Vector2 origin_V2, Vector2 direction_V2, float maxDistance, string nameText, float distanceOfFarestHit, float durationInSec, bool hiddenByNearerObjects)
{
bool hasHit = hitCount > 0;
Vector2 direction_normalized_V2 = UtilitiesDXXL_Math.GetNormalized_afterScalingIntoRegionOfFloatPrecicion(direction_V2);
bool hasUnlimitedLength = float.IsInfinity(maxDistance);
maxDistance = Mathf.Min(maxDistance, 100000.0f);
maxDistance = Mathf.Max(maxDistance, -100000.0f);
Vector2 endPos_V2 = origin_V2 + direction_normalized_V2 * maxDistance;
Vector3 castsUp_insideXYPlane_90degCCFromCastDir_normalized_V3 = Vector3.Cross(Vector3.forward, direction_normalized_V2);
Color color = hasHit ? DrawPhysics2D.colorForHittingCasts : DrawPhysics2D.colorForNonHittingCasts;
Color color_lowAlpha = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(color, 0.5f);
Color color_lowerAlpha = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(color, 0.25f);
Color color_ofCastEnd = hasHit ? DrawPhysics2D.colorForCastLineBeyondHit : DrawPhysics2D.colorForNonHittingCasts;
Color color_ofCastEnd_lowAlpha = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(color_ofCastEnd, 0.5f);
Color color_ofCastEnd_lowerAlpha = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(color_ofCastEnd, 0.25f);
if (radiusIsZero == false)
{
FillCircleCastOutlineVertices(direction_normalized_V2, circleRadius);
FillVolumeCastOutlineVertices_projectedIntoPerpToCastDirPlane(direction_V2);
float arrowWidth = circleRadius * 0.5f;
float arrowLength = circleRadius * 1.0f;
float arrowsRelConeLenth = 0.45f;
float circleDiameter = 2.0f * circleRadius;
DrawCircleAtCastStartAndEnd(origin_V2, endPos_V2, circleRadius, color, color_ofCastEnd_lowerAlpha, durationInSec, hiddenByNearerObjects);
float startArrows_startDistanceFromStart = circleDiameter;
DrawArrowsAtVolumeCastStartAndEnd(out float distance_ofStartArrowsStartPos, out float distance_ofEndArrowsStartPos, hasHit, origin_V2, direction_normalized_V2, startArrows_startDistanceFromStart, maxDistance, distanceOfFarestHit, arrowLength, color_lowerAlpha, color_ofCastEnd_lowerAlpha, arrowsRelConeLenth, arrowWidth, durationInSec, hiddenByNearerObjects);
float sizeApproximationOfVolume = circleDiameter;
DrawCascadeOfArrows(distance_ofStartArrowsStartPos, distance_ofEndArrowsStartPos, sizeApproximationOfVolume, hasHit, hasUnlimitedLength, origin_V2, direction_normalized_V2, distanceOfFarestHit, arrowLength, arrowWidth, arrowsRelConeLenth, color_lowerAlpha, color_ofCastEnd_lowerAlpha, durationInSec, hiddenByNearerObjects);
DrawCascadeOfVolumeSilhouette2Dslices(sizeApproximationOfVolume, hasHit, hasUnlimitedLength, origin_V2, direction_normalized_V2, maxDistance, distanceOfFarestHit, color_lowAlpha, color_ofCastEnd_lowAlpha, durationInSec, hiddenByNearerObjects);
}
else
{
volumeCastOutlineVertice1_local = Vector2.zero;
volumeCastOutlineVertice2_local = Vector2.zero;
}
DrawVolumeCastDirOutline(hasHit, origin_V2, endPos_V2, direction_normalized_V2, distanceOfFarestHit, maxDistance, color, color_ofCastEnd, durationInSec, hiddenByNearerObjects);
WriteTextAtCircleCastOrigin(origin_V2, direction_normalized_V2, circleRadius, castsUp_insideXYPlane_90degCCFromCastDir_normalized_V3, circleRadiusTooSmall, color, nameText, hitCount, maxDistance, durationInSec, hiddenByNearerObjects);
}
static void DrawRayOfBoxcast(int hitCount, Vector2 origin_V2, Vector2 boxSize_V2, float angleDegCC, bool atLeastOneBoxDimIsSmallerThan0d00011, Vector2 direction_V2, float maxDistance, string nameText, float distanceOfFarestHit, float durationInSec, bool hiddenByNearerObjects)
{
bool hasHit = hitCount > 0;
Vector2 direction_normalized_V2 = UtilitiesDXXL_Math.GetNormalized_afterScalingIntoRegionOfFloatPrecicion(direction_V2);
bool hasUnlimitedLength = float.IsInfinity(maxDistance);
maxDistance = Mathf.Min(maxDistance, 100000.0f);
maxDistance = Mathf.Max(maxDistance, -100000.0f);
Vector2 endPos_V2 = origin_V2 + direction_normalized_V2 * maxDistance;
Vector3 castsUp_insideXYPlane_90degCCFromCastDir_normalized_V3 = Vector3.Cross(Vector3.forward, direction_normalized_V2);
Color color = hasHit ? DrawPhysics2D.colorForHittingCasts : DrawPhysics2D.colorForNonHittingCasts;
Color color_lowAlpha = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(color, 0.5f);
Color color_lowerAlpha = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(color, 0.25f);
Color color_ofCastEnd = hasHit ? DrawPhysics2D.colorForCastLineBeyondHit : DrawPhysics2D.colorForNonHittingCasts;
Color color_ofCastEnd_lowAlpha = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(color_ofCastEnd, 0.5f);
Color color_ofCastEnd_lowerAlpha = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(color_ofCastEnd, 0.25f);
bool boxScaleIsZero = UtilitiesDXXL_Math.ApproximatelyZero(boxSize_V2);
Vector2 absBoxSize_V2 = UtilitiesDXXL_Math.Abs(boxSize_V2);
float averageBoxSize = 0.5f * (absBoxSize_V2.x + absBoxSize_V2.y);
if (boxScaleIsZero == false)
{
FillBoxCastOutlineVertices(direction_normalized_V2, boxSize_V2, angleDegCC);
FillVolumeCastOutlineVertices_projectedIntoPerpToCastDirPlane(direction_V2);
float heightOfCastCorridor_perpToCastDir = (volumeCastOutlineVertice1_projectedIntoPerpToCastDirPlane_local - volumeCastOutlineVertice2_projectedIntoPerpToCastDirPlane_local).magnitude;
float arrowWidth = heightOfCastCorridor_perpToCastDir * 0.25f;
float arrowLength = heightOfCastCorridor_perpToCastDir * 0.5f;
float arrowsRelConeLenth = 0.45f;
DrawBoxAtCastStartAndEnd(origin_V2, endPos_V2, boxSize_V2, angleDegCC, color, color_ofCastEnd_lowerAlpha, durationInSec, hiddenByNearerObjects);
float startArrows_startDistanceFromStart = averageBoxSize * 0.5f + arrowLength;
DrawArrowsAtVolumeCastStartAndEnd(out float distance_ofStartArrowsStartPos, out float distance_ofEndArrowsStartPos, hasHit, origin_V2, direction_normalized_V2, startArrows_startDistanceFromStart, maxDistance, distanceOfFarestHit, arrowLength, color_lowerAlpha, color_ofCastEnd_lowerAlpha, arrowsRelConeLenth, arrowWidth, durationInSec, hiddenByNearerObjects);
float sizeApproximationOfVolume = averageBoxSize;
DrawCascadeOfArrows(distance_ofStartArrowsStartPos, distance_ofEndArrowsStartPos, sizeApproximationOfVolume, hasHit, hasUnlimitedLength, origin_V2, direction_normalized_V2, distanceOfFarestHit, arrowLength, arrowWidth, arrowsRelConeLenth, color_lowerAlpha, color_ofCastEnd_lowerAlpha, durationInSec, hiddenByNearerObjects);
DrawCascadeOfVolumeSilhouette2Dslices(sizeApproximationOfVolume, hasHit, hasUnlimitedLength, origin_V2, direction_normalized_V2, maxDistance, distanceOfFarestHit, color_lowAlpha, color_ofCastEnd_lowAlpha, durationInSec, hiddenByNearerObjects);
}
else
{
volumeCastOutlineVertice1_local = Vector2.zero;
volumeCastOutlineVertice2_local = Vector2.zero;
}
DrawVolumeCastDirOutline(hasHit, origin_V2, endPos_V2, direction_normalized_V2, distanceOfFarestHit, maxDistance, color, color_ofCastEnd, durationInSec, hiddenByNearerObjects);
WriteTextAtBoxCastOrigin(origin_V2, direction_normalized_V2, castsUp_insideXYPlane_90degCCFromCastDir_normalized_V3, atLeastOneBoxDimIsSmallerThan0d00011, color, nameText, hitCount, maxDistance, averageBoxSize, durationInSec, hiddenByNearerObjects);
}
static void DrawRayOfCapsulecast(Vector2 origin_V2, Vector2 size_V2, bool atLeastOneBoxDimIsSmallerThan0d00011, CapsuleDirection2D capsuleDirection, float angleDegCC, int hitCount, Vector2 direction_V2, float maxDistance, string nameText, float distanceOfFarestHit, float durationInSec, bool hiddenByNearerObjects)
{
bool hasHit = hitCount > 0;
Vector2 direction_normalized_V2 = UtilitiesDXXL_Math.GetNormalized_afterScalingIntoRegionOfFloatPrecicion(direction_V2);
Vector3 castsUp_insideXYPlane_90degCCFromCastDir_normalized_V3 = Vector3.Cross(Vector3.forward, direction_normalized_V2);
bool hasUnlimitedLength = float.IsInfinity(maxDistance);
maxDistance = Mathf.Min(maxDistance, 100000.0f);
maxDistance = Mathf.Max(maxDistance, -100000.0f);
Color color = hasHit ? DrawPhysics2D.colorForHittingCasts : DrawPhysics2D.colorForNonHittingCasts;
Color color_lowAlpha = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(color, 0.5f);
Color color_lowerAlpha = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(color, 0.25f);
Color color_ofCastEnd = hasHit ? DrawPhysics2D.colorForCastLineBeyondHit : DrawPhysics2D.colorForNonHittingCasts;
Color color_ofCastEnd_lowAlpha = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(color_ofCastEnd, 0.5f);
Color color_ofCastEnd_lowerAlpha = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(color_ofCastEnd, 0.25f);
Vector2 endPos_V2 = origin_V2 + direction_normalized_V2 * maxDistance;
bool capsuleSizeIsZero = UtilitiesDXXL_Math.ApproximatelyZero(size_V2);
Vector2 absSize_V2 = UtilitiesDXXL_Math.Abs(size_V2);
absSize_V2 = ExpandCapsuleDimsToSufficeCapsuleDirectionType(absSize_V2, capsuleDirection);
float capsuleRadius = (capsuleDirection == CapsuleDirection2D.Vertical) ? (0.5f * absSize_V2.x) : (0.5f * absSize_V2.y);
if (capsuleSizeIsZero == false)
{
float sizeAlongAbsLongerCapsuleDir = Mathf.Max(absSize_V2.x, absSize_V2.y);
Vector2 unturned_vectorToACircleCenter_local = (capsuleDirection == CapsuleDirection2D.Vertical) ? (Vector2.up * (0.5f * sizeAlongAbsLongerCapsuleDir - capsuleRadius)) : (Vector2.right * (0.5f * sizeAlongAbsLongerCapsuleDir - capsuleRadius));
float distanceBetweenCircles = (capsuleDirection == CapsuleDirection2D.Vertical) ? (absSize_V2.y - 2.0f * capsuleRadius) : (absSize_V2.x - 2.0f * capsuleRadius);
float capsuleCirclesDiameter = 2.0f * capsuleRadius;
float sizeApproximationOfCapsule = capsuleCirclesDiameter + 0.5f * distanceBetweenCircles;
Quaternion capsuleRotation = Quaternion.AngleAxis(angleDegCC, Vector3.forward);
Vector2 turned_vectorToACircleCenter_local = capsuleRotation * unturned_vectorToACircleCenter_local;
FillCapsuleCastOutlineVertices(turned_vectorToACircleCenter_local, -turned_vectorToACircleCenter_local, direction_normalized_V2, capsuleRadius);
FillVolumeCastOutlineVertices_projectedIntoPerpToCastDirPlane(direction_V2);
float heightOfCastCorridor_perpToCastDir = (volumeCastOutlineVertice1_projectedIntoPerpToCastDirPlane_local - volumeCastOutlineVertice2_projectedIntoPerpToCastDirPlane_local).magnitude;
float arrowWidth = heightOfCastCorridor_perpToCastDir * 0.25f;
float arrowLength = heightOfCastCorridor_perpToCastDir * 0.5f;
float arrowsRelConeLenth = 0.45f;
DrawCapsuleAtCastStartAndEnd(origin_V2, endPos_V2, size_V2, capsuleDirection, angleDegCC, color, color_ofCastEnd_lowerAlpha, durationInSec, hiddenByNearerObjects);
float distanceOfCapsulesFarestPosFromOrigin_alongCastDir = GetDistanceOfCapsulesFarestPosFromOrigin_alongCastDir(direction_normalized_V2, turned_vectorToACircleCenter_local, capsuleRadius);
float startArrows_startDistanceFromStart = distanceOfCapsulesFarestPosFromOrigin_alongCastDir + capsuleRadius;
DrawArrowsAtVolumeCastStartAndEnd(out float distance_ofStartArrowsStartPos, out float distance_ofEndArrowsStartPos, hasHit, origin_V2, direction_normalized_V2, startArrows_startDistanceFromStart, maxDistance, distanceOfFarestHit, arrowLength, color_lowerAlpha, color_ofCastEnd_lowerAlpha, arrowsRelConeLenth, arrowWidth, durationInSec, hiddenByNearerObjects);
DrawCascadeOfArrows(distance_ofStartArrowsStartPos, distance_ofEndArrowsStartPos, sizeApproximationOfCapsule, hasHit, hasUnlimitedLength, origin_V2, direction_normalized_V2, distanceOfFarestHit, arrowLength, arrowWidth, arrowsRelConeLenth, color_lowerAlpha, color_ofCastEnd_lowerAlpha, durationInSec, hiddenByNearerObjects);
DrawCascadeOfVolumeSilhouette2Dslices(sizeApproximationOfCapsule, hasHit, hasUnlimitedLength, origin_V2, direction_normalized_V2, maxDistance, distanceOfFarestHit, color_lowAlpha, color_ofCastEnd_lowAlpha, durationInSec, hiddenByNearerObjects);
}
else
{
volumeCastOutlineVertice1_local = Vector2.zero;
volumeCastOutlineVertice2_local = Vector2.zero;
}
DrawVolumeCastDirOutline(hasHit, origin_V2, endPos_V2, direction_normalized_V2, distanceOfFarestHit, maxDistance, color, color_ofCastEnd, durationInSec, hiddenByNearerObjects);
WriteTextAtCapsuleCastOrigin(origin_V2, direction_normalized_V2, capsuleRadius, castsUp_insideXYPlane_90degCCFromCastDir_normalized_V3, atLeastOneBoxDimIsSmallerThan0d00011, color, nameText, hitCount, maxDistance, durationInSec, hiddenByNearerObjects);
}
static void DrawCircleAtCastStartAndEnd(Vector2 origin_V2, Vector2 endPos_V2, float circleRadius, Color color, Color color_ofCastEnd_lowerAlpha, float durationInSec, bool hiddenByNearerObjects)
{
//start circle:
DrawShapes.Circle2D(origin_V2, circleRadius, color, GetZPosForDrawVisualisation(), 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.solid, false, durationInSec, hiddenByNearerObjects);
//end circle:
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
DrawShapes.Circle2D(endPos_V2, circleRadius, color_ofCastEnd_lowerAlpha, GetZPosForDrawVisualisation(), 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.solid, false, durationInSec, hiddenByNearerObjects);
}
}
static void DrawBoxAtCastStartAndEnd(Vector2 origin_V2, Vector2 endPos_V2, Vector2 boxSize_V2, float angleDegCC, Color color, Color color_ofCastEnd_lowerAlpha, float durationInSec, bool hiddenByNearerObjects)
{
//start box:
DrawShapes.Box2D(origin_V2, boxSize_V2, color, GetZPosForDrawVisualisation(), angleDegCC, DrawShapes.Shape2DType.square, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.solid, false, durationInSec, hiddenByNearerObjects);
//end box:
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
DrawShapes.Box2D(endPos_V2, boxSize_V2, color_ofCastEnd_lowerAlpha, GetZPosForDrawVisualisation(), angleDegCC, DrawShapes.Shape2DType.square, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.solid, false, durationInSec, hiddenByNearerObjects);
}
}
static void DrawCapsuleAtCastStartAndEnd(Vector2 origin_atCastStart_V2, Vector2 origin_atCastEnd_V2, Vector2 size_V2, CapsuleDirection2D capsuleDirection, float angleDegCC, Color color, Color color_ofCastEnd_lowerAlpha, float durationInSec, bool hiddenByNearerObjects)
{
//start capsule:
DrawShapes.Capsule2D(origin_atCastStart_V2, size_V2, color, GetZPosForDrawVisualisation(), capsuleDirection, angleDegCC, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.solid, false, false, durationInSec, hiddenByNearerObjects);
//end capsule:
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
DrawShapes.Capsule2D(origin_atCastEnd_V2, size_V2, color_ofCastEnd_lowerAlpha, GetZPosForDrawVisualisation(), capsuleDirection, angleDegCC, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.solid, false, false, durationInSec, hiddenByNearerObjects);
}
}
static Vector2 ExpandCapsuleDimsToSufficeCapsuleDirectionType(Vector2 absSize_preExpanding_V2, CapsuleDirection2D capsuleDirection)
{
if (capsuleDirection == CapsuleDirection2D.Vertical)
{
absSize_preExpanding_V2.y = Mathf.Max(absSize_preExpanding_V2.x, absSize_preExpanding_V2.y);
}
else
{
absSize_preExpanding_V2.x = Mathf.Max(absSize_preExpanding_V2.x, absSize_preExpanding_V2.y);
}
return absSize_preExpanding_V2;
}
static float GetDistanceOfCapsulesFarestPosFromOrigin_alongCastDir(Vector2 direction_normalized_V2, Vector2 turned_vectorToACircleCenter_local, float capsuleRadius)
{
Vector2 circle1Pos_local = turned_vectorToACircleCenter_local;
Vector2 circle2Pos_local = -turned_vectorToACircleCenter_local;
if (UtilitiesDXXL_Math.Check_ifVectorsPointInSameDirection_perpCountsAsPointingInSameDir(direction_normalized_V2, circle1Pos_local))
{
return circle1Pos_local.magnitude + capsuleRadius;
}
else
{
return circle2Pos_local.magnitude + capsuleRadius;
}
}
static void DrawArrowsAtVolumeCastStartAndEnd(out float distance_ofStartArrowsStartPos, out float distance_ofEndArrowsStartPos, bool hasHit, Vector2 origin_V2, Vector2 direction_normalized_V2, float distanceFromOrigin_toStartOfStartArrow, float maxDistance, float distanceOfFarestHit, float arrowLength, Color color_lowerAlpha, Color color_ofCastEnd_lowerAlpha, float arrowsRelConeLenth, float arrowWidth, float durationInSec, bool hiddenByNearerObjects)
{
distance_ofStartArrowsStartPos = 0.0f;
distance_ofEndArrowsStartPos = 0.0f;
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes) { return; }
if (arrowLength > UtilitiesDXXL_Physics.minArrowLength)
{
//at start:
float original_distanceFromOrigin_toStartOfStartArrow = distanceFromOrigin_toStartOfStartArrow;
distanceFromOrigin_toStartOfStartArrow = Mathf.Min(distanceFromOrigin_toStartOfStartArrow, 0.5f * maxDistance);
if (hasHit) { distanceFromOrigin_toStartOfStartArrow = Mathf.Min(distanceFromOrigin_toStartOfStartArrow, 0.5f * distanceOfFarestHit); }
if (distanceFromOrigin_toStartOfStartArrow <= 0.0f) { distanceFromOrigin_toStartOfStartArrow = original_distanceFromOrigin_toStartOfStartArrow; }
bool isAfterLastHit = hasHit && ((distanceFromOrigin_toStartOfStartArrow + 0.5f * arrowLength) > distanceOfFarestHit);
distance_ofStartArrowsStartPos = distanceFromOrigin_toStartOfStartArrow;
Vector2 startVector_startPos_V2 = origin_V2 + direction_normalized_V2 * distanceFromOrigin_toStartOfStartArrow;
Vector2 startVector_endPos_V2 = origin_V2 + direction_normalized_V2 * (distanceFromOrigin_toStartOfStartArrow + arrowLength);
UtilitiesDXXL_DrawBasics.Set_coneLength_interpretation_forStraightVectors_reversible(DrawBasics.LengthInterpretation.relativeToLineLength);
DrawBasics2D.Vector(startVector_startPos_V2, startVector_endPos_V2, isAfterLastHit ? color_ofCastEnd_lowerAlpha : color_lowerAlpha, arrowWidth, null, arrowsRelConeLenth, false, GetZPosForDrawVisualisation(), false, 0.0f, false, 0.0f, durationInSec, hiddenByNearerObjects);
UtilitiesDXXL_DrawBasics.Reverse_coneLength_interpretation_forStraightVectors();
//at end:
float distanceFromOrigin_toStartOfEndArrow = maxDistance - original_distanceFromOrigin_toStartOfStartArrow - arrowLength;
distance_ofEndArrowsStartPos = distanceFromOrigin_toStartOfEndArrow;
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.high_withFullDetails)
{
if (maxDistance > (distanceFromOrigin_toStartOfStartArrow + 12.0f * arrowLength))
{
isAfterLastHit = hasHit && ((distanceFromOrigin_toStartOfEndArrow + 0.5f * arrowLength) > distanceOfFarestHit);
Vector2 endVector_startPos_V2 = origin_V2 + direction_normalized_V2 * distanceFromOrigin_toStartOfEndArrow;
Vector2 endVector_endPos_V2 = origin_V2 + direction_normalized_V2 * (distanceFromOrigin_toStartOfEndArrow + arrowLength);
UtilitiesDXXL_DrawBasics.Set_coneLength_interpretation_forStraightVectors_reversible(DrawBasics.LengthInterpretation.relativeToLineLength);
DrawBasics2D.Vector(endVector_startPos_V2, endVector_endPos_V2, isAfterLastHit ? color_ofCastEnd_lowerAlpha : color_lowerAlpha, arrowWidth, null, arrowsRelConeLenth, false, GetZPosForDrawVisualisation(), false, 0.0f, false, 0.0f, durationInSec, hiddenByNearerObjects);
UtilitiesDXXL_DrawBasics.Reverse_coneLength_interpretation_forStraightVectors();
}
}
}
}
static void FillCircleCastOutlineVertices(Vector2 direction_normalized_V2, float circleRadius)
{
volumeCastOutlineVertice1_local = Vector3.Cross(Vector3.forward, direction_normalized_V2) * circleRadius;
volumeCastOutlineVertice2_local = -volumeCastOutlineVertice1_local;
}
///cube definition:
//viewed along z-forward:
//starts with: nearer square, lowLeft, then counterclockwise
static Vector2[] unscaledUnrotatedBox2D = new Vector2[4] { new Vector2(-0.5f, -0.5f), new Vector2(0.5f, -0.5f), new Vector2(0.5f, 0.5f), new Vector2(-0.5f, 0.5f) };
static void FillBoxCastOutlineVertices(Vector2 direction_normalized_V2, Vector2 boxSize_V2, float angleDegCC)
{
Quaternion boxRotation = Quaternion.AngleAxis(angleDegCC, Vector3.forward);
Vector2 toUp_ofBox = boxRotation * Vector3.up;
Vector2 toRight_ofBox = boxRotation * Vector3.right;
if (UtilitiesDXXL_Math.Check_ifVectorsPointInSameDirection_perpCountsAsPointingInSameDir(direction_normalized_V2, toRight_ofBox))
{
if (UtilitiesDXXL_Math.Check_ifVectorsPointInSameDirection_perpCountsAsPointingInSameDir(direction_normalized_V2, toUp_ofBox))
{
volumeCastOutlineVertice1_local = boxRotation * Vector2.Scale(unscaledUnrotatedBox2D[1], boxSize_V2);
volumeCastOutlineVertice2_local = boxRotation * Vector2.Scale(unscaledUnrotatedBox2D[3], boxSize_V2);
}
else
{
volumeCastOutlineVertice1_local = boxRotation * Vector2.Scale(unscaledUnrotatedBox2D[0], boxSize_V2);
volumeCastOutlineVertice2_local = boxRotation * Vector2.Scale(unscaledUnrotatedBox2D[2], boxSize_V2);
}
}
else
{
if (UtilitiesDXXL_Math.Check_ifVectorsPointInSameDirection_perpCountsAsPointingInSameDir(direction_normalized_V2, toUp_ofBox))
{
volumeCastOutlineVertice1_local = boxRotation * Vector2.Scale(unscaledUnrotatedBox2D[0], boxSize_V2);
volumeCastOutlineVertice2_local = boxRotation * Vector2.Scale(unscaledUnrotatedBox2D[2], boxSize_V2);
}
else
{
volumeCastOutlineVertice1_local = boxRotation * Vector2.Scale(unscaledUnrotatedBox2D[1], boxSize_V2);
volumeCastOutlineVertice2_local = boxRotation * Vector2.Scale(unscaledUnrotatedBox2D[3], boxSize_V2);
}
}
}
static void FillCapsuleCastOutlineVertices(Vector2 posOfCapsuleCircle1_local, Vector2 posOfCapsuleCircle2_local, Vector2 direction_normalized_V2, float capsuleRadius)
{
Vector2 up_insideXYPlane_ofCastDir_normalized = Vector3.Cross(Vector3.forward, direction_normalized_V2);
bool circle1_isHigher_seenAlongCastDir = UtilitiesDXXL_Math.Check_ifVectorsPointInSameDirection_perpCountsAsPointingInSameDir(posOfCapsuleCircle1_local, up_insideXYPlane_ofCastDir_normalized);
if (circle1_isHigher_seenAlongCastDir)
{
volumeCastOutlineVertice1_local = posOfCapsuleCircle1_local + up_insideXYPlane_ofCastDir_normalized * capsuleRadius;
volumeCastOutlineVertice2_local = posOfCapsuleCircle2_local - up_insideXYPlane_ofCastDir_normalized * capsuleRadius;
}
else
{
volumeCastOutlineVertice1_local = posOfCapsuleCircle1_local - up_insideXYPlane_ofCastDir_normalized * capsuleRadius;
volumeCastOutlineVertice2_local = posOfCapsuleCircle2_local + up_insideXYPlane_ofCastDir_normalized * capsuleRadius;
}
}
static InternalDXXL_Plane plane_throughWorldOrigin_containingZAxis_perpToCastDir = new InternalDXXL_Plane();
static void FillVolumeCastOutlineVertices_projectedIntoPerpToCastDirPlane(Vector2 direction_V2)
{
Vector3 direction_V3 = UtilitiesDXXL_DrawBasics2D.Direction_V2toV3(direction_V2);
plane_throughWorldOrigin_containingZAxis_perpToCastDir.Recreate(Vector3.zero, direction_V3);
volumeCastOutlineVertice1_projectedIntoPerpToCastDirPlane_local = plane_throughWorldOrigin_containingZAxis_perpToCastDir.Get_perpProjectionOfPointOnPlane(volumeCastOutlineVertice1_local);
volumeCastOutlineVertice2_projectedIntoPerpToCastDirPlane_local = -volumeCastOutlineVertice1_projectedIntoPerpToCastDirPlane_local;
distanceOfOutlineVerticesToOrigin_alongCastsUp = volumeCastOutlineVertice1_projectedIntoPerpToCastDirPlane_local.magnitude;
}
static void DrawVolumeCastDirOutline(bool hasHit, Vector2 origin_V2, Vector2 endPos_V2, Vector2 direction_normalized_V2, float distanceOfFarestHit, float maxDistance, Color color, Color color_ofCastEnd, float durationInSec, bool hiddenByNearerObjects)
{
if (hasHit)
{
if (maxDistance < 0.0f)
{
//unity.RaycastHit2D always returns positve values for "distance", also if the cast goes backward due to negative "maxDistance"
distanceOfFarestHit = -distanceOfFarestHit;
}
Vector2 posOfFarestHit_V2 = origin_V2 + direction_normalized_V2 * distanceOfFarestHit;
//vertice1 toFarest hit, then to end:
Line_fadeableAnimSpeed_2D.InternalDraw(origin_V2 + volumeCastOutlineVertice1_local, posOfFarestHit_V2 + volumeCastOutlineVertice1_local, color, 0.0f, null, DrawBasics.LineStyle.solid, GetZPosForDrawVisualisation(), 1.0f, 0.0f, null, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
Line_fadeableAnimSpeed_2D.InternalDraw(posOfFarestHit_V2 + volumeCastOutlineVertice1_local, endPos_V2 + volumeCastOutlineVertice1_local, color_ofCastEnd, 0.0f, null, DrawBasics.LineStyle.solid, GetZPosForDrawVisualisation(), 1.0f, 0.0f, null, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
//vertice2 toFarest hit, then to end:
Line_fadeableAnimSpeed_2D.InternalDraw(origin_V2 + volumeCastOutlineVertice2_local, posOfFarestHit_V2 + volumeCastOutlineVertice2_local, color, 0.0f, null, DrawBasics.LineStyle.solid, GetZPosForDrawVisualisation(), 1.0f, 0.0f, null, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
Line_fadeableAnimSpeed_2D.InternalDraw(posOfFarestHit_V2 + volumeCastOutlineVertice2_local, endPos_V2 + volumeCastOutlineVertice2_local, color_ofCastEnd, 0.0f, null, DrawBasics.LineStyle.solid, GetZPosForDrawVisualisation(), 1.0f, 0.0f, null, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
}
else
{
//vertice1 to end:
Line_fadeableAnimSpeed_2D.InternalDraw(origin_V2 + volumeCastOutlineVertice1_local, endPos_V2 + volumeCastOutlineVertice1_local, color, 0.0f, null, DrawBasics.LineStyle.solid, GetZPosForDrawVisualisation(), 1.0f, 0.0f, null, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
//vertice2 to end:
Line_fadeableAnimSpeed_2D.InternalDraw(origin_V2 + volumeCastOutlineVertice2_local, endPos_V2 + volumeCastOutlineVertice2_local, color, 0.0f, null, DrawBasics.LineStyle.solid, GetZPosForDrawVisualisation(), 1.0f, 0.0f, null, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
}
}
static void DrawCascadeOfVolumeSilhouette2Dslices(float sizeApproximationOfVolume, bool hasHit, bool hasUnlimitedLength, Vector2 origin_V2, Vector2 direction_normalized_V2, float maxDistance, float distanceOfFarestHit, Color color_lowAlpha, Color color_ofCastEnd_lowAlpha, float durationInSec, bool hiddenByNearerObjects)
{
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes) { return; }
if (UtilitiesDXXL_Math.ApproximatelyZero(DrawPhysics2D.castCorridorVisualizerDensity) == false)
{
float distanceBetweenSilhouettes = hasUnlimitedLength ? (4.0f * sizeApproximationOfVolume) : (2.2f * sizeApproximationOfVolume);
int maxSilhouettesPerVolumeCast = hasUnlimitedLength ? 50 : 200;
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes)
{
maxSilhouettesPerVolumeCast = hasUnlimitedLength ? 20 : 40;
}
float used_castSilhouetteVisualizerDensity = DrawPhysics2D.castCorridorVisualizerDensity;
used_castSilhouetteVisualizerDensity = Mathf.Max(used_castSilhouetteVisualizerDensity, 0.01f);
used_castSilhouetteVisualizerDensity = Mathf.Min(used_castSilhouetteVisualizerDensity, 1000.0f);
distanceBetweenSilhouettes = distanceBetweenSilhouettes / used_castSilhouetteVisualizerDensity;
if (used_castSilhouetteVisualizerDensity > 1.0f) { maxSilhouettesPerVolumeCast = Mathf.RoundToInt(used_castSilhouetteVisualizerDensity * maxSilhouettesPerVolumeCast); }
maxSilhouettesPerVolumeCast = Mathf.Min(maxSilhouettesPerVolumeCast, DrawPhysics2D.maxCorridorVisualizersPerCastVisualization);
distanceBetweenSilhouettes = Mathf.Max(distanceBetweenSilhouettes, 0.1f);
float distance_ofCurrSilhouette = 0.0f;
for (int i_silhouette = 0; i_silhouette < maxSilhouettesPerVolumeCast; i_silhouette++)
{
distance_ofCurrSilhouette = distance_ofCurrSilhouette + distanceBetweenSilhouettes;
bool isAfterLastHit = hasHit && (distance_ofCurrSilhouette > distanceOfFarestHit);
if (distance_ofCurrSilhouette < maxDistance)
{
Vector2 posOfCurrSilhouetteOnRayLine_V2 = origin_V2 + distance_ofCurrSilhouette * direction_normalized_V2;
Line_fadeableAnimSpeed_2D.InternalDraw(posOfCurrSilhouetteOnRayLine_V2 + volumeCastOutlineVertice1_projectedIntoPerpToCastDirPlane_local, posOfCurrSilhouetteOnRayLine_V2 + volumeCastOutlineVertice2_projectedIntoPerpToCastDirPlane_local, isAfterLastHit ? color_ofCastEnd_lowAlpha : color_lowAlpha, 0.0f, null, DrawBasics.LineStyle.solid, GetZPosForDrawVisualisation(), 1.0f, 0.0f, null, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
}
else
{
break;
}
if (hasUnlimitedLength)
{
distanceBetweenSilhouettes = (1.0f + (0.4f / used_castSilhouetteVisualizerDensity)) * distanceBetweenSilhouettes;
}
else
{
if (i_silhouette > 3)
{
distanceBetweenSilhouettes = (1.0f + (0.25f / used_castSilhouetteVisualizerDensity)) * distanceBetweenSilhouettes;
}
}
}
}
}
static void DrawCascadeOfArrows(float distance_ofStartArrowsStartPos, float distance_ofEndArrowsStartPos, float sizeApproximationOfVolume, bool hasHit, bool hasUnlimitedLength, Vector2 origin_V2, Vector2 direction_normalized_V2, float distanceOfFarestHit, float arrowLength, float arrowWidth, float arrowsRelConeLenth, Color color_lowerAlpha, Color color_ofCastEnd_lowerAlpha, float durationInSec, bool hiddenByNearerObjects)
{
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.high_withFullDetails)
{
if (UtilitiesDXXL_Math.ApproximatelyZero(DrawPhysics2D.castCorridorVisualizerDensity) == false)
{
if (arrowLength > UtilitiesDXXL_Physics.minArrowLength)
{
float distanceBetweenArrows = hasUnlimitedLength ? (6.0f * sizeApproximationOfVolume) : (3.25f * sizeApproximationOfVolume);
int maxArrowsPerVolumeCast = hasUnlimitedLength ? 5 : 15;
distanceBetweenArrows = Mathf.Max(distanceBetweenArrows, 0.5f);
float distance_ofCurrArrowsStart = distance_ofStartArrowsStartPos + distanceBetweenArrows;
for (int i_arrow = 0; i_arrow < maxArrowsPerVolumeCast; i_arrow++)
{
if (distance_ofCurrArrowsStart < distance_ofEndArrowsStartPos)
{
bool isAfterLastHit = hasHit && ((distance_ofCurrArrowsStart + 0.5f * arrowLength) > distanceOfFarestHit);
Vector2 vectorStartPos_V2 = origin_V2 + distance_ofCurrArrowsStart * direction_normalized_V2;
Vector2 vectorEndPos_V2 = origin_V2 + (distance_ofCurrArrowsStart + arrowLength) * direction_normalized_V2;
UtilitiesDXXL_DrawBasics.Set_coneLength_interpretation_forStraightVectors_reversible(DrawBasics.LengthInterpretation.relativeToLineLength);
DrawBasics2D.Vector(vectorStartPos_V2, vectorEndPos_V2, isAfterLastHit ? color_ofCastEnd_lowerAlpha : color_lowerAlpha, arrowWidth, null, arrowsRelConeLenth, false, GetZPosForDrawVisualisation(), false, 0.0f, false, 0.0f, durationInSec, hiddenByNearerObjects);
UtilitiesDXXL_DrawBasics.Reverse_coneLength_interpretation_forStraightVectors();
}
else
{
break;
}
if (hasUnlimitedLength)
{
distanceBetweenArrows = 2.0f * distanceBetweenArrows;
}
else
{
if (i_arrow > 3)
{
distanceBetweenArrows = 1.5f * distanceBetweenArrows;
}
}
distance_ofCurrArrowsStart = distance_ofCurrArrowsStart + distanceBetweenArrows;
}
}
}
}
}
static void WriteTextAtCircleCastOrigin(Vector2 origin_V2, Vector2 direction_normalized_V2, float circleRadius, Vector3 castsUp_insideXYPlane_90degCCFromCastDir_normalized_V3, bool circleRadiusTooSmall, Color color, string nameText, int hitCount, float maxDistance, float durationInSec, bool hiddenByNearerObjects)
{
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes) { return; }
float textSize = 0.2f * circleRadius;
string additinalWarningText = circleRadiusTooSmall ? "[<color=#e2aa00FF><icon=warning></color> circle radius too small -> potentially collisions missing]<br>" : null;
string castText = GetVolumeCastStartTextString("<size=27>Circlecast2D</size><br><size=5> </size><br>number of hits: ", nameText, hitCount, maxDistance, additinalWarningText);
WriteTextAtVolumeCastOrigin(castText, origin_V2, castsUp_insideXYPlane_90degCCFromCastDir_normalized_V3, direction_normalized_V2, textSize, color, durationInSec, hiddenByNearerObjects);
}
static void WriteTextAtBoxCastOrigin(Vector2 origin_V2, Vector2 direction_normalized_V2, Vector3 castsUp_insideXYPlane_90degCCFromCastDir_normalized_V3, bool atLeastOneBoxDimIsSmallerThan0d00011, Color color, string nameText, int hitCount, float maxDistance, float averageBoxSize, float durationInSec, bool hiddenByNearerObjects)
{
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes) { return; }
float textSize = 0.1f * averageBoxSize;
string additinalWarningText = atLeastOneBoxDimIsSmallerThan0d00011 ? "[<color=#e2aa00FF><icon=warning></color> box dimension is very small -> potentially collisions missing]<br>" : null;
string castText = GetVolumeCastStartTextString("<size=27>Boxcast2D</size><br><size=5> </size><br>number of hits: ", nameText, hitCount, maxDistance, additinalWarningText);
WriteTextAtVolumeCastOrigin(castText, origin_V2, castsUp_insideXYPlane_90degCCFromCastDir_normalized_V3, direction_normalized_V2, textSize, color, durationInSec, hiddenByNearerObjects);
}
static void WriteTextAtCapsuleCastOrigin(Vector2 origin_V2, Vector2 direction_normalized_V2, float capsuleRadius, Vector3 castsUp_insideXYPlane_90degCCFromCastDir_normalized_V3, bool atLeastOneBoxDimIsSmallerThan0d00011, Color color, string nameText, int hitCount, float maxDistance, float durationInSec, bool hiddenByNearerObjects)
{
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes) { return; }
float textSize = 0.2f * capsuleRadius;
string additinalWarningText = atLeastOneBoxDimIsSmallerThan0d00011 ? "[<color=#e2aa00FF><icon=warning></color> capsule dimension is very small -> potentially collisions missing]<br>" : null;
string castText = GetVolumeCastStartTextString("<size=27>Capsulecast2D</size><br><size=5> </size><br>number of hits: ", nameText, hitCount, maxDistance, additinalWarningText);
WriteTextAtVolumeCastOrigin(castText, origin_V2, castsUp_insideXYPlane_90degCCFromCastDir_normalized_V3, direction_normalized_V2, textSize, color, durationInSec, hiddenByNearerObjects);
}
static void WriteTextAtVolumeCastOrigin(string castText, Vector2 origin_V2, Vector3 castsUp_insideXYPlane_90degCCFromCastDir_normalized_V3, Vector2 direction_normalized_V2, float textSize, Color color, float durationInSec, bool hiddenByNearerObjects)
{
textSize = Mathf.Max(textSize, 0.02f);
Color textColor = Color.Lerp(color, Color.black, 0.75f);
Vector2 textPos = origin_V2 + (Vector2)castsUp_insideXYPlane_90degCCFromCastDir_normalized_V3 * (distanceOfOutlineVerticesToOrigin_alongCastsUp + 0.65f * textSize);
bool direction_isTowardsRight = (direction_normalized_V2.x >= 0.0f);
Vector2 textDir = direction_isTowardsRight ? direction_normalized_V2 : (-direction_normalized_V2);
DrawText.TextAnchorDXXL textAnchor = direction_isTowardsRight ? DrawText.TextAnchorDXXL.LowerLeft : DrawText.TextAnchorDXXL.UpperRight;
UtilitiesDXXL_Text.Write2DFramed(castText, textPos, textColor, textSize, textDir, textAnchor, GetZPosForDrawVisualisation(), DrawBasics.LineStyle.solid, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, true, durationInSec, hiddenByNearerObjects);
}
static string GetVolumeCastStartTextString(string volumeCastTypeIdentifyingStringPart, string nameText, int hitCount, float maxDistance, string additinalWarningText)
{
additinalWarningText = UtilitiesDXXL_Math.ApproximatelyZero(maxDistance) ? "[<color=#e2aa00FF><icon=warning></color> cast distance is zero]<br>" + additinalWarningText : additinalWarningText;
additinalWarningText = (maxDistance < 0.0f) ? "[<color=#e2aa00FF><icon=warning></color> negative cast direction]<br>" + additinalWarningText : additinalWarningText;
string startText;
if (DrawPhysics2D.drawCastNameTag_atCastOrigin && nameText != null && nameText.Length != 0)
{
startText = (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes) ? additinalWarningText + UtilitiesDXXL_Physics.GetSizeMarkupStartStringForCastNames(nameText) + nameText + "</size><br><size=5> </size><br>hits: " + hitCount : additinalWarningText + UtilitiesDXXL_Physics.GetSizeMarkupStartStringForCastNames(nameText) + nameText + "</size><br><size=5> </size><br>number of hits: " + hitCount;
}
else
{
startText = (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes) ? additinalWarningText + "hits: " + hitCount : additinalWarningText + volumeCastTypeIdentifyingStringPart + hitCount;
}
return startText;
}
static void DrawCirclecastHitInfo(float circleRadius, RaycastHit2D hitInfo2D, int i_hit, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.VectorIsInvalid(hitInfo2D.point) || UtilitiesDXXL_Math.VectorIsInvalid(hitInfo2D.normal))
{
Debug.LogError("Draw XXL: A 'Physics2D.CircleCast()' returned an invalid hit position (namely " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + ") or normal (namely " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.normal) + "). The drawn cast visualization may be incorrect.");
}
else
{
bool saveDrawnLines = i_hit >= DrawPhysics2D.hitResultsWithMoreDetailedDisplay;
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.high_withFullDetails) { saveDrawnLines = true; }
Vector3 impactPos_V3 = UtilitiesDXXL_DrawBasics2D.Position_V2toV3(hitInfo2D.point, hitInfo2D.transform.position.z);
DrawCircleAtHitPos(hitInfo2D, circleRadius, durationInSec, hiddenByNearerObjects);
DrawNormalAtVolumeCastHitPos(impactPos_V3, saveDrawnLines, hitInfo2D, durationInSec, hiddenByNearerObjects);
DrawDashedLineAlongZ(impactPos_V3, hitInfo2D, durationInSec, hiddenByNearerObjects);
string text = GetTextAtHitPos_forVolumeCast("<sw=80000>Circlecast2D hit #", saveDrawnLines, hitInfo2D, i_hit, nameText);
string additionalWarningText = null;
DrawTextDescriptionAtVolumeCastHitPos(impactPos_V3, hitInfo2D, nameText, text, durationInSec, hiddenByNearerObjects, additionalWarningText);
}
}
static void DrawBoxcastHitInfo(Vector2 boxSize_V2, float angleDegCC, RaycastHit2D hitInfo2D, int i_hit, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.VectorIsInvalid(hitInfo2D.point) || UtilitiesDXXL_Math.VectorIsInvalid(hitInfo2D.normal))
{
Debug.LogError("Draw XXL: A 'Physics2D.BoxCast()' returned an invalid hit position (namely " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + ") or normal (namely " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.normal) + "). The drawn cast visualization may be incorrect.");
}
else
{
bool saveDrawnLines = i_hit >= DrawPhysics2D.hitResultsWithMoreDetailedDisplay;
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.high_withFullDetails) { saveDrawnLines = true; }
Vector3 impactPos_V3 = UtilitiesDXXL_DrawBasics2D.Position_V2toV3(hitInfo2D.point, hitInfo2D.transform.position.z);
DrawBoxAtHitPos(boxSize_V2, angleDegCC, hitInfo2D, durationInSec, hiddenByNearerObjects);
DrawNormalAtVolumeCastHitPos(impactPos_V3, saveDrawnLines, hitInfo2D, durationInSec, hiddenByNearerObjects);
DrawDashedLineAlongZ(impactPos_V3, hitInfo2D, durationInSec, hiddenByNearerObjects);
string text = GetTextAtHitPos_forVolumeCast("<sw=80000>Boxcast2D hit #", saveDrawnLines, hitInfo2D, i_hit, nameText);
string additionalWarningText = null;
DrawTextDescriptionAtVolumeCastHitPos(impactPos_V3, hitInfo2D, nameText, text, durationInSec, hiddenByNearerObjects, additionalWarningText);
}
}
static void DrawCapsulecastHitInfo(Vector2 size_V2, CapsuleDirection2D capsuleDirection, float angleDegCC, RaycastHit2D hitInfo2D, int i_hit, string nameText, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.VectorIsInvalid(hitInfo2D.point) || UtilitiesDXXL_Math.VectorIsInvalid(hitInfo2D.normal))
{
Debug.LogError("Draw XXL: A 'Physics2D.CapsuleCast()' returned an invalid hit position (namely " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + ") or normal (namely " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.normal) + "). The drawn cast visualization may be incorrect.");
}
else
{
bool saveDrawnLines = i_hit >= DrawPhysics2D.hitResultsWithMoreDetailedDisplay;
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.high_withFullDetails) { saveDrawnLines = true; }
Vector3 impactPos_V3 = UtilitiesDXXL_DrawBasics2D.Position_V2toV3(hitInfo2D.point, hitInfo2D.transform.position.z);
DrawCapsuleAtHitPos(size_V2, capsuleDirection, angleDegCC, hitInfo2D, i_hit, durationInSec, hiddenByNearerObjects);
DrawNormalAtVolumeCastHitPos(impactPos_V3, saveDrawnLines, hitInfo2D, durationInSec, hiddenByNearerObjects);
DrawDashedLineAlongZ(impactPos_V3, hitInfo2D, durationInSec, hiddenByNearerObjects);
string text = GetTextAtHitPos_forVolumeCast("<sw=80000>Capsulecast2D hit #", saveDrawnLines, hitInfo2D, i_hit, nameText);
string additionalWarningText = null;
DrawTextDescriptionAtVolumeCastHitPos(impactPos_V3, hitInfo2D, nameText, text, durationInSec, hiddenByNearerObjects, additionalWarningText);
}
}
static void DrawCircleAtHitPos(RaycastHit2D hitInfo2D, float circleRadius, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.VectorIsInvalid(hitInfo2D.centroid))
{
Debug.LogError("Draw XXL: A 'Physics2D.CircleCast()' returned an invalid hit position centroid (namely " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.centroid) + "). The drawn cast visualization may be incorrect.");
}
else
{
Color color_ofHittingVolume = Color.Lerp(DrawPhysics2D.colorForHittingCasts, Color.white, 0.6f);
DrawShapes.Circle2D(hitInfo2D.centroid, circleRadius, color_ofHittingVolume, hitInfo2D.transform.position.z, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.solid, false, durationInSec, hiddenByNearerObjects);
}
}
static void DrawBoxAtHitPos(Vector2 boxSize_V2, float angleDegCC, RaycastHit2D hitInfo2D, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.VectorIsInvalid(hitInfo2D.centroid))
{
Debug.LogError("Draw XXL: A 'Physics2D.BoxCast()' returned an invalid hit position centroid (namely " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.centroid) + "). The drawn cast visualization may be incorrect.");
}
else
{
Color color_ofHittingVolume = Color.Lerp(DrawPhysics2D.colorForHittingCasts, Color.white, 0.6f);
DrawShapes.Box2D(hitInfo2D.centroid, boxSize_V2, color_ofHittingVolume, hitInfo2D.transform.position.z, angleDegCC, DrawShapes.Shape2DType.square, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.solid, false, durationInSec, hiddenByNearerObjects);
}
}
static void DrawCapsuleAtHitPos(Vector2 size_V2, CapsuleDirection2D capsuleDirection, float angleDegCC, RaycastHit2D hitInfo2D, int i_hit, float durationInSec, bool hiddenByNearerObjects)
{
if (UtilitiesDXXL_Math.VectorIsInvalid(hitInfo2D.centroid))
{
Debug.LogError("Draw XXL: A 'Physics2D.CapsuleCast()' returned an invalid hit position centroid (namely " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.centroid) + "). The drawn cast visualization may be incorrect.");
}
else
{
Color color_ofHittingVolume = Color.Lerp(DrawPhysics2D.colorForHittingCasts, Color.white, 0.6f);
DrawShapes.Capsule2D(hitInfo2D.centroid, size_V2, color_ofHittingVolume, hitInfo2D.transform.position.z, capsuleDirection, angleDegCC, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.solid, false, false, durationInSec, hiddenByNearerObjects);
}
}
static void DrawNormalAtVolumeCastHitPos(Vector3 impactPos_V3, bool saveDrawnLines, RaycastHit2D hitInfo2D, float durationInSec, bool hiddenByNearerObjects)
{
Vector3 normal_V3 = UtilitiesDXXL_DrawBasics2D.Direction_V2toV3(hitInfo2D.normal);
Color color_ofNormal = Get_color_ofNormal();
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
//normal:
DrawBasics2D.LineFrom(impactPos_V3, normal_V3, color_ofNormal, 0.0f, null, DrawBasics.LineStyle.solid, hitInfo2D.transform.position.z, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
//normal socket:
DrawShapes.Square(impactPos_V3, 0.12f, color_ofNormal, normal_V3, default, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.invisible, false, false, durationInSec, hiddenByNearerObjects);
}
else
{
//normal:
float relConeLength_ofNormalVector = 0.17f;
string normalText = (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes) ? null : (saveDrawnLines ? "normal" : "normal<br><size=4>of hit surface</size>");
UtilitiesDXXL_DrawBasics.Set_coneLength_interpretation_forStraightVectors_reversible(DrawBasics.LengthInterpretation.relativeToLineLength);
DrawBasics2D.VectorFrom(impactPos_V3, normal_V3, color_ofNormal, saveDrawnLines ? 0.0f : 0.006f, normalText, relConeLength_ofNormalVector, false, hitInfo2D.transform.position.z, false, 0.0f, false, 0.0f, durationInSec, hiddenByNearerObjects);
UtilitiesDXXL_DrawBasics.Reverse_coneLength_interpretation_forStraightVectors();
//normal socket:
DrawShapes.Decagon(impactPos_V3, 0.03f, color_ofNormal, normal_V3, default, 0.0f, null, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.invisible, false, false, durationInSec, hiddenByNearerObjects);
}
}
static Color Get_color_ofNormal()
{
if (UtilitiesDXXL_Colors.IsDefaultColor(DrawPhysics2D.overwriteColorForCastsHitNormals))
{
return Get_defaultColor_ofNormal();
}
else
{
return DrawPhysics2D.overwriteColorForCastsHitNormals;
}
}
public static Color Get_defaultColor_ofNormal()
{
return ((DrawPhysics2D.colorForHittingCasts.grayscale < 0.175f) ? Color.Lerp(DrawPhysics2D.colorForHittingCasts, Color.white, 0.7f) : Color.Lerp(DrawPhysics2D.colorForHittingCasts, Color.black, 0.7f));
}
static void DrawDashedLineAlongZ(Vector3 impactPos_V3, RaycastHit2D hitInfo2D, float durationInSec, bool hiddenByNearerObjects)
{
float absZDistance = Mathf.Abs(hitInfo2D.transform.position.z - GetZPosForDrawVisualisation());
Color color_forDashedLineAlongZ = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(DrawPhysics2D.colorForHittingCasts, 0.6f);
Vector3 impactPos_projectedOntoDrawVisualisation_V3 = UtilitiesDXXL_DrawBasics2D.Position_V2toV3(hitInfo2D.point, GetZPosForDrawVisualisation());
DrawBasics.LineStyle lineStyleAlongZ = (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes) ? DrawBasics.LineStyle.solid : DrawBasics.LineStyle.dashedLong;
Line_fadeableAnimSpeed.InternalDraw(impactPos_V3, impactPos_projectedOntoDrawVisualisation_V3, color_forDashedLineAlongZ, 0.0f, null, lineStyleAlongZ, absZDistance, 0.0f, null, default, false, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
}
static string GetTextAtHitPos_forVolumeCast(string volumeCastTypeSpecifyingStringPart, bool saveDrawnLines, RaycastHit2D hitInfo2D, int i_hit, string nameText)
{
if (DrawPhysics2D.drawCastNameTag_atHitPositions && nameText != null && nameText.Length != 0)
{
return (saveDrawnLines ? (nameText + " / #" + i_hit + ":<br>hit GO: " + hitInfo2D.transform.gameObject.name + "<br>pos = " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + "<br>dist = " + hitInfo2D.distance) : (UtilitiesDXXL_Physics.GetStrokeWidthMarkupStartStringForHitPosDesctiptionHeaders(nameText) + nameText + " / hit #" + i_hit + ":</sw><br>GameObject that was hit: " + hitInfo2D.transform.gameObject.name + "<br>hit pos = " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + "<br>distance = " + hitInfo2D.distance));
}
else
{
return (saveDrawnLines ? ("hit #" + i_hit + ":<br>hit GO: " + hitInfo2D.transform.gameObject.name + "<br>pos = " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + "<br>dist = " + hitInfo2D.distance) : (volumeCastTypeSpecifyingStringPart + i_hit + ":</sw><br>GameObject that was hit: " + hitInfo2D.transform.gameObject.name + "<br>hit pos = " + UtilitiesDXXL_Log.Get_vectorComponentsAsString(hitInfo2D.point) + "<br>distance = " + hitInfo2D.distance));
}
}
static void DrawTextDescriptionAtVolumeCastHitPos(Vector3 impactPos_V3, RaycastHit2D hitInfo2D, string nameText, string text, float durationInSec, bool hiddenByNearerObjects, string additionalWarningText)
{
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes) { return; }
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes)
{
if (DrawPhysics2D.drawCastNameTag_atHitPositions && nameText != null && nameText.Length != 0)
{
UtilitiesDXXL_Text.Write2DFramed(nameText + additionalWarningText, impactPos_V3, DrawPhysics2D.colorForCastsHitText, 0.1f * DrawPhysics2D.scaleFactor_forCastHitTextSize, 0.0f, DrawText.TextAnchorDXXL.LowerLeftOfFirstLine, hitInfo2D.transform.position.z, DrawBasics.LineStyle.invisible, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, true, durationInSec, hiddenByNearerObjects);
}
}
else
{
Vector2 textOffsetDir = default(Vector2);
float textOffsetDistance = DrawPhysics2D.scaleFactor_forCastHitTextSize;
TrySet_default_textOffsetDirection_forPointTags_reversible();
DrawBasics2D.PointTag(impactPos_V3, text + additionalWarningText, DrawPhysics2D.colorForCastsHitText, 0.0f, textOffsetDistance, textOffsetDir, hitInfo2D.transform.position.z, 1.0f, false, durationInSec, hiddenByNearerObjects);
TryReverse_default_textOffsetDirection_forPointTags();
}
}
static float GetDistanceOfSingleHit(bool hasHit, RaycastHit2D hitInfo2D)
{
if (hasHit)
{
if (UtilitiesDXXL_Math.FloatIsInvalid(hitInfo2D.distance))
{
Debug.LogError("Draw XXL: A 'Physics2D.Cast()' returned an invalid hit distance of '" + hitInfo2D.distance + "'. The drawn cast visualization may be incorrect.");
return 1.0f;
}
else
{
return hitInfo2D.distance;
}
}
else
{
return 0.0f;
}
}
static float GetDistanceOfFarestHit(RaycastHit2D[] hitInfos2D, int numberOfUsedSlotsInHitInfoArray)
{
float farestDistance = 0.0f;
if (hitInfos2D != null)
{
numberOfUsedSlotsInHitInfoArray = Mathf.Min(numberOfUsedSlotsInHitInfoArray, hitInfos2D.Length);
for (int i = 0; i < numberOfUsedSlotsInHitInfoArray; i++)
{
//"RaycastHit2D.distance" is always positive, also when the castDistance is negative.
if (UtilitiesDXXL_Math.FloatIsInvalid(hitInfos2D[i].distance))
{
Debug.LogError("Draw XXL: A 'Physics2D.Cast()' returned an invalid hit distance of '" + hitInfos2D[i].distance + "'. The drawn cast visualization may be incorrect.");
}
else
{
farestDistance = Mathf.Max(farestDistance, hitInfos2D[i].distance);
}
}
}
return farestDistance;
}
public static void DrawBoxOverlapResultOfMax1Collision(bool calledAsArea_insteadOfBox, Vector2 pos_V2, Vector2 size_V2, float angleDegCC, Collider2D overlappingCollider, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
DrawOverlapResultBoxOfMax1Collision(calledAsArea_insteadOfBox, overlappingCollider, pos_V2, size_V2, angleDegCC, nameTag, durationInSec, hiddenByNearerObjects);
bool shapeIsShrinkedToPoint = UtilitiesDXXL_Math.ApproximatelyZero(size_V2);
float approxSize_ofOverlapVolume = UtilitiesDXXL_Math.GetAverageBoxExtent(size_V2);
DrawMarkersAtOverlappingCollidersOfMax1Collision(shapeIsShrinkedToPoint, pos_V2, overlappingCollider, approxSize_ofOverlapVolume, durationInSec, hiddenByNearerObjects);
}
public static void DrawBoxOverlapResultOfPotMultipleCollisions(bool calledAsArea_insteadOfBox, Vector2 pos_V2, Vector2 size_V2, float angleDegCC, int numberOfOverlappingColliders, Collider2D[] overlappingColliders, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
bool doesOverlap = numberOfOverlappingColliders > 0;
DrawOverlapResultBoxOfPotMultipleCollisions(calledAsArea_insteadOfBox, doesOverlap, numberOfOverlappingColliders, overlappingColliders, pos_V2, size_V2, angleDegCC, nameTag, durationInSec, hiddenByNearerObjects);
bool shapeIsShrinkedToPoint = UtilitiesDXXL_Math.ApproximatelyZero(size_V2);
float approxSize_ofOverlapVolume = UtilitiesDXXL_Math.GetAverageBoxExtent(size_V2);
DrawMarkersAtOverlappingCollidersOfPotMultipleCollisions(shapeIsShrinkedToPoint, pos_V2, doesOverlap, overlappingColliders, numberOfOverlappingColliders, approxSize_ofOverlapVolume, durationInSec, hiddenByNearerObjects);
}
public static void DrawCapsuleOverlapResultOfMax1Collision(Vector2 pos_V2, Vector2 size_V2, CapsuleDirection2D capsuleDirection, float angleDegCC, Collider2D overlappingCollider, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
DrawOverlapResultCapsuleOfMax1Collision(overlappingCollider, pos_V2, size_V2, capsuleDirection, angleDegCC, nameTag, durationInSec, hiddenByNearerObjects);
bool shapeIsShrinkedToPoint = UtilitiesDXXL_Math.ApproximatelyZero(size_V2);
float approxSize_ofOverlapVolume = UtilitiesDXXL_Math.GetAverageBoxExtent(size_V2);
DrawMarkersAtOverlappingCollidersOfMax1Collision(shapeIsShrinkedToPoint, pos_V2, overlappingCollider, approxSize_ofOverlapVolume, durationInSec, hiddenByNearerObjects);
}
public static void DrawCapsuleOverlapResultOfPotMultipleCollisions(Vector2 pos_V2, Vector2 size_V2, CapsuleDirection2D capsuleDirection, float angleDegCC, int numberOfOverlappingColliders, Collider2D[] overlappingColliders, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
bool doesOverlap = numberOfOverlappingColliders > 0;
DrawOverlapResultCapsuleOfPotMultipleCollisions(doesOverlap, numberOfOverlappingColliders, overlappingColliders, pos_V2, size_V2, capsuleDirection, angleDegCC, nameTag, durationInSec, hiddenByNearerObjects);
bool shapeIsShrinkedToPoint = UtilitiesDXXL_Math.ApproximatelyZero(size_V2);
float approxSize_ofOverlapVolume = UtilitiesDXXL_Math.GetAverageBoxExtent(size_V2);
DrawMarkersAtOverlappingCollidersOfPotMultipleCollisions(shapeIsShrinkedToPoint, pos_V2, doesOverlap, overlappingColliders, numberOfOverlappingColliders, approxSize_ofOverlapVolume, durationInSec, hiddenByNearerObjects);
}
public static void DrawCircleOverlapResultOfMax1Collision(Vector2 pos_V2, float radius, Collider2D overlappingCollider, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
DrawOverlapResultCircleOfMax1Collision(overlappingCollider, pos_V2, radius, nameTag, durationInSec, hiddenByNearerObjects);
bool shapeIsShrinkedToPoint = UtilitiesDXXL_Math.ApproximatelyZero(radius);
float approxSize_ofOverlapVolume = 2.0f * radius;
DrawMarkersAtOverlappingCollidersOfMax1Collision(shapeIsShrinkedToPoint, pos_V2, overlappingCollider, approxSize_ofOverlapVolume, durationInSec, hiddenByNearerObjects);
}
public static void DrawCircleOverlapResultOfPotMultipleCollisions(Vector2 pos_V2, float radius, int numberOfOverlappingColliders, Collider2D[] overlappingColliders, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
bool doesOverlap = numberOfOverlappingColliders > 0;
DrawOverlapResultCircleOfPotMultipleCollisions(doesOverlap, numberOfOverlappingColliders, overlappingColliders, pos_V2, radius, nameTag, durationInSec, hiddenByNearerObjects);
bool shapeIsShrinkedToPoint = UtilitiesDXXL_Math.ApproximatelyZero(radius);
float approxSize_ofOverlapVolume = 2.0f * radius;
DrawMarkersAtOverlappingCollidersOfPotMultipleCollisions(shapeIsShrinkedToPoint, pos_V2, doesOverlap, overlappingColliders, numberOfOverlappingColliders, approxSize_ofOverlapVolume, durationInSec, hiddenByNearerObjects);
}
public static void DrawPointOverlapResultOfMax1Collision(Vector2 pos_V2, Collider2D overlappingCollider, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
DrawOverlapResultPointOfMax1Collision(overlappingCollider, pos_V2, nameTag, durationInSec, hiddenByNearerObjects);
bool shapeIsShrinkedToPoint = true;
float approxSize_ofOverlapVolume = 0.5f;
DrawMarkersAtOverlappingCollidersOfMax1Collision(shapeIsShrinkedToPoint, pos_V2, overlappingCollider, approxSize_ofOverlapVolume, durationInSec, hiddenByNearerObjects);
}
public static void DrawPointOverlapResultOfPotMultipleCollisions(Vector2 pos_V2, int numberOfOverlappingColliders, Collider2D[] overlappingColliders, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
bool doesOverlap = numberOfOverlappingColliders > 0;
DrawOverlapResultPointOfPotMultipleCollisions(doesOverlap, numberOfOverlappingColliders, overlappingColliders, pos_V2, nameTag, durationInSec, hiddenByNearerObjects);
bool shapeIsShrinkedToPoint = true;
float approxSize_ofOverlapVolume = 0.5f;
DrawMarkersAtOverlappingCollidersOfPotMultipleCollisions(shapeIsShrinkedToPoint, pos_V2, doesOverlap, overlappingColliders, numberOfOverlappingColliders, approxSize_ofOverlapVolume, durationInSec, hiddenByNearerObjects);
}
static void DrawOverlapResultBoxOfMax1Collision(bool calledAsArea_insteadOfBox, Collider2D overlappingCollider, Vector2 pos_V2, Vector2 size_V2, float angleDegCC, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
bool doesOverlap = overlappingCollider != null;
string text = null;
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
string additinalWarningText = null;
if (calledAsArea_insteadOfBox == false)
{
bool shapeContainsNegativeDimensions = UtilitiesDXXL_Math.ContainsNegativeComponents(size_V2);
additinalWarningText = shapeContainsNegativeDimensions ? "[<color=#e2aa00FF><icon=warning></color> box contains negative dimensions -> potentially collisions missing]<br>" : null;
}
text = additinalWarningText + GetTextForVolumeOverlapCheckOfMax1Collision(calledAsArea_insteadOfBox ? "Area2D: Overlap check (max 1)" : "Box2D: Overlap check (max 1)", doesOverlap, nameTag, overlappingCollider);
}
DrawOverlapBox(doesOverlap, pos_V2, size_V2, angleDegCC, text, durationInSec, hiddenByNearerObjects);
}
static void DrawOverlapResultCapsuleOfMax1Collision(Collider2D overlappingCollider, Vector2 pos_V2, Vector2 size_V2, CapsuleDirection2D capsuleDirection, float angleDegCC, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
bool doesOverlap = overlappingCollider != null;
string text = null;
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
bool shapeContainsNegativeDimensions = UtilitiesDXXL_Math.ContainsNegativeComponents(size_V2);
string additinalWarningText = shapeContainsNegativeDimensions ? "[<color=#e2aa00FF><icon=warning></color> capsule contains negative dimensions -> potentially collisions missing]<br>" : null;
text = additinalWarningText + GetTextForVolumeOverlapCheckOfMax1Collision("Capsule2D: Overlap check (max 1)", doesOverlap, nameTag, overlappingCollider);
}
DrawOverlapCapsule(doesOverlap, pos_V2, size_V2, capsuleDirection, angleDegCC, text, durationInSec, hiddenByNearerObjects);
}
static void DrawOverlapResultCircleOfMax1Collision(Collider2D overlappingCollider, Vector2 pos_V2, float radius, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
bool doesOverlap = overlappingCollider != null;
string text = null;
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
string additinalWarningText = (radius < 0.0f) ? "[<color=#e2aa00FF><icon=warning></color> negative circle radius -> collision test only with circle center and/or potentially collisions missing]<br>" : null;
text = additinalWarningText + GetTextForVolumeOverlapCheckOfMax1Collision("Circle2D: Overlap check (max 1)", doesOverlap, nameTag, overlappingCollider);
}
DrawOverlapCircle(doesOverlap, pos_V2, radius, text, durationInSec, hiddenByNearerObjects);
}
static void DrawOverlapResultPointOfMax1Collision(Collider2D overlappingCollider, Vector2 pos_V2, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
bool doesOverlap = overlappingCollider != null;
string text = null;
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
text = GetTextForVolumeOverlapCheckOfMax1Collision("Point2D: Overlap check (max 1)", doesOverlap, nameTag, overlappingCollider);
}
DrawOverlapPoint(doesOverlap, pos_V2, text, durationInSec, hiddenByNearerObjects);
}
static void DrawOverlapResultBoxOfPotMultipleCollisions(bool calledAsArea_insteadOfBox, bool doesOverlap, int numberOfOverlappingColliders, Collider2D[] overlappingColliders, Vector2 pos_V2, Vector2 size_V2, float angleDegCC, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
string text = null;
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
string additinalWarningText = null;
if (calledAsArea_insteadOfBox == false)
{
bool shapeContainsNegativeDimensions = UtilitiesDXXL_Math.ContainsNegativeComponents(size_V2);
additinalWarningText = shapeContainsNegativeDimensions ? "[<color=#e2aa00FF><icon=warning></color> box contains negative dimensions -> potentially collisions missing]<br>" : null;
}
string overlappingCollidersListAsText = GetOverlappingCollidersListAsText(overlappingColliders, numberOfOverlappingColliders);
text = additinalWarningText + GetTextForVolumeOverlapCheckOfPotMultipleCollisions(calledAsArea_insteadOfBox ? "Area2D: Overlap check" : "Box2D: Overlap check", doesOverlap, numberOfOverlappingColliders, nameTag, overlappingCollidersListAsText);
}
DrawOverlapBox(doesOverlap, pos_V2, size_V2, angleDegCC, text, durationInSec, hiddenByNearerObjects);
}
static void DrawOverlapResultCapsuleOfPotMultipleCollisions(bool doesOverlap, int numberOfOverlappingColliders, Collider2D[] overlappingColliders, Vector2 pos_V2, Vector2 size_V2, CapsuleDirection2D capsuleDirection, float angleDegCC, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
string text = null;
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
bool shapeContainsNegativeDimensions = UtilitiesDXXL_Math.ContainsNegativeComponents(size_V2);
string additinalWarningText = shapeContainsNegativeDimensions ? "[<color=#e2aa00FF><icon=warning></color> capsule contains negative dimensions -> potentially collisions missing]<br>" : null;
string overlappingCollidersListAsText = GetOverlappingCollidersListAsText(overlappingColliders, numberOfOverlappingColliders);
text = additinalWarningText + GetTextForVolumeOverlapCheckOfPotMultipleCollisions("Capsule2D: Overlap check", doesOverlap, numberOfOverlappingColliders, nameTag, overlappingCollidersListAsText);
}
DrawOverlapCapsule(doesOverlap, pos_V2, size_V2, capsuleDirection, angleDegCC, text, durationInSec, hiddenByNearerObjects);
}
static void DrawOverlapResultCircleOfPotMultipleCollisions(bool doesOverlap, int numberOfOverlappingColliders, Collider2D[] overlappingColliders, Vector2 pos_V2, float radius, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
string text = null;
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
string additinalWarningText = (radius < 0.0f) ? "[<color=#e2aa00FF><icon=warning></color> negative circle radius -> collision test only with circle center and/or potentially collisions missing]<br>" : null;
string overlappingCollidersListAsText = GetOverlappingCollidersListAsText(overlappingColliders, numberOfOverlappingColliders);
text = additinalWarningText + GetTextForVolumeOverlapCheckOfPotMultipleCollisions("Circle2D: Overlap check", doesOverlap, numberOfOverlappingColliders, nameTag, overlappingCollidersListAsText);
}
DrawOverlapCircle(doesOverlap, pos_V2, radius, text, durationInSec, hiddenByNearerObjects);
}
static void DrawOverlapResultPointOfPotMultipleCollisions(bool doesOverlap, int numberOfOverlappingColliders, Collider2D[] overlappingColliders, Vector2 pos_V2, string nameTag, float durationInSec, bool hiddenByNearerObjects)
{
string text = null;
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
string overlappingCollidersListAsText = GetOverlappingCollidersListAsText(overlappingColliders, numberOfOverlappingColliders);
text = GetTextForVolumeOverlapCheckOfPotMultipleCollisions("Point2D: Overlap check", doesOverlap, numberOfOverlappingColliders, nameTag, overlappingCollidersListAsText);
}
UtilitiesDXXL_DrawBasics.Set_strokeWidth_forCoordinateTexts_onPointVisualiation_inPPM_reversible(0);
DrawOverlapPoint(doesOverlap, pos_V2, text, durationInSec, hiddenByNearerObjects);
UtilitiesDXXL_DrawBasics.Reverse_strokeWidth_forCoordinateTexts_onPointVisualiation_inPPM();
}
static string GetOverlappingCollidersListAsText(Collider2D[] overlappingColliders, int numberOfOverlappingColliders)
{
if (overlappingColliders == null)
{
return null;
}
else
{
if (overlappingColliders.Length == 0)
{
return null;
}
else
{
if (numberOfOverlappingColliders <= 0)
{
return null;
}
else
{
string collidersList = null;
for (int i = 0; i < numberOfOverlappingColliders; i++)
{
if (i < DrawPhysics2D.MaxListedColliders_inOverlapVolumesTextList)
{
//collidersList = overlappingColliders[i].GetType().ToString() + " (on GameObject '" + overlappingColliders[i].gameObject.name + "')<br>" + collidersList; //-> first found collider is on bottom. This contradicts the "DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes"-hitPos-display, which only displays the index-number
collidersList = collidersList + "<br>" + overlappingColliders[i].GetType().ToString() + " (on GameObject '" + overlappingColliders[i].gameObject.name + "')"; //-> first found collider is on top. This corresponds to the "DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes"-hitPos-display, which only, which only displays the index-number
}
else
{
collidersList = collidersList + "<br>...and " + (numberOfOverlappingColliders - DrawPhysics2D.MaxListedColliders_inOverlapVolumesTextList) + " more.";
break;
}
}
return collidersList;
}
}
}
}
static string GetTextForVolumeOverlapCheckOfMax1Collision(string volumeTypeIdentifyingStringPart, bool doesOverlap, string nameTag, Collider2D overlappingCollider)
{
if (nameTag != null && nameTag.Length != 0)
{
//has user specified "nameTag":
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes)
{
if (doesOverlap)
{
return (nameTag + "<br>Overlapping at least with:<br>" + overlappingCollider.GetType().ToString() + " (on GameObject '" + overlappingCollider.gameObject.name + "')");
}
else
{
return nameTag;
}
}
else
{
if (doesOverlap)
{
return (nameTag + "<br>Overlapping at least with this collider:<br>" + overlappingCollider.GetType().ToString() + " (on GameObject '" + overlappingCollider.gameObject.name + "')");
}
else
{
return (nameTag + "<br>Result: Is not overlapping with any collider");
}
}
}
else
{
//has NO user specified "nameTag":
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes)
{
if (doesOverlap)
{
return ("Overlapping at least with:<br>" + overlappingCollider.GetType().ToString() + " (on GameObject '" + overlappingCollider.gameObject.name + "')");
}
else
{
return null;
}
}
else
{
if (doesOverlap)
{
return (volumeTypeIdentifyingStringPart + "<br>Overlapping at least with this collider:<br>" + overlappingCollider.GetType().ToString() + " (on GameObject '" + overlappingCollider.gameObject.name + "')");
}
else
{
return (volumeTypeIdentifyingStringPart + "<br>Result: Is not overlapping with any collider");
}
}
}
}
static string GetTextForVolumeOverlapCheckOfPotMultipleCollisions(string volumeTypeIdentifyingStringPart, bool doesOverlap, int numberOfOverlappingColliders, string nameTag, string overlappingCollidersListAsText)
{
if (nameTag != null && nameTag.Length != 0)
{
//has user specified "nameTag":
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes)
{
if (doesOverlap)
{
return (nameTag + "<br>Overlapping with these " + numberOfOverlappingColliders + ":<br>" + overlappingCollidersListAsText);
}
else
{
return nameTag;
}
}
else
{
if (doesOverlap)
{
return (nameTag + "<br>Overlapping with these " + numberOfOverlappingColliders + " collider(s):<br>" + overlappingCollidersListAsText);
}
else
{
return (nameTag + "<br>Result: Is not overlapping with any collider");
}
}
}
else
{
//has NO user specified "nameTag":
if (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes)
{
if (doesOverlap)
{
return ("Overlapping with these " + numberOfOverlappingColliders + ":<br>" + overlappingCollidersListAsText);
}
else
{
return null;
}
}
else
{
if (doesOverlap)
{
return (volumeTypeIdentifyingStringPart + "<br>Overlapping with these " + numberOfOverlappingColliders + " collider(s):<br>" + overlappingCollidersListAsText);
}
else
{
return (volumeTypeIdentifyingStringPart + "<br>Result: Is not overlapping with any collider");
}
}
}
}
static void DrawOverlapBox(bool doesOverlap, Vector2 pos_V2, Vector2 size_V2, float angleDegCC, string text, float durationInSec, bool hiddenByNearerObjects)
{
Color color = doesOverlap ? DrawPhysics2D.colorForHittingCasts : DrawPhysics2D.colorForNonHittingCasts;
UtilitiesDXXL_Shapes.Set_bothForcedConstantTextSizes_forTextAtShapes_reversible(DrawPhysics2D.forcedConstantScreenspaceTextSize_relToScreenHeight_forOverlapResultTexts, DrawPhysics2D.forcedConstantWorldspaceTextSize_forOverlapResultTexts);
DrawShapes.Box2D(pos_V2, size_V2, color, GetZPosForDrawVisualisation(), angleDegCC, DrawShapes.Shape2DType.square, 0.0f, text, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.invisible, true, durationInSec, hiddenByNearerObjects);
UtilitiesDXXL_Shapes.Reverse_disable_bothForcedConstantTextSizes_forTextAtShapes();
}
static void DrawOverlapCapsule(bool doesOverlap, Vector2 pos_V2, Vector2 size_V2, CapsuleDirection2D capsuleDirection, float angleDegCC, string text, float durationInSec, bool hiddenByNearerObjects)
{
Color color = doesOverlap ? DrawPhysics2D.colorForHittingCasts : DrawPhysics2D.colorForNonHittingCasts;
UtilitiesDXXL_Shapes.Set_bothForcedConstantTextSizes_forTextAtShapes_reversible(DrawPhysics2D.forcedConstantScreenspaceTextSize_relToScreenHeight_forOverlapResultTexts, DrawPhysics2D.forcedConstantWorldspaceTextSize_forOverlapResultTexts);
DrawShapes.Capsule2D(pos_V2, size_V2, color, GetZPosForDrawVisualisation(), capsuleDirection, angleDegCC, 0.0f, text, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.invisible, false, true, durationInSec, hiddenByNearerObjects);
UtilitiesDXXL_Shapes.Reverse_disable_bothForcedConstantTextSizes_forTextAtShapes();
}
static void DrawOverlapCircle(bool doesOverlap, Vector2 pos_V2, float radius, string text, float durationInSec, bool hiddenByNearerObjects)
{
Color color = doesOverlap ? DrawPhysics2D.colorForHittingCasts : DrawPhysics2D.colorForNonHittingCasts;
UtilitiesDXXL_Shapes.Set_bothForcedConstantTextSizes_forTextAtShapes_reversible(DrawPhysics2D.forcedConstantScreenspaceTextSize_relToScreenHeight_forOverlapResultTexts, DrawPhysics2D.forcedConstantWorldspaceTextSize_forOverlapResultTexts);
DrawShapes.Circle2D(pos_V2, radius, color, GetZPosForDrawVisualisation(), 0.0f, text, DrawBasics.LineStyle.solid, 1.0f, DrawBasics.LineStyle.invisible, true, durationInSec, hiddenByNearerObjects);
UtilitiesDXXL_Shapes.Reverse_disable_bothForcedConstantTextSizes_forTextAtShapes();
}
static void DrawOverlapPoint(bool doesOverlap, Vector2 pos_V2, string text, float durationInSec, bool hiddenByNearerObjects)
{
Color color = doesOverlap ? DrawPhysics2D.colorForHittingCasts : DrawPhysics2D.colorForNonHittingCasts;
bool drawCoordsAsText = (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes);
DrawBasics2D.Point(pos_V2, text, color, 0.5f, 0.0f, GetZPosForDrawVisualisation(), color, 0.0f, true, drawCoordsAsText, durationInSec, hiddenByNearerObjects);
}
static void DrawMarkersAtOverlappingCollidersOfMax1Collision(bool shapeIsShrinkedToPoint, Vector2 posOfCheckingShape_V2, Collider2D overlappingCollider, float approxSize_ofOverlapVolume, float durationInSec, bool hiddenByNearerObjects)
{
bool doesOverlap = overlappingCollider != null;
if (doesOverlap)
{
Color color_ofMarkers = (DrawPhysics2D.colorForHittingCasts.grayscale < 0.175f) ? Color.Lerp(DrawPhysics2D.colorForHittingCasts, Color.white, 0.7f) : Color.Lerp(DrawPhysics2D.colorForHittingCasts, Color.black, 0.7f);
Color color_ofMarkerExtentionLineToShapeCenter = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(DrawPhysics2D.colorForHittingCasts, 0.2f);
Color color_forDashedLineAlongZ = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(DrawPhysics2D.colorForHittingCasts, 0.6f);
int i_collisionOfPointShrinkedShape = shapeIsShrinkedToPoint ? 0 : (-1);
string shorterFallbackNameText = (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes) ? "hit" : null;
DrawMarkersAtOverlappingColliders(i_collisionOfPointShrinkedShape, posOfCheckingShape_V2, overlappingCollider, color_ofMarkers, color_ofMarkerExtentionLineToShapeCenter, color_forDashedLineAlongZ, shorterFallbackNameText, approxSize_ofOverlapVolume, durationInSec, hiddenByNearerObjects);
}
}
static void DrawMarkersAtOverlappingCollidersOfPotMultipleCollisions(bool shapeIsShrinkedToPoint, Vector2 posOfCheckingShape_V2, bool doesOverlap, Collider2D[] overlappingColliders, int numberOfOverlappingColliders, float approxSize_ofOverlapVolume, float durationInSec, bool hiddenByNearerObjects)
{
if (doesOverlap)
{
Color color_ofMarkers = (DrawPhysics2D.colorForHittingCasts.grayscale < 0.175f) ? Color.Lerp(DrawPhysics2D.colorForHittingCasts, Color.white, 0.7f) : Color.Lerp(DrawPhysics2D.colorForHittingCasts, Color.black, 0.7f);
Color color_ofMarkerExtentionLineToShapeCenter = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(DrawPhysics2D.colorForHittingCasts, 0.1f);
Color color_forDashedLineAlongZ = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(DrawPhysics2D.colorForHittingCasts, 0.6f);
numberOfOverlappingColliders = Mathf.Min(numberOfOverlappingColliders, overlappingColliders.Length);
for (int i = 0; i < numberOfOverlappingColliders; i++)
{
string shorterFallbackNameText = null;
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
if ((DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.medium_meaningReducedTextAndSilhouettes) || (i >= DrawPhysics2D.maxOverlapingCollidersWithUntruncatedText))
{
shorterFallbackNameText = "" + i;
}
}
int i_collisionOfPointShrinkedShape = shapeIsShrinkedToPoint ? i : (-1);
DrawMarkersAtOverlappingColliders(i_collisionOfPointShrinkedShape, posOfCheckingShape_V2, overlappingColliders[i], color_ofMarkers, color_ofMarkerExtentionLineToShapeCenter, color_forDashedLineAlongZ, shorterFallbackNameText, approxSize_ofOverlapVolume, durationInSec, hiddenByNearerObjects);
}
}
}
static void DrawMarkersAtOverlappingColliders(int i_collisionOfPointShrinkedShape, Vector2 posOfCheckingShape_V2, Collider2D overlappingCollider, Color color_ofMarkers, Color color_ofMarkerExtentionLineToShapeCenter, Color color_forDashedLineAlongZ, string shorterFallbackNameText, float approxSize_ofOverlapVolume, float durationInSec, bool hiddenByNearerObjects)
{
//thin line from shape center:
Vector2 nearestPosOnCollider_V2 = overlappingCollider.ClosestPoint(posOfCheckingShape_V2);
Line_fadeableAnimSpeed_2D.InternalDraw(posOfCheckingShape_V2, nearestPosOnCollider_V2, color_ofMarkerExtentionLineToShapeCenter, 0.0f, null, DrawBasics.LineStyle.solid, GetZPosForDrawVisualisation(), 1.0f, 0.0f, null, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
//dashed line along z to collider:
float absZDistance = Mathf.Abs(overlappingCollider.transform.position.z - GetZPosForDrawVisualisation());
Vector3 nearestPosOnCollider_V3 = UtilitiesDXXL_DrawBasics2D.Position_V2toV3(nearestPosOnCollider_V2, overlappingCollider.transform.position.z);
Vector3 nearestPosOnCollider_insideDrawXYplane_V3 = UtilitiesDXXL_DrawBasics2D.Position_V2toV3(nearestPosOnCollider_V2, GetZPosForDrawVisualisation());
DrawBasics.LineStyle lineStyleAlongZ = (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes) ? DrawBasics.LineStyle.solid : DrawBasics.LineStyle.dashedLong;
Line_fadeableAnimSpeed.InternalDraw(nearestPosOnCollider_V3, nearestPosOnCollider_insideDrawXYplane_V3, color_forDashedLineAlongZ, 0.0f, null, lineStyleAlongZ, absZDistance, 0.0f, null, default, false, 0.0f, 0.0f, 0.0f, durationInSec, hiddenByNearerObjects, false, false);
//collider marking:
float sizeOfMarkingCross = Mathf.Max(0.1f * approxSize_ofOverlapVolume, 0.001f);
bool drawCoordsAsText = (DrawPhysics2D.visualizationQuality == DrawPhysics.VisualizationQuality.high_withFullDetails);
DrawBasics2D.Point(nearestPosOnCollider_V2, DrawPhysics2D.colorForHittingCasts, sizeOfMarkingCross, 0.0f, 0.0f, null, DrawPhysics2D.colorForHittingCasts, overlappingCollider.transform.position.z, false, drawCoordsAsText, durationInSec, hiddenByNearerObjects);
if (DrawPhysics2D.visualizationQuality != DrawPhysics.VisualizationQuality.low_withoutAnyTextOrSilhouettes)
{
string text = (shorterFallbackNameText != null) ? shorterFallbackNameText : (overlappingCollider.GetType().ToString() + " (on GameObject '" + overlappingCollider.gameObject.name + "')");
float textOffsetDistance;
Vector2 textOffsetDir_V2;
float relTextSizeScaling;
if (i_collisionOfPointShrinkedShape < 0)
{
textOffsetDir_V2 = nearestPosOnCollider_V2 - posOfCheckingShape_V2;
textOffsetDistance = 1.0f;
relTextSizeScaling = 1.0f;
}
else
{
Quaternion rotation = Quaternion.AngleAxis(-75.0f - 2.22f * i_collisionOfPointShrinkedShape, Vector3.forward);
textOffsetDir_V2 = rotation * Vector3.right;
textOffsetDistance = 1.0f + 0.2f + i_collisionOfPointShrinkedShape;
relTextSizeScaling = 1.0f / textOffsetDistance;
}
DrawBasics2D.PointTag(nearestPosOnCollider_V2, text, color_ofMarkers, 0.0f, textOffsetDistance, textOffsetDir_V2, overlappingCollider.transform.position.z, relTextSizeScaling, true, durationInSec, hiddenByNearerObjects);
}
}
static float GetZPosForDrawVisualisation()
{
if (float.IsNaN(DrawPhysics2D.custom_zPos_forCastVisualisation) || float.IsInfinity(DrawPhysics2D.custom_zPos_forCastVisualisation))
{
return DrawBasics2D.Default_zPos_forDrawing;
}
else
{
return DrawPhysics2D.custom_zPos_forCastVisualisation;
}
}
public static bool ExtentNameTagForNonSuitingResultArray(ref string nameTag, int numberOfOverlappingColliders, Collider2D[] resultsArray)
{
bool resultsArrayIsNull = (resultsArray == null);
UtilitiesDXXL_Physics.ExtentNameTagForNonSuitingResultArray(ref nameTag, numberOfOverlappingColliders, resultsArrayIsNull, resultsArrayIsNull ? 0 : resultsArray.Length);
return resultsArrayIsNull;
}
public static bool ExtentNameTagForNonSuitingResultArray(ref string nameTag, int numberOfUsedSlotsInHitInfoArray, RaycastHit2D[] resultsArray)
{
bool resultsArrayIsNull = (resultsArray == null);
UtilitiesDXXL_Physics.ExtentNameTagForNonSuitingResultArray(ref nameTag, numberOfUsedSlotsInHitInfoArray, resultsArrayIsNull, resultsArrayIsNull ? 0 : resultsArray.Length);
return resultsArrayIsNull;
}
public static bool ExtentNameTagForNonSuitingResultList(ref string nameTag, int numberOfUsedSlotsInList, List<RaycastHit2D> resultsList)
{
bool resultsListIsNull = (resultsList == null);
UtilitiesDXXL_Physics.ExtentNameTagForNonSuitingResultList(ref nameTag, resultsListIsNull, resultsListIsNull ? 0 : numberOfUsedSlotsInList);
return resultsListIsNull;
}
public static bool ExtentNameTagForNonSuitingResultList(ref string nameTag, int numberOfUsedSlotsInList, List<Collider2D> resultsList)
{
bool resultsListIsNull = (resultsList == null);
UtilitiesDXXL_Physics.ExtentNameTagForNonSuitingResultList(ref nameTag, resultsListIsNull, resultsListIsNull ? 0 : numberOfUsedSlotsInList);
return resultsListIsNull;
}
public static int CopyHitResultsFromListToPreallocatedArray(out bool preallocatedArrayIsTooSmall, List<RaycastHit2D> resultsList, int numberOfUsedSlotsInResultsList)
{
if (resultsList != null)
{
preallocatedArrayIsTooSmall = numberOfUsedSlotsInResultsList > preallocatedRayHit2DResultsArray_copiedFromList.Length;
int numberOfCopiedSlots = Mathf.Min(numberOfUsedSlotsInResultsList, preallocatedRayHit2DResultsArray_copiedFromList.Length);
for (int i = 0; i < numberOfCopiedSlots; i++)
{
preallocatedRayHit2DResultsArray_copiedFromList[i] = resultsList[i];
}
return numberOfCopiedSlots;
}
else
{
preallocatedArrayIsTooSmall = false;
return 0;
}
}
public static int CopyHitResultsFromListToPreallocatedArray(out bool preallocatedArrayIsTooSmall, List<Collider2D> colliderList, int numberOfUsedSlotsInResultsList)
{
if (colliderList != null)
{
preallocatedArrayIsTooSmall = numberOfUsedSlotsInResultsList > preallocatedCollider2DResultsArray_copiedFromList.Length;
int numberOfCopiedSlots = Mathf.Min(numberOfUsedSlotsInResultsList, preallocatedCollider2DResultsArray_copiedFromList.Length);
for (int i = 0; i < numberOfCopiedSlots; i++)
{
preallocatedCollider2DResultsArray_copiedFromList[i] = colliderList[i];
}
return numberOfCopiedSlots;
}
else
{
preallocatedArrayIsTooSmall = false;
return 0;
}
}
public static void ExtentNameTagForPreallocatedArrayIsTooSmallForFilledInListResults(bool preallocatedArrayIsTooSmall, ref string nameTag, int numberOfUsedSlotsInResultsList)
{
//"ExtentNameTagForNonSuitingResultList" already cares for this
return;
//if (preallocatedArrayIsTooSmall)
//{
// int numberOfNotDrawnCollisions = numberOfUsedSlotsInResultsList - DrawPhysics2D.MaxNumberOfPreallocatedHits;
// nameTag = "[<color=#e2aa00FF><icon=warning></color> DrawPhysics2D internal result buffer (of " + DrawPhysics2D.MaxNumberOfPreallocatedHits + ") is full<br>-> " + numberOfNotDrawnCollisions + " results are not drawn<br>-> Fix by increasing 'DrawPhysics2D.MaxNumberOfPreallocatedHits']<br>" + nameTag;
//}
}
public static void Area2D_to_Box2D(out Vector2 boxCenterPos_V2, out Vector2 boxSize_V2, Vector2 areaPointA, Vector2 areaPointB)
{
if (UtilitiesDXXL_Math.CheckIf_twoVectorsAreApproximatelyEqual(areaPointA, areaPointB))
{
boxSize_V2 = Vector2.zero;
}
else
{
boxSize_V2 = UtilitiesDXXL_Math.Abs(areaPointB - areaPointA);
}
boxCenterPos_V2 = 0.5f * (areaPointA + areaPointB);
}
static float scaleFactor_forCastHitTextSize_before;
public static void Set_scaleFactor_forCastHitTextSize_reversible(float new_scaleFactor_forCastHitTextSize)
{
scaleFactor_forCastHitTextSize_before = DrawPhysics2D.scaleFactor_forCastHitTextSize;
DrawPhysics2D.scaleFactor_forCastHitTextSize = new_scaleFactor_forCastHitTextSize;
}
public static void Reverse_scaleFactor_forCastHitTextSize()
{
DrawPhysics2D.scaleFactor_forCastHitTextSize = scaleFactor_forCastHitTextSize_before;
}
static float castCorridorVisualizerDensity_before;
public static void Set_castCorridorVisualizerDensity_reversible(float new_castCorridorVisualizerDensity)
{
castCorridorVisualizerDensity_before = DrawPhysics2D.castCorridorVisualizerDensity;
DrawPhysics2D.castCorridorVisualizerDensity = new_castCorridorVisualizerDensity;
}
public static void Reverse_castCorridorVisualizerDensity()
{
DrawPhysics2D.castCorridorVisualizerDensity = castCorridorVisualizerDensity_before;
}
static float forcedConstantScreenspaceTextSize_relToScreenHeight_forOverlapResultTexts_before;
public static void Set_forcedConstantScreenspaceTextSize_relToScreenHeight_forOverlapResultTexts_reversible(float new_forcedConstantScreenspaceTextSize_relToScreenHeight_forOverlapResultTexts)
{
forcedConstantScreenspaceTextSize_relToScreenHeight_forOverlapResultTexts_before = DrawPhysics2D.forcedConstantScreenspaceTextSize_relToScreenHeight_forOverlapResultTexts;
DrawPhysics2D.forcedConstantScreenspaceTextSize_relToScreenHeight_forOverlapResultTexts = new_forcedConstantScreenspaceTextSize_relToScreenHeight_forOverlapResultTexts;
}
public static void Reverse_forcedConstantScreenspaceTextSize_relToScreenHeight_forOverlapResultTexts()
{
DrawPhysics2D.forcedConstantScreenspaceTextSize_relToScreenHeight_forOverlapResultTexts = forcedConstantScreenspaceTextSize_relToScreenHeight_forOverlapResultTexts_before;
}
static float forcedConstantWorldspaceTextSize_forOverlapResultTexts_before;
public static void Set_forcedConstantWorldspaceTextSize_forOverlapResultTexts_reversible(float new_forcedConstantWorldspaceTextSize_forOverlapResultTexts)
{
forcedConstantWorldspaceTextSize_forOverlapResultTexts_before = DrawPhysics2D.forcedConstantWorldspaceTextSize_forOverlapResultTexts;
DrawPhysics2D.forcedConstantWorldspaceTextSize_forOverlapResultTexts = new_forcedConstantWorldspaceTextSize_forOverlapResultTexts;
}
public static void Reverse_forcedConstantWorldspaceTextSize_forOverlapResultTexts()
{
DrawPhysics2D.forcedConstantWorldspaceTextSize_forOverlapResultTexts = forcedConstantWorldspaceTextSize_forOverlapResultTexts_before;
}
static Vector2 directionOfHitResultText_before;
public static void Set_directionOfHitResultText_reversible(Vector2 new_directionOfHitResultText)
{
directionOfHitResultText_before = DrawPhysics2D.directionOfHitResultText;
DrawPhysics2D.directionOfHitResultText = new_directionOfHitResultText;
}
public static void Reverse_directionOfHitResultText()
{
DrawPhysics2D.directionOfHitResultText = directionOfHitResultText_before;
}
static Vector3 default_textOffsetDirection_forPointTags_before;
public static void TrySet_default_textOffsetDirection_forPointTags_reversible()
{
if (UtilitiesDXXL_Math.IsDefaultVector(DrawPhysics2D.directionOfHitResultText) == false)
{
default_textOffsetDirection_forPointTags_before = DrawBasics.Default_textOffsetDirection_forPointTags;
DrawBasics.Default_textOffsetDirection_forPointTags = new Vector3(DrawPhysics2D.directionOfHitResultText.x, DrawPhysics2D.directionOfHitResultText.y, 0.0f);
}
}
public static void TryReverse_default_textOffsetDirection_forPointTags()
{
if (UtilitiesDXXL_Math.IsDefaultVector(DrawPhysics2D.directionOfHitResultText) == false)
{
DrawBasics.Default_textOffsetDirection_forPointTags = default_textOffsetDirection_forPointTags_before;
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink