Added audio device change fix and moved/deleted stuff

Author: stringfromjava

assets/shared/music/Stargazer.mp3

@@ -1,22 +1,20 @@
 package;
 
-import flixel.FlxG;
 import flixel.FlxState;
 import flixel.math.FlxMath;
 import flixel.system.FlxAssets;
-import flixel.tweens.FlxTween;
 import lime.app.Application;
 import openfl.Lib;
 import openfl.display.StageQuality;
 import openfl.display.StageScaleMode;
 import starcore.backend.api.DiscordClient;
 import starcore.backend.data.ClientPrefs;
+import starcore.backend.util.AudioUtil;
 import starcore.backend.util.CacheUtil;
 import starcore.backend.util.FlixelUtil;
 import starcore.backend.util.LoggerUtil;
 import starcore.backend.util.PathUtil;
 import starcore.menus.MainMenuState;
-import starcore.shaders.*;
 #if web
 import js.Browser;
 #end
@@ -43,6 +41,9 @@ class InitState extends FlxState
     // cause null errors and crash the game!
     ClientPrefs.loadAll();
 
+    // Configure and setup the Audio utility class.
+    AudioUtil.initAudioFix();
+
     // Assign and configure Flixel settings.
     configureFlixelSettings();
 
@@ -74,7 +75,7 @@ class InitState extends FlxState
     // NOTE: Maybe use a custom cursor (that isn't Flixel's)?
     FlxG.mouse.useSystemCursor = true;
 
-    // Set auto pause to false.
+    // Set auto pause to false (we NEVER want this enabled).
     FlxG.autoPause = false;
 
     // Set the stage and scaling modes.

assets/shared/music/Stargazer.ogg

@@ -0,0 +1,15 @@
+// ===============================================================================================
+// This is a file which automatically imports common classes used throughout the project.
+// You can add your own imports here if you want them to be globally available, that way you
+// don't have to import them in every file!
+// ===============================================================================================
+
+package;
+
+//
+// FLIXEL IMPORTS
+// =============================
+
+import flixel.FlxG;
+import flixel.FlxSprite;
+import flixel.tweens.FlxTween;

assets/shared/sounds/intro/stargazer-intro-start.mp3

