private void OnDataAdded(AddedDataEvent addedData) {
var accessor = new DataAccessor(addedData.AddedDataType);
DataRenderer renderer;
if (DataRegistry.TryGetRenderer(accessor, out renderer)) {
SparseArray<DataRenderer> renderers = GetRenderers(addedData.Entity);
renderer.Initialize(addedData.Entity);
renderers[accessor.Id] = renderer;
}
}
private void OnDataAdded(AddedDataEvent addedData)
{
var accessor = new DataAccessor(addedData.AddedDataType);
DataRenderer renderer;
if (DataRegistry.TryGetRenderer(accessor, out renderer))
{
SparseArray <DataRenderer> renderers = GetRenderers(addedData.Entity);
renderer.Initialize(addedData.Entity);
renderers[accessor.Id] = renderer;
}
}
/// <summary>
/// Applies data state changes to the entity.
/// </summary>
/// <remarks>
/// This function is not thread-safe; no other API calls can be made to the Entity while
/// this function is being executed.
/// </remarks>
/// <returns>If more data state change updates are needed</returns>
public void DataStateChangeUpdate()
{
// do removals
{
for (int i = 0; i < _toRemoveStage1.Count; ++i)
{
int id = _toRemoveStage1[i].Id;
_removedLastFrame[id] = _toRemoveStage1[i];
// _removedLastFrame[id] is removed in stage2
_eventDispatcher.Submit(RemovedDataEvent.Create(this, DataAccessorFactory.GetTypeFromId(id)));
}
for (int i = 0; i < _toRemoveStage2.Count; ++i)
{
int id = _toRemoveStage2[i].Id;
_removedLastFrame.Remove(id);
_data.Remove(id);
}
_toRemoveStage2.Clear();
Utils.Swap(ref _toRemoveStage1, ref _toRemoveStage2);
}
// We don't throw an exception immediately. If we are throwing an exception, that means
// that the Entity is in an invalid state (adding a bad data instance). However, the
// only way to recover from that invalid state is by having this method terminate.
// Hence, we only throw an exception at the end of the method.
Exception exceptionToThrow = null;
// do additions
for (int i = 0; i < _toAddStage1.Count; ++i)
{
Data.IData added = _toAddStage1[i];
int id = DataAccessorFactory.GetId(added.GetType());
// make sure we do not readd the same data instance twice
if (_data.ContainsKey(id))
{
exceptionToThrow = new AlreadyAddedDataException(this, new DataAccessor(added));
continue;
}
_addedLastFrame[id] = added;
if (added is Data.IVersioned)
{
Data.IVersioned versioned = (Data.IVersioned)added;
_data[id] = new VersionedDataContainer(versioned.Duplicate(), versioned.Duplicate(), versioned.Duplicate());
}
else
{
Data.NonVersioned nonVersioned = (Data.NonVersioned)added;
_data[id] = new NonVersionedDataContainer(nonVersioned);
}
// visualize the initial data
_eventDispatcher.Submit(AddedDataEvent.Create(this, added.GetType()));
}
for (int i = 0; i < _toAddStage2.Count; ++i)
{
_addedLastFrame.Remove(new DataAccessor(_toAddStage2[i]).Id);
}
_toAddStage2.Clear();
Utils.Swap(ref _toAddStage1, ref _toAddStage2);
if (exceptionToThrow != null)
{
throw exceptionToThrow;
}
}
private static void OnDataAdded(AddedDataEvent addedData)
{
var container = EntityContainer.GetContainer(addedData.Entity);
var accessor = new DataAccessor(addedData.AddedDataType);
DataRegistry.TryAddRenderer(accessor, container.gameObject, addedData.Entity);
}
