/// <summary>
/// Updates the scene's and prepares all views for rendering.
/// </summary>
/// <param name="renderingRenderLoops">The registered render loops on the current pass.</param>
/// <param name="scenesToRender">All scenes to be updated / rendered.</param>
/// <param name="devicesInUse">The rendering devices that are in use.</param>
/// <param name="inputFrames">All InputFrames gathered during last render.</param>
/// <param name="updateState">Current global update state.</param>
private async Task UpdateAndPrepareRendering(List <RenderLoop> renderingRenderLoops, List <Scene> scenesToRender, List <EngineDevice> devicesInUse, IEnumerable <InputFrame> inputFrames, UpdateState updateState)
{
using (var perfToken = m_host.BeginMeasureActivityDuration(Constants.PERF_GLOBAL_UPDATE_AND_PREPARE))
{
List <Action> additionalContinuationActions = new List <Action>();
object additionalContinuationActionsLock = new object();
// Trigger all tasks for preparing views
List <Task <List <Action> > > prepareRenderTasks = new List <Task <List <Action> > >(renderingRenderLoops.Count);
for (int actDeviceIndex = 0; actDeviceIndex < devicesInUse.Count; actDeviceIndex++)
{
EngineDevice actDevice = devicesInUse[actDeviceIndex];
for (int loop = 0; loop < renderingRenderLoops.Count; loop++)
{
RenderLoop actRenderLoop = renderingRenderLoops[loop];
if (actRenderLoop.Device == actDevice)
{
// Call prepare render and wait for the answer
// => Error handling is a bit tricky..
// Errors are catched by the continuation action
var actTask = actRenderLoop.PrepareRenderAsync();
prepareRenderTasks.Add(actTask.ContinueWith((givenTask) =>
{
if (!givenTask.IsFaulted)
{
return(givenTask.Result);
}
else
{
// Deregister this RenderLoop
lock (additionalContinuationActionsLock)
{
additionalContinuationActions.Add(() =>
{
this.DeregisterRenderLoop(actRenderLoop);
renderingRenderLoops.Remove(actRenderLoop);
});
}
return(new List <Action>());
}
}));
}
}
}
// Handle initial configuration of render loops (=> No current device)
for (int loop = 0; loop < renderingRenderLoops.Count; loop++)
{
RenderLoop actRenderLoop = renderingRenderLoops[loop];
if (actRenderLoop.Device == null)
{
try
{
Task <List <Action> > actPrepareRenderTask = actRenderLoop.PrepareRenderAsync();
await actPrepareRenderTask;
lock (additionalContinuationActionsLock)
{
additionalContinuationActions.AddRange(actPrepareRenderTask.Result);
}
}
catch (Exception)
{
// Deregister this RenderLoop
lock (additionalContinuationActionsLock)
{
additionalContinuationActions.Add(() =>
{
this.DeregisterRenderLoop(actRenderLoop);
renderingRenderLoops.Remove(actRenderLoop);
});
}
}
}
}
// Update all scenes
ThreadSaveQueue <Exception> exceptionsDuringUpdate = new ThreadSaveQueue <Exception>();
Parallel.For(0, scenesToRender.Count, (actTaskIndex) =>
{
try
{
using (var perfToken2 = m_host.BeginMeasureActivityDuration(
string.Format(Constants.PERF_GLOBAL_UPDATE_SCENE, actTaskIndex)))
{
Scene actScene = scenesToRender[actTaskIndex];
SceneRelatedUpdateState actUpdateState = actScene.CachedUpdateState;
actUpdateState.OnStartSceneUpdate(actScene, updateState, inputFrames);
actScene.Update(actUpdateState);
}
}
catch (Exception ex)
{
exceptionsDuringUpdate.Enqueue(ex);
}
});
// Await synchronizations with the view(s)
if (prepareRenderTasks.Count > 0)
{
await Task.WhenAll(prepareRenderTasks.ToArray());
}
// Throw exceptions if any occurred during scene update
// => This would be a fatal exception, so throw up to main loop
if (exceptionsDuringUpdate.HasAny())
{
throw new AggregateException("Error(s) during Scene update!", exceptionsDuringUpdate.DequeueAll().ToArray());
}
// Trigger all continuation actions returned by the previously executed prepare tasks
foreach (var actPrepareTasks in prepareRenderTasks)
{
if (actPrepareTasks.IsFaulted || actPrepareTasks.IsCanceled)
{
continue;
}
foreach (Action actContinuationAction in actPrepareTasks.Result)
{
actContinuationAction();
}
}
foreach (var actAction in additionalContinuationActions)
{
actAction();
}
// Reset all dummy flags before rendering
foreach (var actRenderLoop in renderingRenderLoops)
{
actRenderLoop.ResetFlagsBeforeRendering();
}
// Unload all derigistered RenderLoops
await UpdateRenderLoopRegistrationsAsync(renderingRenderLoops);
}
}