void playingAnimations_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
var item = (PlayingAnimation)e.Item;
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
{
item.attached = true;
break;
}
case NotifyCollectionChangedAction.Remove:
{
var evaluator = item.Evaluator;
if (evaluator != null)
{
Blender.ReleaseEvaluator(evaluator);
item.Evaluator = null;
}
item.endedTCS?.TrySetResult(true);
item.endedTCS = null;
item.attached = false;
break;
}
}
}
/// <summary>
/// The <see cref="AudioSystem"/> listeners collection has been modified.
/// Mark AudioEmitter not for update if removed from the list.
/// Create the AudioEmitter data and mark it for update if added to the list.
/// </summary>
/// <param name="o"></param>
/// <param name="args"></param>
private void OnListenerCollectionChanged(object o, TrackingCollectionChangedEventArgs args)
{
if (!args.CollectionChanged) // no keys have been added or removed, only one of the values changed
{
return;
}
var listenersData = matchingEntities.Values.Where(x => x.ListenerComponent == args.Key);
if (args.Action == NotifyCollectionChangedAction.Add) // A new listener have been added
{
foreach (var listenerData in listenersData)
{
InitializeAudioEmitter(listenerData);
listenerData.ShouldBeComputed = true;
}
}
else if (args.Action == NotifyCollectionChangedAction.Remove) // A listener have been removed
{
foreach (var listenerData in listenersData)
{
listenerData.ShouldBeComputed = false;
}
}
}
private void Slots_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
{
var slot = (Slot)e.Item;
var slots = slot.Direction == SlotDirection.Input ? InputSlots : OutputSlots;
var slotViewModel = new VisualScriptSlotViewModel(ViewModel, slot);
slots.Add(slotViewModel);
ViewModel.Slots.Add(slot, slotViewModel);
break;
}
case NotifyCollectionChangedAction.Remove:
{
var slot = (Slot)e.Item;
var slots = slot.Direction == SlotDirection.Input ? InputSlots : OutputSlots;
var slotViewModel = ViewModel.Slots[slot];
slots.Remove(slotViewModel);
ViewModel.Slots.Remove(slot);
break;
}
default:
throw new NotSupportedException();
}
}
private void MeshListenerOnCollectionChanged(object sender, TrackingCollectionChangedEventArgs trackingCollectionChangedEventArgs)
{
throw new NotImplementedException();
//var updater = updaters.Where(particleUpdater => particleUpdater.Mesh != null).FirstOrDefault(particleUpdater => ReferenceEquals(sender, particleUpdater.Mesh.SubMeshes));
//if (updater != null)
// updater.Emitter.OnMeshUpdate(updater.Entity, trackingCollectionChangedEventArgs);
}
private void OnListenerCollectionChanged(object o, TrackingCollectionChangedEventArgs args)
{
if (!args.CollectionChanged) // no keys have been added or removed, only one of the values changed
{
return;
}
// A listener have been Added or Removed.
// We need to create/destroy all SoundInstances associated to that listener for each AudioEmitterComponent.
for (int a = 0; a < ComponentDataValues.Count; a++)
{
var associatedData = ComponentDataValues[a];
var soundControllers = associatedData.AudioEmitterComponent.SoundToController.Values;
foreach (var soundController in soundControllers)
{
if (args.Action == NotifyCollectionChangedAction.Add) // A new listener have been added
{
soundController.CreateSoundInstance((AudioListenerComponent)args.Key, false);
}
else if (args.Action == NotifyCollectionChangedAction.Remove) // A listener have been removed
{
soundController.DestroySoundInstances((AudioListenerComponent)args.Key);
}
}
}
}
/// <summary>
/// Notification that the modules (plugins) have changed.
/// Pool's fields may need to be updated if new are required or old ones are no longer needed.
/// </summary>
/// <param name="sender">Sender</param>
/// <param name="e">Event arguments</param>
private void ModulesChanged(object sender, TrackingCollectionChangedEventArgs e)
{
var module = e.Item as ParticleModule;
if (module == null)
{
return;
}
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
for (int i = 0; i < module.RequiredFields.Count; i++)
{
AddRequiredField(module.RequiredFields[i]);
}
break;
case NotifyCollectionChangedAction.Remove:
for (int i = 0; i < module.RequiredFields.Count; i++)
{
RemoveRequiredField(module.RequiredFields[i]);
}
break;
}
}
private void OnListenerCollectionChanged(object o, TrackingCollectionChangedEventArgs args)
{
if (!args.CollectionChanged)// no keys have been added or removed, only one of the values changed
{
return;
}
// A listener have been Added or Removed.
// We need to create/destroy all SoundEffectInstances associated to that listener for each AudioEmitterComponent.
foreach (var associatedData in ComponentDatas.Values)
{
var listenerControllerToSoundInstance = associatedData.ListenerControllerToSoundInstance;
var soundControllers = associatedData.AudioEmitterComponent.SoundEffectToController.Values;
foreach (var soundController in soundControllers)
{
var currentTupple = Tuple.Create((AudioListenerComponent)args.Key, soundController);
if (args.Action == NotifyCollectionChangedAction.Add) // A new listener have been added
{
listenerControllerToSoundInstance[currentTupple] = soundController.CreateSoundInstance();
}
else if (args.Action == NotifyCollectionChangedAction.Remove) // A listener have been removed
{
soundController.DestroySoundInstance(listenerControllerToSoundInstance[currentTupple]);
listenerControllerToSoundInstance.Remove(currentTupple);
}
}
}
}
private void UpdateTargetConnectors(object sender, TrackingCollectionChangedEventArgs e)
{
// Unregister ourselves
((NodeVertexControl)Target).Connectors.CollectionChanged -= UpdateTargetConnectors;
// Update edge
UpdateEdge();
}
public void OnMeshUpdate(Entity entity, TrackingCollectionChangedEventArgs updateArgs)
{
var update = MeshUpdate;
if (update != null)
{
update(this, Entity, updateArgs);
}
}
void globalLights_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
InternalAddEntity(((LightComponent)e.Item).Entity);
}
else if (e.Action == NotifyCollectionChangedAction.Remove)
{
InternalRemoveEntity(((LightComponent)e.Item).Entity);
}
}
private void GameSystems_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
GameSystems_ItemAdded(sender, e);
}
else if (e.Action == NotifyCollectionChangedAction.Remove)
{
GameSystems_ItemRemoved(sender, e);
}
}
private void GameSystemsOnCollectionChanged(object sender, TrackingCollectionChangedEventArgs trackingCollectionChangedEventArgs)
{
// Detect addition of dynamic navigation mesh system
if (dynamicNavigationMeshSystem == null)
{
dynamicNavigationMeshSystem = gameSystemCollection.OfType <DynamicNavigationMeshSystem>().FirstOrDefault();
if (dynamicNavigationMeshSystem != null)
{
dynamicNavigationMeshSystem.NavigationMeshUpdated += DynamicNavigationMeshSystemOnNavigationMeshUpdatedUpdated;
}
}
}
private void OnSoundsOnCollectionChanged(object sender, TrackingCollectionChangedEventArgs args)
{
switch (args.Action)
{
case NotifyCollectionChangedAction.Add:
AttachSound((SoundBase)args.Item);
break;
case NotifyCollectionChangedAction.Remove:
DetachSound((SoundBase)args.Item);
break;
}
}
private void GameSystemsOnCollectionChanged(object sender, TrackingCollectionChangedEventArgs trackingCollectionChangedEventArgs)
{
if (trackingCollectionChangedEventArgs.Action == NotifyCollectionChangedAction.Add)
{
if (trackingCollectionChangedEventArgs.Item is DynamicNavigationMeshSystem dynamicNavigationMeshSystem)
{
dynamicNavigationMeshSystem.Enabled = true;
// No longer need to listen to changes
Game.GameSystems.CollectionChanged -= GameSystemsOnCollectionChanged;
}
}
}
private void GameSystemsOnCollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
if (dynamicNavigationMeshSystem != null)
{
return;
}
// Handle addition of dynamic navigation mesh system
if (e.Action == NotifyCollectionChangedAction.Add)
{
SetDynamicNavigationSystem(e.Item as DynamicNavigationMeshSystem);
}
}
private void rootEntities_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
transformationRoots.Add(((Entity)e.Item).Transform);
break;
case NotifyCollectionChangedAction.Remove:
transformationRoots.Remove(((Entity)e.Item).Transform);
break;
}
}
void playingAnimations_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Remove)
{
var item = (PlayingAnimation)e.Item;
var evaluator = item.Evaluator;
if (evaluator != null)
{
Blender.ReleaseEvaluator(evaluator);
item.Evaluator = null;
}
}
}
private void Entities_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
Add((Entity)e.Item);
break;
case NotifyCollectionChangedAction.Remove:
Remove((Entity)e.Item);
break;
}
}
//private void entities_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
//{
// var entity = (Entity)e.Item;
// switch (e.Action)
// {
// case NotifyCollectionChangedAction.Add:
// InternalAddEntity(entity);
// break;
// case NotifyCollectionChangedAction.Remove:
// InternalRemoveEntity(entity);
// break;
// }
//}
private void systems_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
OnProcessorAdded((EntityProcessor)e.Item);
break;
case NotifyCollectionChangedAction.Remove:
OnProcessorRemoved((EntityProcessor)e.Item);
break;
}
}
private void Children_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
Add((Scene)e.Item);
break;
case NotifyCollectionChangedAction.Remove:
Remove((Scene)e.Item);
break;
}
}
private void GameSystems_ItemRemoved(object sender, TrackingCollectionChangedEventArgs e)
{
var gameSystem = (IGameSystemBase)e.Item;
if (State == GameSystemState.None)
{
pendingGameSystems.Remove(gameSystem);
}
var contentableSystem = gameSystem as IContentable;
if (contentableSystem != null)
{
lock (contentableGameSystems)
{
contentableGameSystems.Remove(contentableSystem);
}
// UnLoads the content of IContentable when running
if (State == GameSystemState.ContentLoaded)
{
contentableSystem.UnloadContent();
}
}
var updateableSystem = gameSystem as IUpdateable;
if (updateableSystem != null)
{
lock (updateableGameSystems)
{
var key = new KeyValuePair <IUpdateable, ProfilingKey>(updateableSystem, null);
updateableGameSystems.Remove(key);
}
updateableSystem.UpdateOrderChanged -= UpdateableGameSystem_UpdateOrderChanged;
}
var drawableSystem = gameSystem as IDrawable;
if (drawableSystem != null)
{
lock (drawableGameSystems)
{
var key = new KeyValuePair <IDrawable, ProfilingKey>(drawableSystem, null);
drawableGameSystems.Remove(key);
}
drawableSystem.DrawOrderChanged -= DrawableGameSystem_DrawOrderChanged;
}
}
void Components_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
// Remove entity owner from previous EntityComponentData.
if (e.OldItem is EntityComponentData)
{
((EntityComponentData)e.OldItem).Entity = null;
}
// Set entity owner to this new EntityComponentData.
if (e.Item is EntityComponentData)
{
((EntityComponentData)e.Item).Entity = this;
}
}
private void GameSystems_ItemAdded(object sender, TrackingCollectionChangedEventArgs e)
{
var gameSystem = (IGameSystemBase)e.Item;
// If the game is already running, then we can initialize the game system now
if (State >= GameSystemState.Initialized)
{
gameSystem.Initialize();
}
else
{
// else we need to initialize it later
pendingGameSystems.Add(gameSystem);
}
// Add a contentable system to a separate list
var contentableSystem = gameSystem as IContentable;
if (contentableSystem != null)
{
lock (contentableGameSystems)
{
if (!contentableGameSystems.Contains(contentableSystem))
{
contentableGameSystems.Add(contentableSystem);
}
}
// Load the content of IContentable when running
if (State >= GameSystemState.ContentLoaded)
{
contentableSystem.LoadContent();
}
}
// Add an updateable system to the separate list
var updateableGameSystem = gameSystem as IUpdateable;
if (updateableGameSystem != null && AddGameSystem(updateableGameSystem, updateableGameSystems, UpdateableComparer.Default, GameProfilingKeys.GameUpdate))
{
updateableGameSystem.UpdateOrderChanged += UpdateableGameSystem_UpdateOrderChanged;
}
// Add a drawable system to the separate list
var drawableGameSystem = gameSystem as IDrawable;
if (drawableGameSystem != null && AddGameSystem(drawableGameSystem, drawableGameSystems, DrawableComparer.Default, GameProfilingKeys.GameDraw))
{
drawableGameSystem.DrawOrderChanged += DrawableGameSystem_DrawOrderChanged;
}
}
private void Bindings_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
var virtualButtonBinding = (VirtualButtonBinding)e.Item;
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
AddBinding(virtualButtonBinding);
break;
case NotifyCollectionChangedAction.Remove:
RemoveBinding(virtualButtonBinding);
break;
}
}
void Processors_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
var renderer = (Renderer)e.Item;
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
renderer.Load();
break;
case NotifyCollectionChangedAction.Remove:
renderer.Unload();
break;
}
}
private void Pipelines_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
var renderPass = (RenderPass)e.Item;
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
RenderPassAdded(renderPass);
break;
case NotifyCollectionChangedAction.Remove:
RenderPassRemoved(renderPass);
break;
}
}
private void Slots_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
OnSlotAdd((Slot)e.Item);
break;
case NotifyCollectionChangedAction.Remove:
OnSlotRemove((Slot)e.Item);
break;
default:
throw new NotSupportedException();
}
}
private void ChildrenCollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
AddItem((TransformComponent)e.Item);
break;
case NotifyCollectionChangedAction.Remove:
RemoveItem((TransformComponent)e.Item);
break;
default:
throw new NotSupportedException();
}
}
private void RenderFeatures_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
var renderFeature = (SubRenderFeature)e.Item;
switch (e.Action)
{
case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
renderFeature.AttachRootRenderFeature(this);
renderFeature.Initialize(Context);
break;
case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
renderFeature.Dispose();
break;
}
}
void rootEntities_CollectionChanged(object sender, TrackingCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
EntityManager.Add((Entity)e.Item);
break;
case NotifyCollectionChangedAction.Remove:
EntityManager.Remove((Entity)e.Item);
break;
default:
throw new NotSupportedException();
}
}
private void OnMeshUpdate(ParticleEmitterComponent particleEmitterComponent, Entity entity, TrackingCollectionChangedEventArgs arg3)
{
if (entity.Name.StartsWith("maguma_"))
{
var meshComponent = entity.Get(ModelComponent.Key);
if (meshComponent == null)
return;
foreach (var effectMesh in meshComponent.SubMeshes)
{
var subMeshData = effectMesh.MeshData.Value.SubMeshDatas[MeshData.StandardSubMeshData];
var buffer = subMeshData.GetVertexBufferData<Vector3>("POSITION");
var gpuBuffer = Buffer.Structured.New(renderContext.GraphicsDevice, buffer);
Parameters.Set(ScriptParticleSmoke.VerticesEmitterKey, gpuBuffer);
break;
}
}
}
