public BodyPairWriter(NativeStream.Writer *collidingPairs, CollisionFilter *bodyFiltersLeft, CollisionFilter *bodyFiltersRight,
int bodyAIndexBase, int bodyBIndexBase)
{
m_CollidingPairs = collidingPairs;
m_BodyFiltersLeft = bodyFiltersLeft;
m_BodyFiltersRight = bodyFiltersRight;
m_BodyAIndexBase = bodyAIndexBase;
m_BodyBIndexBase = bodyBIndexBase;
m_Count = 0;
}
public BodyPairWriter(NativeStream.Writer *collidingPairs, CollisionFilter *bodyFiltersLeft, CollisionFilter *bodyFiltersRight,
bool *bodyRespondsToCollisionLeft, bool *bodyRespondsToCollisionRight, int bodyIndexABase, int bodyIndexBBase)
{
m_CollidingPairs = collidingPairs;
m_BodyFiltersLeft = bodyFiltersLeft;
m_BodyFiltersRight = bodyFiltersRight;
m_BodyRespondsToCollisionLeft = bodyRespondsToCollisionLeft;
m_BodyRespondsToCollisionRight = bodyRespondsToCollisionRight;
m_BodyIndexABase = bodyIndexABase;
m_BodyIndexBBase = bodyIndexBBase;
m_Count = 0;
}
public unsafe void Execute()
{
if (DummyRun)
{
return;
}
CollisionPairWriter.BeginForEachIndex(0);
CollisionFilter *bodyFilters = (CollisionFilter *)Filter.GetUnsafePtr();
var pairBuffer = new Broadphase.BodyPairWriter((BlockStream.Writer *)UnsafeUtility.AddressOf(ref CollisionPairWriter), bodyFilters);
Node *nodesPtr = (Node *)Nodes.GetUnsafePtr();
BoundingVolumeHierarchy.TreeOverlap(ref pairBuffer, nodesPtr, nodesPtr);
pairBuffer.Close();
CollisionPairWriter.EndForEachIndex();
}
public unsafe void OverlapTaskFilteringTest([Values(2, 10, 33, 100)] int elementCount)
{
elementCount *= 2;
int numNodes = elementCount + Constants.MaxNumTreeBranches;
var points = new NativeArray <PointAndIndex>(elementCount, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
var aabbs = new NativeArray <Aabb>(elementCount, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
var bodyFilters = new NativeArray <CollisionFilter>(elementCount, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
InitInputWithCopyArrays(points, aabbs, bodyFilters);
var nodes = new NativeArray <Node>(numNodes, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
Node *nodesPtr = (Node *)nodes.GetUnsafePtr();
var seenUnfiltered = new HashSet <BodyIndexPair>();
{
var bvhUnfiltered = new BoundingVolumeHierarchy(nodes);
bvhUnfiltered.Build(points, aabbs, out int numNodesOut);
bvhUnfiltered.CheckIntegrity();
EverythingWriter pairWriter = new EverythingWriter {
SeenPairs = seenUnfiltered
};
BoundingVolumeHierarchy.TreeOverlap(ref pairWriter, nodesPtr, nodesPtr);
}
var nodeFilters = new NativeArray <CollisionFilter>(numNodes, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
var bvhFiltered = new BoundingVolumeHierarchy(nodes, nodeFilters);
int numNodesFilteredTree;
bvhFiltered.Build(points, aabbs, out numNodesFilteredTree);
bvhFiltered.BuildCombinedCollisionFilter(bodyFilters, 0, numNodesFilteredTree - 1);
var filteredCollisionPairs = new BlockStream(1, 0xec87b613);
BlockStream.Writer filteredPairWriter = filteredCollisionPairs;
filteredPairWriter.BeginForEachIndex(0);
CollisionFilter *bodyFiltersPtr = (CollisionFilter *)bodyFilters.GetUnsafePtr();
var bufferedPairs = new Broadphase.BodyPairWriter(&filteredPairWriter, bodyFiltersPtr);
CollisionFilter *nodeFiltersPtr = (CollisionFilter *)nodeFilters.GetUnsafePtr();
BoundingVolumeHierarchy.TreeOverlap(ref bufferedPairs, nodesPtr, nodesPtr, nodeFiltersPtr, nodeFiltersPtr);
bufferedPairs.Close();
filteredPairWriter.EndForEachIndex();
BlockStream.Reader filteredPairReader = filteredCollisionPairs;
filteredPairReader.BeginForEachIndex(0);
// Check that every pair in our filtered set also appears in the unfiltered set
while (filteredPairReader.RemainingItemCount > 0)
{
var pair = filteredPairReader.Read <BodyIndexPair>();
Assert.IsTrue(seenUnfiltered.Contains(pair));
seenUnfiltered.Remove(pair); // Remove the pair
}
// Pairs were removed, so the only remaining ones should be filtered
foreach (BodyIndexPair pair in seenUnfiltered)
{
bool shouldCollide = CollisionFilter.IsCollisionEnabled(bodyFilters[pair.BodyAIndex], bodyFilters[pair.BodyBIndex]);
Assert.IsFalse(shouldCollide);
}
nodeFilters.Dispose();
nodes.Dispose();
bodyFilters.Dispose();
aabbs.Dispose();
points.Dispose();
filteredCollisionPairs.Dispose();
}
public unsafe BoundingVolumeHierarchy(NativeArray <Node> nodes)
{
m_Nodes = (Node *)nodes.GetUnsafeReadOnlyPtr();
m_NodeFilters = null;
}
public unsafe BoundingVolumeHierarchy(NativeArray <Node> nodes, NativeArray <CollisionFilter> nodeFilters)
{
m_Nodes = (Node *)nodes.GetUnsafeReadOnlyPtr();
m_NodeFilters = (CollisionFilter *)nodeFilters.GetUnsafeReadOnlyPtr();
}
public unsafe BoundingVolumeHierarchy(Node *nodes, CollisionFilter *nodeFilters)
{
m_Nodes = nodes;
m_NodeFilters = nodeFilters;
}
