public bool Contains(AaRect small)
{
return(min.x <= small.min.x &&
max.x >= small.max.x &&
min.y <= small.min.y &&
max.y >= small.max.y);
}
public override void TraverseOverlapping(T queryBody, Action <T> action)
{
var rect = GetBodyFitRect(queryBody);
if (type == TreeType.Bag)
{
var skipped = 0;
foreach (var body in bodies)
{
if (AaRect.Overlaps(GetBodyFitRect(body), rect))
{
action(body);
}
else
{
skipped++;
}
}
return;
}
if (root != null)
{
PossibleCollisionsUsingTree(rect, root, action);
}
}
public AaRect GetBodyFatRect(Rigidbody body)
{
var rect = GetBodyFitRect(body);
var fat = rect.ExtendSides(rect.GetSize() * fatSizeFactor);
var maxSize = fat.GetMaxSize() * fatVelocityMaxFactor;
var translation = (body.positionVelocity * fatVelocityFactor).Clamp(maxSize);
return(AaRect.Merge(fat, fat.Translate(translation)));
}
public static bool Include(ref AaRect bounds, AaRect newrect)
{
if (bounds.Contains(newrect))
{
return(false);
}
bounds = AaRect.Merge(bounds, newrect);
return(true);
}
public override void TraverseOverlapping(T body, Action <T> action)
{
var rect = GetBodyFitRect(body);
foreach (var b in bodies)
{
if (AaRect.Overlaps(GetBodyFitRect(b), rect))
{
action(b);
}
}
}
public static AaRect?MergeNullable(AaRect?a, AaRect?b)
{
if (!a.HasValue)
{
return(b);
}
if (!b.HasValue)
{
return(a);
}
return(AaRect.Merge(a.Value, b.Value));
}
public static AaRect MergeAll(IEnumerable <AaRect> rects)
{
bool first = true;
AaRect result = default;
foreach (var r in rects)
{
if (first)
{
first = false;
result = r;
}
else
{
result = AaRect.Merge(result, r);
}
}
return(result);
}
private void PossibleCollisionsUsingTree(AaRect rect, AabbTreeNode <T> node, Action <T> action)
{
if (!AaRect.Overlaps(rect, node.bounds))
{
return;
}
marks?.Add(node);
if (node.leaf)
{
if (AaRect.Overlaps(rect, GetBodyFitRect(node.body)))
{
action?.Invoke(node.body);
}
}
else
{
foreach (var child in node.children)
{
PossibleCollisionsUsingTree(rect, child, action);
}
}
}
public static AaRect Merge(AaRect a, AaRect b)
{
return(new AaRect(Vec2.Min(a.min, b.min), Vec2.Max(a.max, b.max)));
}
public static bool Overlaps(AaRect a, AaRect b)
{
return
(a.min.x < b.max.x && a.max.x > b.min.x &&
a.min.y < b.max.y && a.max.y > b.min.y);
}
private AabbTreeNode <T> FindChildNodeWithLeastOverlapInInner(AabbTreeNode <T> node, AaRect fat)
{
return(node.children.MinBy <AabbTreeNode <T>, List <AabbTreeNode <T> >, float>(
n => AaRect.Merge(n.bounds, fat).GetArea() - n.bounds.GetArea()
));
}
