public void Execute(int index1)
{
//for (int index1 = 0; index1 < brushesThatNeedIndirectUpdate.Length; index1++)
{
var brush1IndexOrder = brushesThatNeedIndirectUpdate[index1];
int brush1NodeOrder = brush1IndexOrder.nodeOrder;
NativeListArray <BrushIntersectWith> .NativeList brush1Intersections;
if (!brushBrushIntersections.IsAllocated(brush1NodeOrder))
{
brush1Intersections = brushBrushIntersections.AllocateWithCapacityForIndex(brush1NodeOrder, 16);
}
else
{
brush1Intersections = brushBrushIntersections[brush1NodeOrder];
}
for (int index0 = 0; index0 < allTreeBrushIndexOrders.Length; index0++)
{
var brush0IndexOrder = allTreeBrushIndexOrders[index0];
int brush0NodeOrder = brush0IndexOrder.nodeOrder;
if (brush0NodeOrder == brush1NodeOrder
// TODO: figure out why this optimization causes iterative updates to fail
//|| foundBrushes.IsSet(brush0IndexOrder.nodeOrder)
)
{
continue;
}
if (brush0NodeOrder > brush1NodeOrder)
{
var result = IntersectionUtility.FindIntersection(brush0NodeOrder, brush1NodeOrder,
ref brushMeshLookup, ref brushTreeSpaceBounds, ref transformationCache,
ref transformedPlanes0, ref transformedPlanes1);
if (result == IntersectionType.NoIntersection)
{
continue;
}
result = IntersectionUtility.Flip(result);
IntersectionUtility.StoreIntersection(brush1Intersections, brush0IndexOrder, result);
}
else
{
var result = IntersectionUtility.FindIntersection(brush1NodeOrder, brush0NodeOrder,
ref brushMeshLookup, ref brushTreeSpaceBounds, ref transformationCache,
ref transformedPlanes0, ref transformedPlanes1);
if (result == IntersectionType.NoIntersection)
{
continue;
}
IntersectionUtility.StoreIntersection(brush1Intersections, brush0IndexOrder, result);
}
}
}
//*/
}
public void Execute(int index1)
{
if (allTreeBrushIndexOrders.Length == rebuildTreeBrushIndexOrders.Length)
{
//for (int index1 = 0; index1 < updateBrushIndicesArray.Length; index1++)
{
var brush1IndexOrder = rebuildTreeBrushIndexOrders[index1];
int brush1NodeOrder = brush1IndexOrder.nodeOrder;
NativeListArray <BrushIntersectWith> .NativeList brush1Intersections;
if (!brushBrushIntersections.IsAllocated(brush1NodeOrder))
{
brush1Intersections = brushBrushIntersections.AllocateWithCapacityForIndex(brush1NodeOrder, 16);
}
else
{
brush1Intersections = brushBrushIntersections[brush1NodeOrder];
}
for (int index0 = 0; index0 < rebuildTreeBrushIndexOrders.Length; index0++)
{
var brush0IndexOrder = rebuildTreeBrushIndexOrders[index0];
int brush0NodeOrder = brush0IndexOrder.nodeOrder;
if (brush0NodeOrder <= brush1NodeOrder)
{
continue;
}
var result = IntersectionUtility.FindIntersection(brush0NodeOrder, brush1NodeOrder,
ref brushMeshLookup, ref brushTreeSpaceBounds, ref transformationCache,
ref transformedPlanes0, ref transformedPlanes1);
if (result == IntersectionType.NoIntersection)
{
continue;
}
result = IntersectionUtility.Flip(result);
IntersectionUtility.StoreIntersection(brush1Intersections, brush0IndexOrder, result);
}
}
return;
}
NativeCollectionHelpers.EnsureMinimumSizeAndClear(ref foundBrushes, allTreeBrushIndexOrders.Length);
NativeCollectionHelpers.EnsureMinimumSizeAndClear(ref usedBrushes, allTreeBrushIndexOrders.Length);
// TODO: figure out a way to avoid needing this
for (int a = 0; a < rebuildTreeBrushIndexOrders.Length; a++)
{
foundBrushes.Set(rebuildTreeBrushIndexOrders[a].nodeOrder, true);
}
//for (int index1 = 0; index1 < updateBrushIndicesArray.Length; index1++)
{
var brush1IndexOrder = rebuildTreeBrushIndexOrders[index1];
int brush1NodeOrder = brush1IndexOrder.nodeOrder;
NativeListArray <BrushIntersectWith> .NativeList brush1Intersections;
if (!brushBrushIntersections.IsAllocated(brush1NodeOrder))
{
brush1Intersections = brushBrushIntersections.AllocateWithCapacityForIndex(brush1NodeOrder, 16);
}
else
{
brush1Intersections = brushBrushIntersections[brush1NodeOrder];
}
for (int index0 = 0; index0 < allTreeBrushIndexOrders.Length; index0++)
{
var brush0IndexOrder = allTreeBrushIndexOrders[index0];
int brush0NodeOrder = brush0IndexOrder.nodeOrder;
if (brush0NodeOrder == brush1NodeOrder)
{
continue;
}
var found = foundBrushes.IsSet(brush0NodeOrder);
if (brush0NodeOrder < brush1NodeOrder && found)
{
continue;
}
var result = IntersectionUtility.FindIntersection(brush0NodeOrder, brush1NodeOrder,
ref brushMeshLookup, ref brushTreeSpaceBounds, ref transformationCache,
ref transformedPlanes0, ref transformedPlanes1);
if (result == IntersectionType.NoIntersection)
{
continue;
}
if (!found)
{
if (!usedBrushes.IsSet(brush0IndexOrder.nodeOrder))
{
usedBrushes.Set(brush0IndexOrder.nodeOrder, true);
brushesThatNeedIndirectUpdateHashMap.Add(brush0IndexOrder);
result = IntersectionUtility.Flip(result);
IntersectionUtility.StoreIntersection(brush1Intersections, brush0IndexOrder, result);
}
}
else
{
if (brush0NodeOrder > brush1NodeOrder)
{
result = IntersectionUtility.Flip(result);
IntersectionUtility.StoreIntersection(brush1Intersections, brush0IndexOrder, result);
}
}
}
}
}
public void Execute(int index)
{
var count = input.BeginForEachIndex(index);
if (count == 0)
{
return;
}
var brushIndexOrder = input.Read <IndexOrder>();
var brushNodeOrder = brushIndexOrder.nodeOrder;
var vertexCount = input.Read <int>();
NativeCollectionHelpers.EnsureCapacityAndClear(ref brushVertices, vertexCount);
for (int v = 0; v < vertexCount; v++)
{
var vertex = input.Read <float3>();
brushVertices.AddNoResize(vertex);
}
var surfaceOuterCount = input.Read <int>();
NativeCollectionHelpers.EnsureSizeAndClear(ref surfaceLoopIndices, surfaceOuterCount);
for (int o = 0; o < surfaceOuterCount; o++)
{
var surfaceInnerCount = input.Read <int>();
if (surfaceInnerCount > 0)
{
var inner = surfaceLoopIndices.AllocateWithCapacityForIndex(o, surfaceInnerCount);
//inner.ResizeUninitialized(surfaceInnerCount);
for (int i = 0; i < surfaceInnerCount; i++)
{
inner.AddNoResize(input.Read <int>());
}
}
}
var surfaceLoopCount = input.Read <int>();
NativeCollectionHelpers.EnsureMinimumSizeAndClear(ref surfaceLoopAllInfos, surfaceLoopCount);
NativeCollectionHelpers.EnsureSizeAndClear(ref surfaceLoopAllEdges, surfaceLoopCount);
for (int l = 0; l < surfaceLoopCount; l++)
{
surfaceLoopAllInfos[l] = input.Read <SurfaceInfo>();
var edgeCount = input.Read <int>();
if (edgeCount > 0)
{
var edgesInner = surfaceLoopAllEdges.AllocateWithCapacityForIndex(l, edgeCount);
//edgesInner.ResizeUninitialized(edgeCount);
for (int e = 0; e < edgeCount; e++)
{
edgesInner.AddNoResize(input.Read <Edge>());
}
}
}
input.EndForEachIndex();
if (!basePolygonCache[brushNodeOrder].IsCreated)
{
return;
}
var maxLoops = 0;
var maxIndices = 0;
for (int s = 0; s < surfaceLoopIndices.Length; s++)
{
if (!surfaceLoopIndices.IsIndexCreated(s))
{
continue;
}
var length = surfaceLoopIndices[s].Length;
maxIndices += length;
maxLoops = math.max(maxLoops, length);
}
ref var baseSurfaces = ref basePolygonCache[brushNodeOrder].Value.surfaces;
public void Execute(int index)
{
//var brushNodeIndex = treeBrushNodeIndices[index];
var count = input.BeginForEachIndex(index);
if (count == 0)
{
return;
}
HashedVertices brushVertices;
NativeListArray <int> surfaceLoopIndices;
NativeList <SurfaceInfo> surfaceLoopAllInfos;
NativeListArray <Edge> surfaceLoopAllEdges;
var brushNodeIndex = input.Read <int>();
var vertexCount = input.Read <int>();
brushVertices = new HashedVertices(vertexCount, allocator);
for (int v = 0; v < vertexCount; v++)
{
var vertex = input.Read <float3>();
brushVertices.AddNoResize(vertex);
}
var surfaceOuterCount = input.Read <int>();
surfaceLoopIndices = new NativeListArray <int>(surfaceOuterCount, allocator);
surfaceLoopIndices.ResizeExact(surfaceOuterCount);
for (int o = 0; o < surfaceOuterCount; o++)
{
var surfaceInnerCount = input.Read <int>();
if (surfaceInnerCount > 0)
{
var inner = surfaceLoopIndices.AllocateWithCapacityForIndex(o, surfaceInnerCount);
//inner.ResizeUninitialized(surfaceInnerCount);
for (int i = 0; i < surfaceInnerCount; i++)
{
inner.AddNoResize(input.Read <int>());
}
}
}
var surfaceLoopCount = input.Read <int>();
surfaceLoopAllInfos = new NativeList <SurfaceInfo>(surfaceLoopCount, allocator);
surfaceLoopAllEdges = new NativeListArray <Edge>(surfaceLoopCount, allocator);
surfaceLoopAllInfos.ResizeUninitialized(surfaceLoopCount);
surfaceLoopAllEdges.ResizeExact(surfaceLoopCount);
for (int l = 0; l < surfaceLoopCount; l++)
{
surfaceLoopAllInfos[l] = input.Read <SurfaceInfo>();
var edgeCount = input.Read <int>();
if (edgeCount > 0)
{
var edgesInner = surfaceLoopAllEdges.AllocateWithCapacityForIndex(l, edgeCount);
//edgesInner.ResizeUninitialized(edgeCount);
for (int e = 0; e < edgeCount; e++)
{
edgesInner.AddNoResize(input.Read <Edge>());
}
}
}
input.EndForEachIndex();
var maxLoops = 0;
var maxIndices = 0;
for (int s = 0; s < surfaceLoopIndices.Length; s++)
{
if (!surfaceLoopIndices.IsIndexCreated(s))
{
continue;
}
var length = surfaceLoopIndices[s].Length;
maxIndices += length;
maxLoops = math.max(maxLoops, length);
}
ref var baseSurfaces = ref basePolygons[brushNodeIndex].Value.surfaces;