public void EndExclusiveTransaction()
{
if (!IsInTransaction)
{
return;
}
m_ExclusiveTransactionDependency.Complete();
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var res = AtomicSafetyHandle.EnforceAllBufferJobsHaveCompletedAndRelease(ExclusiveTransactionSafety);
if (res != EnforceJobResult.AllJobsAlreadySynced)
{
//@TODO: Better message
Debug.LogError("ExclusiveEntityTransaction job has not been registered");
}
#endif
IsInTransaction = false;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
for (var i = 0; i != TypeManager.GetTypeCount(); i++)
{
m_ComponentSafetyHandles[i].SafetyHandle = AtomicSafetyHandle.Create();
AtomicSafetyHandle.SetAllowSecondaryVersionWriting(m_ComponentSafetyHandles[i].SafetyHandle, false);
}
#endif
}
public void BeginExclusiveTransaction()
{
if (IsInTransaction)
{
return;
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
for (var i = 0; i != TypeManager.GetTypeCount(); i++)
{
AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].SafetyHandle);
AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].BufferHandle);
}
for (var i = 0; i != TypeManager.GetTypeCount(); i++)
{
AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].SafetyHandle);
AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].BufferHandle);
}
#endif
IsInTransaction = true;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
ExclusiveTransactionSafety = AtomicSafetyHandle.Create();
#endif
m_ExclusiveTransactionDependency = GetAllDependencies();
}
internal static int CallTypeIndexForStableTypeHash(ulong typeHash)
{
for (int i = 0; i < TypeManager.GetTypeCount(); ++i)
{
var t = TypeManager.GetTypeInfo(i);
if (typeHash == t.StableTypeHash)
{
return(t.TypeIndex);
}
}
return(-1);
}
public SharedComponentDataManager()
{
var actualCount = TypeManager.GetTypeCount() - SharedComponentTypeStart;
dataArray = new Element[actualCount];
for (int i = 0; i < dataArray.Length; i++)
{
var type = TypeManager.GetType(i + SharedComponentTypeStart);
if (!ISharedComponentDataType.IsAssignableFrom(type) || !type.IsValueType)
{
continue;
}
dataArray[i] = Element.Create(128, type);
}
}
public List <Type> GetAssignableComponentTypes(Type interfaceType)
{
int typeCount = TypeManager.GetTypeCount();
List <Type> list = new List <Type>();
for (int i = 0; i < typeCount; i++)
{
Type c = TypeManager.GetType(i);
if (interfaceType.IsAssignableFrom(c))
{
list.Add(c);
}
}
return(list);
}
public List <Type> GetAssignableComponentTypes(Type interfaceType, List <Type> listOut)
{
// #todo Cache this. It only can change when TypeManager.GetTypeCount() changes
var componentTypeCount = TypeManager.GetTypeCount();
for (var i = 0; i < componentTypeCount; i++)
{
var type = TypeManager.GetType(i);
if (interfaceType.IsAssignableFrom(type))
{
listOut.Add(type);
}
}
return(listOut);
}
//@TODO: Optimize as one function call to in batch bump version on every single handle...
public void CompleteAllJobsAndInvalidateArrays()
{
if (m_HasCleanHandles)
{
return;
}
Profiler.BeginSample("CompleteAllJobsAndInvalidateArrays");
var count = TypeManager.GetTypeCount();
for (var t = 0; t != count; t++)
{
m_ComponentSafetyHandles[t].WriteFence.Complete();
var readFencesCount = m_ComponentSafetyHandles[t].NumReadFences;
var readFences = m_ReadJobFences + t * kMaxReadJobHandles;
for (var r = 0; r != readFencesCount; r++)
{
readFences[r].Complete();
}
m_ComponentSafetyHandles[t].NumReadFences = 0;
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
for (var i = 0; i != count; i++)
{
AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].SafetyHandle);
AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].BufferHandle);
}
for (var i = 0; i != count; i++)
{
AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].SafetyHandle);
m_ComponentSafetyHandles[i].SafetyHandle = AtomicSafetyHandle.Create();
AtomicSafetyHandle.SetAllowSecondaryVersionWriting(m_ComponentSafetyHandles[i].SafetyHandle, false);
AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].BufferHandle);
m_ComponentSafetyHandles[i].BufferHandle = AtomicSafetyHandle.Create();
}
#endif
m_HasCleanHandles = true;
Profiler.EndSample();
}
private void ReAlloc(int requiredComponentTypeIndexNotModified)
{
var oldLength = dataArray.Length;
if (requiredComponentTypeIndexNotModified < oldLength + SharedComponentTypeStart)
{
return;
}
var currentActualLength = TypeManager.GetTypeCount() - SharedComponentTypeStart;
for (int i = currentActualLength - 1; i >= oldLength; --i)
{
var type = TypeManager.GetType(i + SharedComponentTypeStart);
if (!type.IsValueType || !ISharedComponentDataType.IsAssignableFrom(type))
{
continue;
}
var tmp = new Element[i + 1];
Buffer.BlockCopy(dataArray, 0, tmp, 0, dataArray.Length);
dataArray = tmp;
dataArray[i] = Element.Create(128, type);
break;
}
for (int i = dataArray.Length - 2; i >= oldLength; --i)
{
var type = TypeManager.GetType(i + SharedComponentTypeStart);
if (!ISharedComponentDataType.IsAssignableFrom(type) || !type.IsValueType || (type.IsGenericType && type.IsGenericTypeDefinition))
{
continue;
}
#if REF_EQUATABLE
var EqualsMethodInfo = type.GetMethod("Equals", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly, null, CallingConventions.Any, EqualsTypeArray, null);
if (EqualsMethodInfo == null || EqualsMethodInfo.DeclaringType != type)
{
throw new Exception(type.FullName);
}
var GetHashCodeMethodInfo = type.GetMethod("GetHashCode", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly, null, CallingConventions.Any, Array.Empty <Type>(), null);
if (GetHashCodeMethodInfo == null || GetHashCodeMethodInfo.DeclaringType != type)
{
throw new Exception(type.FullName);
}
#endif
dataArray[i] = Element.Create(128, type);
}
}
static SharedComponentDataManager()
{
TypeManager.Initialize();
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
ISharedComponentDataType = typeof(ISharedComponentData);
for (int i = 0; i < assemblies.Length; ++i)
{
var types = assemblies[i].GetTypes();
for (int j = 0; j < types.Length; ++j)
{
if (!types[j].IsValueType || !ISharedComponentDataType.IsAssignableFrom(types[j]) || (types[j].IsGenericType && types[j].IsGenericTypeDefinition))
{
continue;
}
TypeManager.GetTypeIndex(types[j]);
}
}
for (int i = 1, length = TypeManager.GetTypeCount(); i < length; ++i)
{
var type = TypeManager.GetType(i);
if (!type.IsValueType || !ISharedComponentDataType.IsAssignableFrom(type) || (type.IsGenericType && type.IsGenericTypeDefinition))
{
continue;
}
#if REF_EQUATABLE
var EqualsMethodInfo = type.GetMethod("Equals", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly, null, CallingConventions.Any, EqualsTypeArray, null);
if (EqualsMethodInfo == null || EqualsMethodInfo.DeclaringType != type)
{
throw new Exception(type.FullName);
}
var GetHashCodeMethodInfo = type.GetMethod("GetHashCode", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly, null, CallingConventions.Any, Array.Empty <Type>(), null);
if (GetHashCodeMethodInfo == null || GetHashCodeMethodInfo.DeclaringType != type)
{
throw new Exception(type.FullName);
}
#endif
SharedComponentTypeStart = i;
break;
}
}
JobHandle GetAllDependencies()
{
var jobHandles = new NativeArray <JobHandle>(TypeManager.GetTypeCount() * (kMaxReadJobHandles + 1), Allocator.Temp);
var count = 0;
for (var i = 0; i != TypeManager.GetTypeCount(); i++)
{
jobHandles[count++] = m_ComponentSafetyHandles[i].WriteFence;
var numReadFences = m_ComponentSafetyHandles[i].NumReadFences;
for (var j = 0; j != numReadFences; j++)
{
jobHandles[count++] = m_ReadJobFences[i * kMaxReadJobHandles + j];
}
}
var combined = JobHandle.CombineDependencies(jobHandles);
jobHandles.Dispose();
return(combined);
}
