public void UnsafeMultiHashMap_ForEach_FixedStringInHashMap()
{
using (var stringList = new NativeList <FixedString32>(10, Allocator.Persistent)
{
"Hello", ",", "World", "!"
})
{
var container = new UnsafeMultiHashMap <FixedString128, float>(50, Allocator.Temp);
var seen = new NativeArray <int>(stringList.Length, Allocator.Temp);
foreach (var str in stringList)
{
container.Add(str, 0);
}
foreach (var pair in container)
{
int index = stringList.IndexOf(pair.Key);
Assert.AreEqual(stringList[index], pair.Key.ToString());
seen[index] = seen[index] + 1;
}
for (int i = 0; i < stringList.Length; i++)
{
Assert.AreEqual(1, seen[i], $"Incorrect value count {stringList[i]}");
}
}
}
public void UnsafeMultiHashMap_GetKeys()
{
var container = new UnsafeMultiHashMap <int, int>(1, Allocator.Temp);
for (int i = 0; i < 30; ++i)
{
container.Add(i, 2 * i);
container.Add(i, 3 * i);
}
var keys = container.GetKeyArray(Allocator.Temp);
#if !NET_DOTS // Tuple is not supported by TinyBCL
var(unique, uniqueLength) = container.GetUniqueKeyArray(Allocator.Temp);
Assert.AreEqual(30, uniqueLength);
#endif
Assert.AreEqual(60, keys.Length);
keys.Sort();
for (int i = 0; i < 30; ++i)
{
Assert.AreEqual(i, keys[i * 2 + 0]);
Assert.AreEqual(i, keys[i * 2 + 1]);
#if !NET_DOTS // Tuple is not supported by TinyBCL
Assert.AreEqual(i, unique[i]);
#endif
}
}
NativeMultiHashMap(int capacity, Allocator allocator, int disposeSentinelStackDepth)
{
m_MultiHashMapData = new UnsafeMultiHashMap <TKey, TValue>(capacity, allocator, disposeSentinelStackDepth);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
DisposeSentinel.Create(out m_Safety, out m_DisposeSentinel, disposeSentinelStackDepth, allocator);
#endif
}
public UnsafeMultiHashMapEnumerator(UnsafeMultiHashMap <TKey, TValue> map, TKey key)
{
this.map = map;
this.key = key;
iterator = default;
value = default;
isFirst = true;
}
public ConversionDependencies(bool isLiveLink)
{
m_IsLiveLink = isLiveLink;
if (m_IsLiveLink)
{
GameObjectDependentsByInstanceId = new UnsafeMultiHashMap <int, int>(0, Allocator.Persistent);
}
}
public void UnsafeMultiHashMap_RemoveOnEmptyMap_DoesNotThrow()
{
var container = new UnsafeMultiHashMap <int, int>(0, Allocator.Temp);
Assert.DoesNotThrow(() => container.Remove(0));
Assert.DoesNotThrow(() => container.Remove(-425196));
Assert.DoesNotThrow(() => container.Remove(0, 0));
Assert.DoesNotThrow(() => container.Remove(-425196, 0));
container.Dispose();
}
static void AssertDependencyExists <T>(ConversionDependencies dependencies, UnsafeMultiHashMap <T, int> map, T key, GameObject dependent) where T : unmanaged, IEquatable <T>
{
if (!dependencies.GameObjectIndexByInstanceId.TryGetValue(dependent.GetInstanceID(), out int idx))
{
Assert.Fail($"The conversion system didn't store the dependent game object {dependent.name}.");
}
Assert.AreEqual(dependent, dependencies.DependentGameObjects[idx]);
if (!map.TryGetFirstValue(key, out var value, out _))
{
Assert.Fail("The dependent wasn't registered to the key of the dependency.");
}
Assert.AreEqual(idx, value);
}
NativeMultiHashMap(int capacity, Allocator allocator, int disposeSentinelStackDepth)
{
m_MultiHashMapData = new UnsafeMultiHashMap <TKey, TValue>(capacity, allocator);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
DisposeSentinel.Create(out m_Safety, out m_DisposeSentinel, disposeSentinelStackDepth, allocator);
if (s_staticSafetyId.Data == 0)
{
CreateStaticSafetyId();
}
AtomicSafetyHandle.SetStaticSafetyId(ref m_Safety, s_staticSafetyId.Data);
#endif
}
public void UnsafeMultiHashMap_AddJob()
{
var container = new UnsafeMultiHashMap <int, int>(32, Allocator.TempJob);
var job = new UnsafeMultiHashMapAddJob()
{
Writer = container.AsParallelWriter(),
};
job.Schedule(3, 1).Complete();
Assert.True(container.ContainsKey(123));
Assert.AreEqual(container.CountValuesForKey(123), 3);
container.Dispose();
}
internal WorldUnmanagedImpl(ulong sequenceNumber, WorldFlags flags)
{
CurrentTime = default;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AllowGetSystem = true;
#endif
SequenceNumber = sequenceNumber;
MaximumDeltaTime = 1.0f / 3.0f;
Flags = flags;
_unmanagedSlotByTypeHash = new UnsafeMultiHashMap <long, ushort>(32, Allocator.Persistent);
_pendingDestroys = new UnsafeList <ushort>(32, Allocator.Persistent);
_stateMemory = default;
_stateMemory.Init();
Version = 0;
ExecutingSystem = default;
}
public void UnsafeMultiHashMap_ForEach([Values(10, 1000)] int n)
{
var seenKeys = new NativeArray <int>(n, Allocator.Temp);
var seenValues = new NativeArray <int>(n * 2, Allocator.Temp);
using (var container = new UnsafeMultiHashMap <int, int>(1, Allocator.Temp))
{
for (int i = 0; i < n; ++i)
{
container.Add(i, i);
container.Add(i, i + n);
}
var count = 0;
foreach (var kv in container)
{
if (kv.Value < n)
{
Assert.AreEqual(kv.Key, kv.Value);
}
else
{
Assert.AreEqual(kv.Key + n, kv.Value);
}
seenKeys[kv.Key] = seenKeys[kv.Key] + 1;
seenValues[kv.Value] = seenValues[kv.Value] + 1;
++count;
}
Assert.AreEqual(container.Count(), count);
for (int i = 0; i < n; i++)
{
Assert.AreEqual(2, seenKeys[i], $"Incorrect key count {i}");
Assert.AreEqual(1, seenValues[i], $"Incorrect value count {i}");
Assert.AreEqual(1, seenValues[i + n], $"Incorrect value count {i + n}");
}
}
}
protected override JobHandle OnUpdate(JobHandle inputDependencies)
{
var brickCount = m_BrickQuery.CalculateEntityCount();
if (brickCount == 0)
{
return(inputDependencies);
}
World.EntityManager.CreateEntity(typeof(BrickHashGrid));
var screenBounds = GetSingleton <ScreenBoundsData>();
var gridCellSize = 2.5f;
var screenWidthHeight = math.abs(screenBounds.XYMax - screenBounds.XYMin);
var screenWidthInCells = (int)math.ceil(screenWidthHeight.x / gridCellSize);
var hashGrid = new UnsafeMultiHashMap <int, Entity>(brickCount * 4, Allocator.Persistent);
new HashBrickPositionsJob
{
Grid = hashGrid,
GridCellSize = gridCellSize,
ScreenWidthInCells = screenWidthInCells
}.Run(this, inputDependencies);
var brickHashGrid = new BrickHashGrid
{
Grid = hashGrid,
GridCellSize = gridCellSize,
ScreenWidthInCells = screenWidthInCells
};
SetSingleton(brickHashGrid);
this.Enabled = false;
return(inputDependencies);
}
public static (NativeArray <TKey>, int) GetUniqueKeyArray <TKey, TValue>(this UnsafeMultiHashMap <TKey, TValue> container, Allocator allocator)
void AssertDependencyExists <T>(UnsafeMultiHashMap <T, int> map, T key, GameObject dependent) where T : unmanaged, IEquatable <T> => AssertDependencyExists(m_Dependencies, map, key, dependent);
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
if (!m_ObstacleQuery.IsEmptyIgnoreFilter)
{
return(inputDeps);
}
var settings = GetSingleton <AntManagerSettings>();
var obstacleSpawner = GetSingleton <ObstacleSpawner>();
float radius = obstacleSpawner.ObstacleRadius;
var mapSize = settings.MapSize;
var bucketResolution = settings.BucketResolution;
World.EntityManager.CreateEntity(typeof(ObstacleBuckets));
var values = new UnsafeMultiHashMap <int, Position>(bucketResolution * bucketResolution, Allocator.Persistent);
var buckets = new ObstacleBuckets {
Values = values
};
SetSingleton(buckets);
Entities.WithStructuralChanges().ForEach((ref ObstacleSpawner spawner) =>
{
var scale = new Vector3(spawner.ObstacleRadius * 2f, spawner.ObstacleRadius * 2f, 1f) / mapSize;
float obstaclesPerRing = spawner.ObstaclesPerRing;
for (int ring = 1; ring <= spawner.ObstacleRingCount; ring++)
{
float ringRadius = (ring / (spawner.ObstacleRingCount + 1f)) * (mapSize * .5f);
float circumference = ringRadius * 2f * Mathf.PI;
int maxCount = Mathf.CeilToInt(circumference / (2f * spawner.ObstacleRadius) * 2f);
int offset = UnityEngine.Random.Range(0, maxCount);
int holeCount = UnityEngine.Random.Range(1, 3);
NativeList <Vector2> obstaclesToSpawn = new NativeList <Vector2>(maxCount, Allocator.TempJob);
for (int j = 0; j < maxCount; j++)
{
float t = (float)j / maxCount;
if ((t * holeCount) % 1f < obstaclesPerRing)
{
float angle = (j + offset) / (float)maxCount * (2f * Mathf.PI);
Vector2 pos = new Vector2(mapSize * .5f + Mathf.Cos(angle) * ringRadius, mapSize * .5f + Mathf.Sin(angle) * ringRadius);
obstaclesToSpawn.Add(pos);
}
}
using (var obstacles = EntityManager.Instantiate(spawner.ObstaclePrefab, obstaclesToSpawn.Length, Allocator.TempJob))
{
for (int j = 0; j < obstacles.Length; j++)
{
Vector2 pos = obstaclesToSpawn[j];
EntityManager.SetComponentData(obstacles[j], new Position()
{
Value = pos
});
EntityManager.SetComponentData(obstacles[j], new LocalToWorld()
{
Value = Matrix4x4.TRS(pos / mapSize, Quaternion.identity, scale)
});
}
obstacles.Dispose();
}
obstaclesToSpawn.Dispose();
}
}).Run();
Entities.WithStructuralChanges().WithAll <TagObstacle>().ForEach((Position pos) =>
{
for (int x = Mathf.FloorToInt((pos.Value.x - radius) / mapSize * bucketResolution); x <= Mathf.FloorToInt((pos.Value.x + radius) / mapSize * bucketResolution); x++)
{
if (x < 0 || x >= bucketResolution)
{
continue;
}
for (int y = Mathf.FloorToInt((pos.Value.y - radius) / mapSize * bucketResolution); y <= Mathf.FloorToInt((pos.Value.y + radius) / mapSize * bucketResolution); y++)
{
if (y < 0 || y >= bucketResolution)
{
continue;
}
buckets.Values.Add(ObstacleBuckets.Hash(mapSize, x, y), pos);
}
}
}).Run();
return(inputDeps);
}
internal DependencyTracker(Allocator allocator)
{
_dependentsByInstanceId = new UnsafeMultiHashMap <int, int>(0, allocator);
_dependenciesByInstanceId = new UnsafeMultiHashMap <int, int>(0, allocator);
}
public ValueGroupingValues(TKey key, UnsafeMultiHashMap <TKey, TValue> map)
{
this.enumerator = new UnsafeMultiHashMapEnumerator <TKey, TValue>(map, key);
}
