chore: import upstream snapshot with attribution

Player/Program.Loading.cs

@@ -0,0 +1,162 @@
+using System.IO;
+using System.Linq;
+using System.Threading;
+using SharpDX;
+using SharpDX.Direct3D11;
+using SharpDX.DXGI;
+using T3.Core.Animation;
+using T3.Core.Audio;
+using T3.Core.Compilation;
+using T3.Core.DataTypes.Vector;
+using T3.Core.IO;
+using T3.Core.Logging;
+using T3.Core.Model;
+using T3.Core.Operator;
+using T3.Core.Operator.Slots;
+using T3.Core.Settings;
+using Texture2D = T3.Core.DataTypes.Texture2D;
+
+namespace T3.Player;
+
+internal static partial class Program
+{
+    private static void LoadOperators()
+    {
+        var searchDirectory = Path.Combine(FileLocations.StartFolder, FileLocations.OperatorsSubFolder);
+        Log.Info($"Loading operators from \"{searchDirectory}\"...");
+
+        var assemblies = Directory.GetDirectories(searchDirectory, "*", SearchOption.TopDirectoryOnly)
+                                  .Select(packageDir =>
+                                          {
+                                              var releaseInfoPath = Path.Combine(packageDir, ReleaseInfo.FileName);
+                                              var assetsOnlyPath = !File.Exists(releaseInfoPath);
+                                              if (assetsOnlyPath)
+                                                  return null;
+                                              
+                                              var assemblyInformation = new AssemblyInformation(packageDir);
+                                              Log.Debug($"Searching for dlls in {packageDir}...");
+                                              return assemblyInformation; 
+                                          })
+                                  .Where(x => x != null)
+                                  .ToArray();
+        
+        Log.Debug($"Finished loading {assemblies.Length} operator assemblies. Loading symbols...");
+        var packageLoadInfo = assemblies
+                             //.AsParallel()
+                             .Select(assemblyInfo =>
+                                     {
+                                         var symbolPackage = new PlayerSymbolPackage(assemblyInfo);
+                                         symbolPackage.LoadSymbols(false, out var newSymbolsWithFiles, out _);
+                                         return new PackageLoadInfo(symbolPackage, newSymbolsWithFiles);
+                                     })
+                             .ToArray();
+
+        packageLoadInfo
+           .AsParallel()
+           .ForAll(packageInfo => SymbolPackage.ApplySymbolChildren(packageInfo.NewlyLoadedSymbols));
+    }
+    
+    private static void PreloadShadersAndResources(double durationSecs,
+                                                   Int2 resolution,
+                                                   Playback playback,
+                                                   DeviceContext deviceContext,
+                                                   EvaluationContext context,
+                                                   Slot<Texture2D> textureOutput,
+                                                   SwapChain swapChain,
+                                                   RenderTargetView renderView)
+    {
+        var previousSpeed = playback.PlaybackSpeed;
+        var originalTime = playback.TimeInSecs;
+        var wasWindowVisible = _renderForm?.Visible ?? true;
+        var audio = CompositionSettings.Current.Audio;
+        var previousSoundtrackMute = audio.SoundtrackMute;
+        var previousGlobalMute = CoreSettings.Config.AppMute;
+        var hideDisplayDuringPreload = true;
+        var muteAudioDuringPreload = true;
+        const double subFrameWarmOffsetInSecs = 1.0 / 60.0;
+
+        if (muteAudioDuringPreload)
+        {
+            audio.SoundtrackMute = true;
+            AudioEngine.SetSoundtrackMute(true);
+            AudioEngine.SetGlobalMute(true);
+        }
+
+        if (hideDisplayDuringPreload && _renderForm != null)
+        {
+            _renderForm.Visible = false;
+        }
+
+        playback.PlaybackSpeed = 0;
+        var reportedTextureInitFailure = false;
+
+        try
+        {
+            for (double timeInSecs = 0; timeInSecs < durationSecs; timeInSecs += 2.0)
+            {
+                var barsAtSample = playback.BarsFromSeconds(timeInSecs);
+                Log.Info($"Pre-evaluate at: {timeInSecs:0.00}s / {barsAtSample:0.00} bars");
+
+                var frameWasDrawn = PreloadSampleAtTime(timeInSecs);
+                if (!frameWasDrawn && !reportedTextureInitFailure)
+                {
+                    Log.Error("Failed to initialize texture during preload");
+                    reportedTextureInitFailure = true;
+                }
+
+                var warmupTimeInSecs = timeInSecs + subFrameWarmOffsetInSecs;
+                if (warmupTimeInSecs < durationSecs)
+                {
+                    PreloadSampleAtTime(warmupTimeInSecs);
+                }
+
+                Thread.Sleep(20);
+                if (hideDisplayDuringPreload)
+                {
+                    // Ensure GPU work gets submitted even when preload frames are not presented.
+                    deviceContext.Flush();
+                }
+                else
+                {
+                    swapChain.Present(1, PresentFlags.None);
+                }
+            }
+        }
+        finally
+        {
+            playback.PlaybackSpeed = previousSpeed;
+            playback.TimeInSecs = originalTime;
+
+            if (muteAudioDuringPreload)
+            {
+                AudioEngine.SetGlobalMute(previousGlobalMute);
+                audio.SoundtrackMute = previousSoundtrackMute;
+                AudioEngine.SetSoundtrackMute(previousSoundtrackMute);
+            }
+
+            if (hideDisplayDuringPreload && _renderForm != null)
+            {
+                _renderForm.Visible = wasWindowVisible;
+            }
+        }
+
+        bool PreloadSampleAtTime(double sampleTimeInSecs)
+        {
+            playback.TimeInSecs = sampleTimeInSecs;
+            playback.Update();
+
+            // Register every cached clip so all streams stay loaded during preload sampling.
+            foreach (var handle in _allSoundtrackHandles)
+            {
+                AudioEngine.UseSoundtrackClip(handle, playback.TimeInSecs);
+            }
+
+            AudioEngine.CompleteFrame(playback, Playback.LastFrameDuration);
+
+            DirtyFlag.IncrementGlobalTicks();
+            DirtyFlag.GlobalInvalidationTick++;
+
+            return EvaluateAndDrawOutput(context, resolution, textureOutput, deviceContext, renderView);
+        }
+    }
+}