@@ -0,0 +1,276 @@
+package starcore.backend.util;
+
+import flixel.sound.FlxSound;
+import flixel.util.FlxSignal;
+import lime.media.AudioBuffer;
+import lime.media.AudioManager;
+import lime.utils.UInt8Array;
+import openfl.media.Sound;
+
+/**
+ * Type definition for storing sound regeneration data.
+ */
+#if (windows && cpp)
+typedef RegenSoundData =
+{
+  var sound:FlxSound;
+  var isPlaying:Bool;
+  var time:Float;
+};
+
+/**
+ * Utility class for handling the game's audio, such as restarting audio on device change.
+ * 
+ * THIS WAS NOT MADE BY ME! Credits go to cyn0x8 for this class.
+ * @see https://github.com/cyn0x8
+ * @see https://github.com/FunkinCrew/Funkin/pull/5569
+ */
+@:buildXml('
+<target id="haxe">
+  <lib name="ole32.lib" if="windows"/>
+</target>
+')
+@:cppFileCode('
+#include <string>
+#include "mmdeviceapi.h"
+
+bool _audioDeviceChanged = false;
+class AudioFixClient : public IMMNotificationClient {
+  public:
+
+  AudioFixClient() : _refCount(1), _pDeviceEnum(nullptr) {
+    HRESULT result = CoCreateInstance(__uuidof(MMDeviceEnumerator), nullptr, CLSCTX_INPROC_SERVER, __uuidof(IMMDeviceEnumerator), (void**)&_pDeviceEnum);
+    if (result == S_OK) _pDeviceEnum->RegisterEndpointNotificationCallback(this);
+    updateCurrentDeviceID();
+  }
+
+  ~AudioFixClient() {
+    if (_pDeviceEnum != nullptr) {
+      _pDeviceEnum->UnregisterEndpointNotificationCallback(this);
+      _pDeviceEnum->Release();
+      _pDeviceEnum = nullptr;
+    }
+  }
+
+  HRESULT STDMETHODCALLTYPE OnDefaultDeviceChanged(EDataFlow flow, ERole role, LPCWSTR pwstrDefaultDeviceId) {
+    if (flow == eRender && role == eConsole && pwstrDefaultDeviceId != nullptr) {
+      if (_currentDeviceID.compare(pwstrDefaultDeviceId) != 0) {
+        _audioDeviceChanged = true;
+      }
+    }
+
+    return S_OK;
+  }
+
+  ULONG STDMETHODCALLTYPE AddRef() {
+    return InterlockedIncrement(&_refCount);
+  }
+
+  ULONG STDMETHODCALLTYPE Release() {
+    ULONG ulRef = InterlockedDecrement(&_refCount);
+    if (0 == ulRef) delete this;
+    return ulRef;
+  }
+
+  HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, VOID** ppvInterface) {
+    if (IID_IUnknown == riid) {
+      AddRef();
+      *ppvInterface = (IUnknown*)this;
+    } else if (__uuidof(IMMNotificationClient) == riid) {
+      AddRef();
+      *ppvInterface = (IMMNotificationClient*)this;
+    } else {
+      *ppvInterface = NULL;
+      return E_NOINTERFACE;
+    }
+
+    return S_OK;
+  }
+
+  HRESULT STDMETHODCALLTYPE OnDeviceAdded(LPCWSTR pwstrDeviceId) {
+    return S_OK;
+  }
+
+  HRESULT STDMETHODCALLTYPE OnDeviceRemoved(LPCWSTR pwstrDeviceId) {
+    return S_OK;
+  }
+
+  HRESULT STDMETHODCALLTYPE OnDeviceStateChanged(LPCWSTR pwstrDeviceId, DWORD dwNewState) {
+    return S_OK;
+  }
+
+  HRESULT STDMETHODCALLTYPE OnPropertyValueChanged(LPCWSTR pwstrDeviceId, const PROPERTYKEY key) {
+    return S_OK;
+  }
+
+  void updateCurrentDeviceID() {
+    if (_pDeviceEnum == nullptr) return;
+    IMMDevice* _pDevice = nullptr;
+    LPWSTR _deviceId = nullptr;
+    HRESULT result = _pDeviceEnum->GetDefaultAudioEndpoint(eRender, eConsole, &_pDevice);
+    if (SUCCEEDED(result) && _pDevice != nullptr) {
+      result = _pDevice->GetId(&_deviceId);
+      if (SUCCEEDED(result) && _deviceId != nullptr) {
+        _currentDeviceID = _deviceId;
+        CoTaskMemFree(_deviceId);
+      }
+
+      _pDevice->Release();
+    }
+  }
+
+  private:
+
+  std::wstring _currentDeviceID;
+  IMMDeviceEnumerator* _pDeviceEnum;
+
+  LONG _refCount;
+};
+
+AudioFixClient* curAudioFix;
+')
+#end
+@:nullSafety
+final class AudioUtil
+{
+  #if (windows && cpp)
+  /**
+   * Signal dispatched when the current audio device is changed, after an attempted restart.
+   */
+  public static final audioDeviceChangeSignal:FlxSignal = new FlxSignal();
+
+  /**
+   * Whether the current audio device has changed.
+   */
+  static var audioDeviceChanged(get, set):Bool;
+
+  function new() {}
+
+  /**
+   * Gets whether the current audio device has changed.
+   * 
+   * @return If the audio device has changed.
+   */
+  public static function get_audioDeviceChanged():Bool
+  {
+    return cast untyped __cpp__('_audioDeviceChanged');
+  }
+
+  static function set_audioDeviceChanged(v:Bool):Bool
+  {
+    untyped __cpp__('_audioDeviceChanged = (bool)v;');
+    return v;
+  }
+
+  static var initializedAudioFix:Bool = false;
+
+  /**
+   * Initializes the audio fix client to handle audio device changes.
+   * This should be called once at the start of the application.
+   */
+  public static function initAudioFix():Void
+  {
+    if (initializedAudioFix)
+    {
+      return;
+    }
+
+    LoggerUtil.log('Initializing audio device change detection');
+
+    untyped __cpp__('if (curAudioFix == nullptr) curAudioFix = new AudioFixClient();');
+
+    FlxG.signals.preUpdate.add(function():Void
+    {
+      if (audioDeviceChanged)
+      {
+        LoggerUtil.log('AUDIO DEVICE CHANGE DETECTED', INFO, false);
+        LoggerUtil.log('Restarting audio system');
+        restartAudio();
+      }
+    });
+
+    initializedAudioFix = true;
+  }
+
+  /**
+   * Restarts the audio system and regenerates all sounds.
+   */
+  public static function restartAudio():Void
+  {
+    final curSounds:Array<FlxSound> = new Array<FlxSound>();
+
+    @:privateAccess
+    for (sound in FlxG.sound.list)
+    {
+      if (sound != null && sound.exists)
+      {
+        DataUtil.pushUniqueElement(curSounds, sound);
+      }
+    }
+    for (sound in FlxG.sound.list)
+    {
+      if (sound != null && sound.exists)
+      {
+        DataUtil.pushUniqueElement(curSounds, sound);
+      }
+    }
+    if (FlxG.sound.music != null && FlxG.sound.music.exists)
+    {
+      DataUtil.pushUniqueElement(curSounds, FlxG.sound.music);
+    }
+
+    final regenData:Array<RegenSoundData> = new Array<RegenSoundData>();
+    for (sound in curSounds)
+    {
+      regenData.push({sound: sound, isPlaying: sound.playing, time: sound.time});
+      sound.pause();
+    }
+
+    AudioManager.shutdown();
+    AudioManager.init();
+
+    untyped __cpp__('if (curAudioFix != nullptr) curAudioFix->updateCurrentDeviceID();');
+
+    for (entry in regenData)
+    {
+      final sound:FlxSound = entry.sound;
+      @:privateAccess regenSound(sound._sound);
+
+      if (entry.isPlaying)
+      {
+        sound.play(true, entry.time);
+      }
+
+      sound.time = entry.time;
+    }
+
+    // TODO: Do garbage collection here.
+
+    audioDeviceChanged = false;
+    audioDeviceChangeSignal.dispatch();
+  }
+
+  /**
+   * Refreshes the sound buffer of a given `Sound`.
+   * 
+   * @param sound The sound to refresh.
+   */
+  public static function regenSound(sound:Null<Sound>):Void
+  {
+    if (sound != null)
+    {
+      @:privateAccess final curBuffer:Null<AudioBuffer> = sound.__buffer;
+      if (curBuffer != null)
+      {
+        final newBuffer:AudioBuffer = new AudioBuffer();
+        newBuffer.bitsPerSample = curBuffer.bitsPerSample;
+        newBuffer.channels = curBuffer.channels;
+        newBuffer.data = UInt8Array.fromBytes(curBuffer.data.toBytes());
+        newBuffer.sampleRate = curBuffer.sampleRate;
+        newBuffer.src = curBuffer.src;
+        @:privateAccess sound.__buffer = newBuffer;
+      }
+    }
+  }
+  #end
+}

assets/shared/sounds/intro/stargazer-intro-start.ogg

@@ -127,4 +127,21 @@ final class DataUtil
   {
     return (Reflect.hasField(object, field)) ? Reflect.field(object, field) : defaultValue;
   }
+
+  /**
+   * Push an element to an array if it is not already present.
+   * 
+   * @param input   The array to push the new value to.
+   * @param element The element to push.
+   * @return Bool If the value was added or not.
+   */
+  public static function pushUniqueElement<T>(input:Array<T>, element:T):Bool
+  {
+    if (input.contains(element))
+    {
+      return false;
+    }
+    input.push(element);
+    return true;
+  }
 }