internal override void GetOverlaps(Node opposingNode, DynamicHierarchy owner)
{
bool intersects;
//note: This is never executed when the opposing node is the current node.
if (opposingNode.IsLeaf)
{
//We're both leaves! Our parents have already done the testing for us, so we know we're overlapping.
owner.TryToAddOverlap(element, opposingNode.Element);
}
else
{
Node opposingChildA = opposingNode.ChildA;
Node opposingChildB = opposingNode.ChildB;
//If it's not a leaf, try to go deeper in the opposing hierarchy.
BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);
if (intersects)
{
GetOverlaps(opposingChildA, owner);
}
BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);
if (intersects)
{
GetOverlaps(opposingChildB, owner);
}
}
}
internal override void GetMultithreadedOverlaps(Node opposingNode, int splitDepth, int currentDepth,
DynamicHierarchy owner, RawList <DynamicHierarchy.NodePair> multithreadingSourceOverlaps)
{
bool intersects;
//note: This is never executed when the opposing node is the current node.
if (opposingNode.IsLeaf)
{
//We're both leaves! Our parents have already done the testing for us, so we know we're overlapping.
owner.TryToAddOverlap(element, opposingNode.Element);
}
else
{
Node opposingChildA = opposingNode.ChildA;
Node opposingChildB = opposingNode.ChildB;
if (splitDepth == currentDepth)
{
//Time to add the child overlaps to the multithreading set!
BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);
if (intersects)
{
multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair {
a = this, b = opposingChildA
});
}
BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);
if (intersects)
{
multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair {
a = this, b = opposingChildB
});
}
return;
}
//If it's not a leaf, try to go deeper in the opposing hierarchy.
BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);
if (intersects)
{
GetOverlaps(opposingChildA, owner);
}
BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);
if (intersects)
{
GetOverlaps(opposingChildB, owner);
}
}
}
internal abstract void GetMultithreadedOverlaps(Node opposingNode, int splitDepth, int currentDepth,
DynamicHierarchy owner, RawList <DynamicHierarchy.NodePair> multithreadingSourceOverlaps);
internal override void GetMultithreadedOverlaps(Node opposingNode, int splitDepth, int currentDepth,
DynamicHierarchy owner, RawList <DynamicHierarchy.NodePair> multithreadingSourceOverlaps)
{
bool intersects;
if (currentDepth == splitDepth)
{
//We've reached the depth where our child comparisons will be multithreaded.
if (this == opposingNode)
{
//We are being compared against ourselves!
//Obviously we're an internal node, so spawn three children:
//A versus A:
if (!childA.IsLeaf
) //This is performed in the child method usually by convention, but this saves some time.
{
multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair {
a = childA, b = childA
});
}
//B versus B:
if (!childB.IsLeaf
) //This is performed in the child method usually by convention, but this saves some time.
{
multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair {
a = childB, b = childB
});
}
//A versus B (if they intersect):
childA.BoundingBox.Intersects(ref childB.BoundingBox, out intersects);
if (intersects)
{
multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair {
a = childA, b = childB
});
}
}
else
{
//Two different nodes. The other one may be a leaf.
if (opposingNode.IsLeaf)
{
//If it's a leaf, go deeper in our hierarchy, but not the opposition.
childA.BoundingBox.Intersects(ref opposingNode.BoundingBox, out intersects);
if (intersects)
{
multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair
{
a = childA, b = opposingNode
});
}
childB.BoundingBox.Intersects(ref opposingNode.BoundingBox, out intersects);
if (intersects)
{
multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair
{
a = childB, b = opposingNode
});
}
}
else
{
Node opposingChildA = opposingNode.ChildA;
Node opposingChildB = opposingNode.ChildB;
//If it's not a leaf, try to go deeper in both hierarchies.
childA.BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);
if (intersects)
{
multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair
{
a = childA, b = opposingChildA
});
}
childA.BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);
if (intersects)
{
multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair
{
a = childA, b = opposingChildB
});
}
childB.BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);
if (intersects)
{
multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair
{
a = childB, b = opposingChildA
});
}
childB.BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);
if (intersects)
{
multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair
{
a = childB, b = opposingChildB
});
}
}
}
return;
}
if (this == opposingNode)
{
//We are being compared against ourselves!
//Obviously we're an internal node, so spawn three children:
//A versus A:
if (!childA.IsLeaf
) //This is performed in the child method usually by convention, but this saves some time.
{
childA.GetMultithreadedOverlaps(childA, splitDepth, currentDepth + 1, owner,
multithreadingSourceOverlaps);
}
//B versus B:
if (!childB.IsLeaf
) //This is performed in the child method usually by convention, but this saves some time.
{
childB.GetMultithreadedOverlaps(childB, splitDepth, currentDepth + 1, owner,
multithreadingSourceOverlaps);
}
//A versus B (if they intersect):
childA.BoundingBox.Intersects(ref childB.BoundingBox, out intersects);
if (intersects)
{
childA.GetMultithreadedOverlaps(childB, splitDepth, currentDepth + 1, owner,
multithreadingSourceOverlaps);
}
}
else
{
//Two different nodes. The other one may be a leaf.
if (opposingNode.IsLeaf)
{
//If it's a leaf, go deeper in our hierarchy, but not the opposition.
childA.BoundingBox.Intersects(ref opposingNode.BoundingBox, out intersects);
if (intersects)
{
childA.GetMultithreadedOverlaps(opposingNode, splitDepth, currentDepth + 1, owner,
multithreadingSourceOverlaps);
}
childB.BoundingBox.Intersects(ref opposingNode.BoundingBox, out intersects);
if (intersects)
{
childB.GetMultithreadedOverlaps(opposingNode, splitDepth, currentDepth + 1, owner,
multithreadingSourceOverlaps);
}
}
else
{
Node opposingChildA = opposingNode.ChildA;
Node opposingChildB = opposingNode.ChildB;
//If it's not a leaf, try to go deeper in both hierarchies.
childA.BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);
if (intersects)
{
childA.GetMultithreadedOverlaps(opposingChildA, splitDepth, currentDepth + 1, owner,
multithreadingSourceOverlaps);
}
childA.BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);
if (intersects)
{
childA.GetMultithreadedOverlaps(opposingChildB, splitDepth, currentDepth + 1, owner,
multithreadingSourceOverlaps);
}
childB.BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);
if (intersects)
{
childB.GetMultithreadedOverlaps(opposingChildA, splitDepth, currentDepth + 1, owner,
multithreadingSourceOverlaps);
}
childB.BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);
if (intersects)
{
childB.GetMultithreadedOverlaps(opposingChildB, splitDepth, currentDepth + 1, owner,
multithreadingSourceOverlaps);
}
}
}
}
internal abstract void GetOverlaps(Node node, DynamicHierarchy owner);
internal override void GetOverlaps(Node opposingNode, DynamicHierarchy owner)
{
bool intersects;
if (this == opposingNode)
{
//We are being compared against ourselves!
//Obviously we're an internal node, so spawn three children:
//A versus A:
if (!childA.IsLeaf
) //This is performed in the child method usually by convention, but this saves some time.
{
childA.GetOverlaps(childA, owner);
}
//B versus B:
if (!childB.IsLeaf
) //This is performed in the child method usually by convention, but this saves some time.
{
childB.GetOverlaps(childB, owner);
}
//A versus B (if they intersect):
childA.BoundingBox.Intersects(ref childB.BoundingBox, out intersects);
if (intersects)
{
childA.GetOverlaps(childB, owner);
}
}
else
{
//Two different nodes. The other one may be a leaf.
if (opposingNode.IsLeaf)
{
//If it's a leaf, go deeper in our hierarchy, but not the opposition.
childA.BoundingBox.Intersects(ref opposingNode.BoundingBox, out intersects);
if (intersects)
{
childA.GetOverlaps(opposingNode, owner);
}
childB.BoundingBox.Intersects(ref opposingNode.BoundingBox, out intersects);
if (intersects)
{
childB.GetOverlaps(opposingNode, owner);
}
}
else
{
Node opposingChildA = opposingNode.ChildA;
Node opposingChildB = opposingNode.ChildB;
//If it's not a leaf, try to go deeper in both hierarchies.
childA.BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);
if (intersects)
{
childA.GetOverlaps(opposingChildA, owner);
}
childA.BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);
if (intersects)
{
childA.GetOverlaps(opposingChildB, owner);
}
childB.BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);
if (intersects)
{
childB.GetOverlaps(opposingChildA, owner);
}
childB.BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);
if (intersects)
{
childB.GetOverlaps(opposingChildB, owner);
}
}
}
}
internal DynamicHierarchyQueryAccelerator(DynamicHierarchy hierarchy)
{
this.hierarchy = hierarchy;
}