private bool TriangleContainsVertexInList(int indexPrev, int indexCurr, int indexNext, NativeLinkedList <int> list)
{
for (NativeLinkedList <int> .Enumerator currIndexNode = list.Head; currIndexNode.IsValid; currIndexNode.MoveNext())
{
NativeLinkedList <int> .Enumerator prevIndexNode = (currIndexNode.Prev.IsValid) ? currIndexNode.Prev : list.Tail;
NativeLinkedList <int> .Enumerator nextIndexNode = (currIndexNode.Next.IsValid) ? currIndexNode.Next : list.Head;
bool isCurrentConvex = Math2DUtils.IsVertexConvex(Polygon[prevIndexNode.Value], Polygon[currIndexNode.Value], Polygon[nextIndexNode.Value], true);
if (isCurrentConvex)
{
continue;
}
int currIndexToCheck = currIndexNode.Value;
if (currIndexToCheck == indexPrev || currIndexToCheck == indexCurr || currIndexToCheck == indexNext)
{
continue;
}
if (Math2DUtils.IsInsideTriangle(Polygon[currIndexToCheck], Polygon[indexPrev], Polygon[indexCurr], Polygon[indexNext]))
{
return(true);
}
}
return(false);
}
private NativeLinkedList <T> GetList(int index)
{
NativeLinkedList <T> value = new NativeLinkedList <T>();
UnsafeUtility.MemCpy(UnsafeUtility.AddressOf(ref value), (mainArray + index * UnsafeUtility.SizeOf <NativeLinkedList <T> >()).ToPointer(), UnsafeUtility.SizeOf <NativeLinkedList <T> >());
return(value);
}
public VirtualTexture(int resolution, RenderTextureFormat format)
{
this.resolution = resolution;
this.format = format;
allSparse = new ArrayOfNativeLink <TextureSparse>((int)(0.01f + log2(resolution)), Allocator.Persistent, (a, b) =>
{
bool2 offset = a.offset == b.offset;
bool2 size = a.size == b.size;
return(offset.x && offset.y && size.x && size.y);
});
NativeLinkedList <TextureSparse> originSparse = allSparse[allSparse.Length - 1];
originSparse.AddLast(new TextureSparse
{
offset = 0,
size = resolution / 2,
});
originSparse.AddLast(new TextureSparse
{
offset = int2(0, resolution / 2),
size = resolution / 2,
});
originSparse.AddLast(new TextureSparse
{
offset = int2(resolution / 2, 0),
size = resolution / 2,
});
originSparse.AddLast(new TextureSparse
{
offset = resolution / 2,
size = resolution / 2,
});
}
public void Execute()
{
NativeLinkedList <int> .Enumerator e = List.Tail;
for (int i = 0; i < NumNodesToInsert; ++i)
{
e = List.InsertAfter(e, i);
}
}
public NativeLinkedList <T> this[int index]
{
get
{
NativeLinkedList <T> value = new NativeLinkedList <T>();
UnsafeUtility.MemCpy(UnsafeUtility.AddressOf(ref value), (mainArray + index * UnsafeUtility.SizeOf <NativeLinkedList <T> >()).ToPointer(), UnsafeUtility.SizeOf <NativeLinkedList <T> >());
return(value);
}
}
public bool MoveNext()
{
ptr = next;
if (ptr.ToPointer() == null)
{
return(false);
}
next = new UIntPtr(*NativeLinkedList <T> .GetNextPtr(next));
return(true);
}
private NativeLinkedList <int> StorePolygonContourAsLinkedList()
{
int totNumVerts = Polygon.HolesNum * 2 + Polygon.VerticesNum;
NativeLinkedList <int> linkedList = new NativeLinkedList <int>(totNumVerts, Allocator.Temp);
//add contour points to the vertices linked list and set the max ray length
for (int i = 0; i < Polygon.ContourPointsNum; ++i)
{
linkedList.InsertAfter(linkedList.Tail, i);
}
return(linkedList);
}
private void Triangulate(int polygonIndex, NativeLinkedList <int> list)
{
int trisIndex = 0;
for (int pi = 0; pi < polygonIndex; ++pi)
{
trisIndex += Polygons.GetPolygonHolesNum(pi) * 2 + Polygons.GetPolygonNumVertices(pi) - 2;
}
trisIndex *= 3;
while (list.Length > 2)
{
bool hasRemovedEar = false;
int currListIndex = 0;
NativeLinkedList <int> .Enumerator currIndexNode = list.Head;
for (int i = 0; i < list.Length; ++i)
{
NativeLinkedList <int> .Enumerator prevIndexNode = (currIndexNode.Prev.IsValid) ? currIndexNode.Prev : list.Tail;
NativeLinkedList <int> .Enumerator nextIndexNode = (currIndexNode.Next.IsValid) ? currIndexNode.Next : list.Head;
bool isCurrentConvex = Math2DUtils.IsVertexConvex(Polygons[prevIndexNode.Value], Polygons[currIndexNode.Value], Polygons[nextIndexNode.Value], true);
if (isCurrentConvex)
{
bool triangleContainsAVertex = TriangleContainsVertexInList(prevIndexNode.Value, currIndexNode.Value, nextIndexNode.Value, list);
if (!triangleContainsAVertex)
{
OutTriangles[trisIndex] = nextIndexNode.Value;
OutTriangles[trisIndex + 1] = currIndexNode.Value;
OutTriangles[trisIndex + 2] = prevIndexNode.Value;
trisIndex += 3;
list.Remove(currIndexNode);
hasRemovedEar = true;
break;
}
}
currListIndex = (currListIndex + 1) % list.Length;
currIndexNode = list.GetEnumeratorAtIndex(currListIndex);
}
if (!hasRemovedEar)
{
return;
}
}
}
private NativeLinkedList <int> StorePolygonContourAsLinkedList(int polygonIndex)
{
int polygonNumHoles = Polygons.GetPolygonHolesNum(polygonIndex);
int polygonNumVertices = Polygons.GetPolygonNumVertices(polygonIndex);
int totNumVerts = polygonNumHoles * 2 + polygonNumVertices;
NativeLinkedList <int> linkedList = new NativeLinkedList <int>(totNumVerts, Allocator.Temp);
//add contour points to the vertices linked list and set the max ray length
int polygonStartIndex = Polygons.GetPolygonStartIndex(polygonIndex);
int polygonContourLastIndex = polygonStartIndex + Polygons.GetContourPointsNum(polygonIndex);
for (int i = polygonStartIndex; i < polygonContourLastIndex; ++i)
{
linkedList.InsertAfter(linkedList.Tail, i);
}
return(linkedList);
}
private static void TestLinkedList <T>(NativeLinkedList <T> llist) where T : unmanaged
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write("Test: ");
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write(nameof(NativeLinkedList <T>));
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write('<');
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write(typeof(T).Name);
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write('>');
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write(" --> ");
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(llist.ToString());
}
public void CombineTexture()
{
for (int i = 0; i < allSparse.Length - 1; ++i)
{
NativeLinkedList <TextureSparse> sparse = allSparse[i];
NativeList <TextureSparse> zeroPos = new NativeList <TextureSparse>(sparse.Length, Allocator.Temp);
foreach (var j in sparse)
{
bool2 ald = IsSparseAligned(j);
if (ald.x && ald.y)
{
zeroPos.Add(j);
}
}
foreach (var j in zeroPos)
{
TextureSparse *array = stackalloc TextureSparse[] {
new TextureSparse
{
offset = j.offset + int2(j.size, 0),
size = j.size,
},
new TextureSparse
{
offset = j.offset + int2(0, j.size),
size = j.size,
},
new TextureSparse
{
offset = j.offset + j.size,
size = j.size,
},
j
};
if (sparse.ContainsDatas(array, 3))
{
sparse.RemoveData(array, 4);
allSparse[i + 1].AddLast(new TextureSparse
{
offset = j.offset,
size = j.size * 2,
});
}
}
}
}
private TextureSparse GetNewSparse(int index)
{
if (index >= allSparse.Length)
{
throw new Exception("Out of Range!");
}
NativeLinkedList <TextureSparse> currentSparseList = allSparse[index];
if (currentSparseList.Length > 0)
{
TextureSparse sparse = *currentSparseList.GetLast();
currentSparseList.RemoveLast();
return(sparse);
}
TextureSparse nextSparse = GetNewSparse(index + 1);
int size = nextSparse.size / 2;
currentSparseList.AddLast(new TextureSparse
{
offset = nextSparse.offset,
size = size,
});
currentSparseList.AddLast(new TextureSparse
{
offset = nextSparse.offset + int2(0, size),
size = size,
});
currentSparseList.AddLast(new TextureSparse
{
offset = nextSparse.offset + int2(size, 0),
size = size,
});
return(new TextureSparse
{
offset = nextSparse.offset + size,
size = size,
});
}
private static void TestLinkedList()
{
const int count = 10;
using var llist = new NativeLinkedList <LCRange>();
for (int i = 0; i < count; i++)
{
llist.AddAfter(new LCRange(i, (i + 7) * 3));
}
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("-- foreach supported --");
Console.ForegroundColor = ConsoleColor.Blue;
foreach (var item in llist)
{
Console.WriteLine(item);
}
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"Peek -> {llist.Peek()} -> Count: {llist.Count}\n");
Debug.Assert(llist.Count == count);
// Pops Nodes
Console.WriteLine($"Pop -> {llist.Pop()} -> Count: {llist.Count}");
Debug.Assert(llist.Count == count - 1);
Console.WriteLine($"Pop -> {llist.Pop()} -> Count: {llist.Count}");
Debug.Assert(llist.Count == count - 2);
Console.WriteLine($"Pop -> {llist.Pop()} -> Count: {llist.Count}");
Debug.Assert(llist.Count == count - 3);
// Clear All Nodes and free (Count-1)*size memory spaces
llist.Clear();
Debug.Assert(llist.IsEmpty);
Console.WriteLine($"Clear -> Count: {llist.Count}");
Console.WriteLine();
TestLinkedList(llist);
}
public void Execute()
{
NativeLinkedList <int> hullVertices = StorePolygonContourAsLinkedList();
#region Removing Holes
//create the array containing the holes data
NativeArray <ECHoleData> holes = GetHolesDataSortedByMaxX();
//remove holes
for (int hi = 0; hi < holes.Length; ++hi)
{
ECHoleData hole = holes[hi];
var intersectionEdgeP0 = hullVertices.GetEnumerator();
var intersectionEdgeP1 = hullVertices.GetEnumerator();
float2 intersectionPoint = new float2(float.MaxValue, hole.BridgePoint.y);
for (var currentHullVertex = hullVertices.Head; currentHullVertex.IsValid; currentHullVertex.MoveNext())
{
var nextHullVertex = (currentHullVertex.Next.IsValid) ? currentHullVertex.Next : hullVertices.Head;
float2 currPoint = Polygon[currentHullVertex.Value];
float2 nextPoint = Polygon[nextHullVertex.Value];
//M is to the left of the line containing the edge (M is inside the outer polygon)
bool isMOnLeftOfEdgeLine = (Math2DUtils.LineSide(hole.BridgePoint, currPoint, nextPoint) < 0f);
if (isMOnLeftOfEdgeLine)
{
continue;
}
// at least one point must be to right of the hole bridge point for intersection with ray to be possible
if (currPoint.x < hole.BridgePoint.x && nextPoint.x < hole.BridgePoint.x)
{
continue;
}
if (currPoint.y > hole.BridgePoint.y == nextPoint.y > hole.BridgePoint.y)
{
continue;
}
float intersectionX = nextPoint.x; // if line p0,p1 is vertical
if (math.abs(currPoint.x - nextPoint.x) > float.Epsilon)
{
float intersectY = hole.BridgePoint.y;
float gradient = (currPoint.y - nextPoint.y) / (currPoint.x - nextPoint.x);
float c = nextPoint.y - gradient * nextPoint.x;
intersectionX = (intersectY - c) / gradient;
}
if (intersectionX < intersectionPoint.x)
{
intersectionPoint.x = intersectionX;
intersectionEdgeP0 = currentHullVertex;
intersectionEdgeP1 = nextHullVertex;
}
}
var selectedHullBridgePoint = hullVertices.GetEnumerator();
//If I is a vertex of the outer polygon, then M and I are mutually visible
if (Math2DUtils.SamePoints(intersectionPoint, Polygon[intersectionEdgeP0.Value]))
{
selectedHullBridgePoint = intersectionEdgeP0;
}
else if (Math2DUtils.SamePoints(intersectionPoint, Polygon[intersectionEdgeP1.Value]))
{
selectedHullBridgePoint = intersectionEdgeP1;
}
else
{
//Select P to be the endpoint of maximum x-value for this edge
var P = (Polygon[intersectionEdgeP0.Value].x > Polygon[intersectionEdgeP1.Value].x) ? intersectionEdgeP0 : intersectionEdgeP1;
bool existReflexVertexInsideMIP = false;
float minAngle = float.MaxValue;
float minDist = float.MaxValue;
for (var currOuterPolygonVertex = hullVertices.Head; currOuterPolygonVertex.IsValid; currOuterPolygonVertex.MoveNext())
{
if (currOuterPolygonVertex.Value == P.Value)
{
continue;
}
var nextOuterPolygonVertex = (currOuterPolygonVertex.Next.IsValid) ? currOuterPolygonVertex.Next : hullVertices.Head;
var prevOuterPolygonVertex = (currOuterPolygonVertex.Prev.IsValid) ? currOuterPolygonVertex.Prev : hullVertices.Tail;
if (Math2DUtils.IsVertexReflex(
Polygon[prevOuterPolygonVertex.Value],
Polygon[currOuterPolygonVertex.Value],
Polygon[nextOuterPolygonVertex.Value],
true))
{
bool isInsideMIPTriangle = Math2DUtils.IsInsideTriangle(Polygon[currOuterPolygonVertex.Value],
hole.BridgePoint,
intersectionPoint,
Polygon[P.Value]);
existReflexVertexInsideMIP |= isInsideMIPTriangle;
if (isInsideMIPTriangle)
{
//search for the reflex vertex R that minimizes the angle between (1,0) and the line segment M-R
float2 MR = Polygon[currOuterPolygonVertex.Value] - hole.BridgePoint;
float angleMRI = math.atan2(MR.y, MR.x);
if (angleMRI < minAngle)
{
selectedHullBridgePoint = currOuterPolygonVertex;
minAngle = angleMRI;
}
else if (math.abs(angleMRI - minAngle) <= float.Epsilon)
{
//same angle
float lengthMR = math.length(MR);
if (lengthMR < minDist)
{
selectedHullBridgePoint = currOuterPolygonVertex;
minDist = lengthMR;
}
}
}
}
if (!existReflexVertexInsideMIP)
{
selectedHullBridgePoint = P;
}
}
}
hullVertices.InsertAfter(selectedHullBridgePoint, selectedHullBridgePoint.Value);
for (int i = hole.BridgePointIndex - hole.HoleFirstIndex, count = 0;
count < hole.HoleLength;
i = (i + hole.HoleLength - 1) % hole.HoleLength, ++count)
{
hullVertices.InsertAfter(selectedHullBridgePoint, i + hole.HoleFirstIndex);
}
hullVertices.InsertAfter(selectedHullBridgePoint, hole.BridgePointIndex);
}
holes.Dispose();
#endregion
Triangulate(hullVertices);
hullVertices.Dispose();
}
private void SetList(int index, NativeLinkedList <T> list)
{
UnsafeUtility.MemCpy((mainArray + index * UnsafeUtility.SizeOf <NativeLinkedList <T> >()).ToPointer(), UnsafeUtility.AddressOf(ref list), UnsafeUtility.SizeOf <NativeLinkedList <T> >());
}
// Run the test
void Start()
{
WarmUpJobSystem();
const int size =
#if UNITY_EDITOR
1000
#else
10000
#endif
;
const int chunkSize = 1024;
const int numElementsPerChunk = chunkSize / sizeof(int);
// Create native collections
NativeArray <int> sum = new NativeArray <int>(1, Allocator.TempJob);
NativeArray <int> array = new NativeArray <int>(
size,
Allocator.TempJob);
NativeList <int> list = new NativeList <int>(
0,
Allocator.TempJob);
NativeLinkedList <int> linkedList = new NativeLinkedList <int>(
0,
Allocator.TempJob);
NativeChunkedList <int> chunkedList = new NativeChunkedList <int>(
numElementsPerChunk,
0,
Allocator.TempJob);
NativeHashSet <int> hashSet = new NativeHashSet <int>(
0,
Allocator.TempJob);
NativeIntPtr nativeIntPtr = new NativeIntPtr(Allocator.TempJob);
NativePerJobThreadIntPtr nativePerJobThreadIntPtr = new NativePerJobThreadIntPtr(
Allocator.TempJob);
// Run add jobs
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
ListAddJob listAddJob = new ListAddJob
{
List = list,
NumElementsToAdd = size
};
sw.Reset();
sw.Start();
listAddJob.Run();
long listAddTicks = sw.ElapsedTicks;
LinkedListAddJob linkedListAddJob = new LinkedListAddJob
{
List = linkedList,
NumNodesToInsert = size
};
sw.Reset();
sw.Start();
linkedListAddJob.Run();
long linkedListAddTicks = sw.ElapsedTicks;
ChunkedListAddJob chunkedListAddJob = new ChunkedListAddJob
{
List = chunkedList,
NumElementsToAdd = size
};
sw.Reset();
sw.Start();
chunkedListAddJob.Run();
long chunkedListAddTicks = sw.ElapsedTicks;
HashSetAddJob hashSetAddJob = new HashSetAddJob
{
Set = hashSet,
NumElementsToAdd = size
};
sw.Reset();
sw.Start();
hashSetAddJob.Run();
long hashSetAddTicks = sw.ElapsedTicks;
// Run iterate jobs
ArrayIterateJob arrayIterateJob = new ArrayIterateJob
{
Array = array,
Sum = sum
};
sum[0] = 0;
sw.Reset();
sw.Start();
arrayIterateJob.Run();
long arrayIterateTicks = sw.ElapsedTicks;
ListIterateJob listIterateJob = new ListIterateJob
{
List = list,
Sum = sum
};
sum[0] = 0;
sw.Reset();
sw.Start();
listIterateJob.Run();
long listIterateTicks = sw.ElapsedTicks;
LinkedListIterateJob linkedListIterateJob = new LinkedListIterateJob
{
List = linkedList,
Sum = sum
};
sum[0] = 0;
sw.Reset();
sw.Start();
linkedListIterateJob.Run();
long linkedListIterateTicks = sw.ElapsedTicks;
ChunkedListIterateJob chunkedListIterateJob = new ChunkedListIterateJob
{
List = chunkedList,
Sum = sum
};
sum[0] = 0;
sw.Reset();
sw.Start();
chunkedListIterateJob.Run();
long chunkedListIterateTicks = sw.ElapsedTicks;
ArrayIterateJobParallelFor arrayIterateJobParallelFor = new ArrayIterateJobParallelFor
{
Array = array,
Sum = sum
};
sum[0] = 0;
sw.Reset();
sw.Start();
arrayIterateJobParallelFor.Run(size);
long arrayIterateParallelForTicks = sw.ElapsedTicks;
linkedList.PrepareForParallelForJob();
LinkedListIterateJobParallelFor linkedListIterateJobParallelFor = new LinkedListIterateJobParallelFor
{
List = linkedList,
Sum = sum
};
sum[0] = 0;
sw.Reset();
sw.Start();
linkedListIterateJobParallelFor.Run(size);
long linkedListIterateParallelForTicks = sw.ElapsedTicks;
chunkedList.PrepareForParallelForJob();
ChunkedListIterateJobParallelFor chunkedListIterateJobParallelFor = new ChunkedListIterateJobParallelFor
{
List = chunkedList,
Sum = sum
};
sum[0] = 0;
sw.Reset();
sw.Start();
chunkedListIterateJobParallelFor.RunRanged(size);
long chunkedListIterateParallelForTicks = sw.ElapsedTicks;
// Clear native collections
list.Clear();
linkedList.Clear();
chunkedList.Clear();
// Run insert jobs
LinkedListInsertJob linkedListInsertJob = new LinkedListInsertJob
{
LinkedList = linkedList,
NumElementsToAdd = size
};
sw.Reset();
sw.Start();
linkedListInsertJob.Run();
long linkedListInsertTicks = sw.ElapsedTicks;
ChunkedListInsertJob chunkedListInsertJob = new ChunkedListInsertJob
{
List = chunkedList,
NumElementsToAdd = size
};
sw.Reset();
sw.Start();
chunkedListInsertJob.Run();
long chunkedListInsertTicks = sw.ElapsedTicks;
// Run remove jobs
LinkedListRemoveJob linkedListRemoveJob = new LinkedListRemoveJob
{
List = linkedList,
NumElementsToRemove = size
};
sw.Reset();
sw.Start();
linkedListRemoveJob.Run();
long linkedListRemoveTicks = sw.ElapsedTicks;
ChunkedListRemoveJob chunkedListRemoveJob = new ChunkedListRemoveJob
{
List = chunkedList,
NumElementsToRemove = size
};
sw.Reset();
sw.Start();
chunkedListRemoveJob.Run();
long chunkedListRemoveTicks = sw.ElapsedTicks;
HashSetRemoveJob hashSetRemoveJob = new HashSetRemoveJob
{
Set = hashSet,
NumElementsToRemove = size
};
sw.Reset();
sw.Start();
hashSetRemoveJob.Run();
long hashSetRemoveTicks = sw.ElapsedTicks;
// Run NativeIntPtr and NativePerJobThreadIntPtr jobs
NativeIntPtrParallelJob nativeIntPtrParallelJob = new NativeIntPtrParallelJob
{
Array = array,
Sum = nativeIntPtr.GetParallel()
};
sw.Reset();
sw.Start();
nativeIntPtrParallelJob.Run(size);
long nativeIntPtrTicks = sw.ElapsedTicks;
NativePerJobThreadIntPtrParallelJob nativePerJobThreadIntPtrParallelJob = new NativePerJobThreadIntPtrParallelJob
{
Array = array,
Sum = nativePerJobThreadIntPtr.GetParallel()
};
sw.Reset();
sw.Start();
nativePerJobThreadIntPtrParallelJob.Run(size);
long nativePerJobThreadIntPtrTicks = sw.ElapsedTicks;
// Report results
Debug.Log(
"Operation,Job Type,NativeArray,NativeList,NativeLinkedList,NativeChunkedList,NativeHashSet\n" +
"Add,Single," + "n/a" + "," + listAddTicks + "," + linkedListAddTicks + "," + chunkedListAddTicks + "," + hashSetAddTicks + "\n" +
"Iterate,Single," + arrayIterateTicks + "," + listIterateTicks + "," + linkedListIterateTicks + "," + chunkedListIterateTicks + "," + "n/a" + "\n" +
"Iterate,ParallelFor," + arrayIterateParallelForTicks + "," + "n/a" + "," + linkedListIterateParallelForTicks + "," + chunkedListIterateParallelForTicks + "," + "n/a" + "\n" +
"Insert,Single," + "n/a" + "," + "n/a" + "," + linkedListInsertTicks + "," + chunkedListInsertTicks + "," + "n/a" + "\n" +
"Remove,Single," + "n/a" + "," + "n/a" + "," + linkedListRemoveTicks + "," + chunkedListRemoveTicks + "," + hashSetRemoveTicks);
Debug.Log(
"Operation,Job Type,NativeIntPtr,NativePerJobThreadIntPtr\n" +
"Sum,ParallelFor," + nativeIntPtrTicks + "," + nativePerJobThreadIntPtrTicks);
// Dispose native collections
sum.Dispose();
array.Dispose();
list.Dispose();
linkedList.Dispose();
chunkedList.Dispose();
hashSet.Dispose();
nativeIntPtr.Dispose();
nativePerJobThreadIntPtr.Dispose();
// Quit
#if UNITY_EDITOR
EditorApplication.isPlaying = false;
#else
Application.Quit();
#endif
}
// Warm up the job system
static void WarmUpJobSystem()
{
// Create native collections
NativeArray <int> sum = new NativeArray <int>(1, Allocator.TempJob);
NativeArray <int> array = new NativeArray <int>(
4,
Allocator.TempJob);
NativeList <int> list = new NativeList <int>(
4,
Allocator.TempJob);
NativeLinkedList <int> linkedList = new NativeLinkedList <int>(
4,
Allocator.TempJob);
NativeChunkedList <int> chunkedList = new NativeChunkedList <int>(
4,
4,
Allocator.TempJob);
NativeHashSet <int> hashSet = new NativeHashSet <int>(
4,
Allocator.TempJob);
NativeIntPtr nativeIntPtr = new NativeIntPtr(Allocator.TempJob);
NativePerJobThreadIntPtr nativePerJobThreadIntPtr = new NativePerJobThreadIntPtr(
Allocator.TempJob);
// Create jobs
ListAddJob listAddJob = new ListAddJob
{
List = list
};
LinkedListAddJob linkedListAddJob = new LinkedListAddJob
{
List = linkedList
};
ChunkedListAddJob chunkedListAddJob = new ChunkedListAddJob
{
List = chunkedList
};
HashSetAddJob hashSetAddJob = new HashSetAddJob
{
Set = hashSet
};
ArrayIterateJob arrayIterateJob = new ArrayIterateJob
{
Array = array,
Sum = sum
};
ListIterateJob listIterateJob = new ListIterateJob
{
List = list,
Sum = sum
};
LinkedListIterateJob linkedListIterateJob = new LinkedListIterateJob
{
List = linkedList,
Sum = sum
};
ChunkedListIterateJob chunkedListIterateJob = new ChunkedListIterateJob
{
List = chunkedList,
Sum = sum
};
ArrayIterateJobParallelFor arrayIterateJobParallelFor = new ArrayIterateJobParallelFor
{
Array = array,
Sum = sum
};
LinkedListIterateJobParallelFor linkedListIterateJobParallelFor = new LinkedListIterateJobParallelFor
{
List = linkedList,
Sum = sum
};
ChunkedListIterateJobParallelFor chunkedListIterateJobParallelFor = new ChunkedListIterateJobParallelFor
{
List = chunkedList,
Sum = sum
};
LinkedListInsertJob linkedListInsertJob = new LinkedListInsertJob
{
LinkedList = linkedList
};
ChunkedListInsertJob chunkedListInsertJob = new ChunkedListInsertJob
{
List = chunkedList
};
LinkedListRemoveJob linkedListRemoveJob = new LinkedListRemoveJob
{
List = linkedList
};
ChunkedListRemoveJob chunkedListRemoveJob = new ChunkedListRemoveJob
{
List = chunkedList
};
HashSetRemoveJob hashSetRemoveJob = new HashSetRemoveJob
{
Set = hashSet
};
NativeIntPtrParallelJob nativeIntPtrParallelJob = new NativeIntPtrParallelJob
{
Array = array,
Sum = nativeIntPtr.GetParallel()
};
NativePerJobThreadIntPtrParallelJob nativePerJobThreadIntPtrParallelJob = new NativePerJobThreadIntPtrParallelJob
{
Array = array,
Sum = nativePerJobThreadIntPtr.GetParallel()
};
// Run jobs
listAddJob.Run();
linkedListAddJob.Run();
chunkedListAddJob.Run();
hashSetAddJob.Run();
arrayIterateJob.Run();
listIterateJob.Run();
linkedListIterateJob.Run();
chunkedListIterateJob.Run();
arrayIterateJobParallelFor.Run(array.Length);
linkedListIterateJobParallelFor.Run(linkedList.Length);
chunkedListIterateJobParallelFor.RunRanged(chunkedList.Length);
list.Clear();
linkedList.Clear();
chunkedList.Clear();
hashSet.Clear();
linkedListInsertJob.Run();
chunkedListInsertJob.Run();
linkedListRemoveJob.Run();
chunkedListRemoveJob.Run();
hashSetRemoveJob.Run();
nativeIntPtrParallelJob.Run(array.Length);
nativePerJobThreadIntPtrParallelJob.Run(array.Length);
// Dispose native collections
sum.Dispose();
array.Dispose();
list.Dispose();
linkedList.Dispose();
chunkedList.Dispose();
hashSet.Dispose();
nativeIntPtr.Dispose();
nativePerJobThreadIntPtr.Dispose();
}
