Library/Demo: Implement DemoSyncedEventKeeper (#964)

data/file_list.yml

@@ -235180,27 +235180,27 @@ Library/Demo/DemoSyncedEventKeeper.o:
     label:
     - _ZN2al21DemoSyncedEventKeeperC1EPNS_13AudioDirectorE
     - _ZN2al21DemoSyncedEventKeeperC2EPNS_13AudioDirectorE
-    status: NotDecompiled
+    status: Matching
   - offset: 0x8724b4
     size: 72
     label: _ZN2al21DemoSyncedEventKeeper21updateOnlyWhenDemoRunEi
-    status: NotDecompiled
+    status: Matching
   - offset: 0x8724fc
     size: 56
     label: _ZN2al21DemoSyncedEventKeeper8finalizeEv
-    status: NotDecompiled
+    status: Matching
   - offset: 0x872534
     size: 140
     label: _ZN2al21DemoSyncedEventKeeper9startDemoEPKc
-    status: NotDecompiled
+    status: Matching
   - offset: 0x8725c0
     size: 104
     label: _ZN2al21DemoSyncedEventKeeper7endDemoEbb
-    status: NotDecompiled
+    status: Matching
   - offset: 0x872628
     size: 84
     label: _ZN25alDemoSyncedEventFunction23tryCreateAndSetSeKeeperEPN2al21DemoSyncedEventKeeperEPNS0_13AudioDirectorEPKc
-    status: NotDecompiled
+    status: Matching
 Library/Demo/DemoSyncedBgmCtrl.o:
   '.text':
   - offset: 0x87267c

lib/al/Library/Audio/AudioDirector.h

@@ -59,6 +59,10 @@ public:
         mIsSafeFinalizingInParallelThread = isSafe;
     }
 
+    SeDirector* getSeDirector() const { return mSeDirector; }
+
+    const AudioSystemInfo* getAudioSystemInfo() const { return mAudioSystemInfo; }
+
 private:
     SeDirector* mSeDirector;
     BgmDirector* mBgmDirector;

lib/al/Library/Audio/AudioEventController.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <basis/seadTypes.h>
+#include <math/seadVector.h>
 
 namespace al {
 class ByamlIter;
@@ -8,7 +9,23 @@ class Resource;
 
 template <typename T>
 class AudioInfoListWithParts;
+class AudioEventController;
+class BgmPlayObj;
+class AudioDirector;
+}  // namespace al
 
+namespace alAudioEventControllerFunction {
+bool tryRegistBgmPlayObj(al::AudioEventController*, al::BgmPlayObj*);
+const char* getBgmPlayNameInCurPosition(al::AudioEventController* audioEventController, bool);
+const char* getBgmPlayNameInTargetPosition(al::AudioEventController* audioEventController,
+                                           const sead::Vector3f&);
+void tryStartAndStopBgmInCurPosition(al::AudioEventController* audioEventController, bool, bool);
+void activateAudioEventCtrl(al::AudioDirector*);
+void deactivateAudioEventCtrl(al::AudioDirector*);
+void tryActivateOrDeactivateAudioEventCtrl(al::AudioDirector*, bool, s32);
+}  // namespace alAudioEventControllerFunction
+
+namespace al {
 struct AudioAddonSoundArchiveInfo {
     AudioAddonSoundArchiveInfo();
 

lib/al/Library/Demo/DemoSyncedBgmCtrl.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+
+#include "Library/Audio/AudioInfo.h"
+#include "Library/Audio/IUseAudioKeeper.h"
+#include "Library/HostIO/HioNode.h"
+
+namespace al {
+class AudioDirector;
+class BgmDataBase;
+template <typename, typename>
+class BgmEventController;
+class BgmDemoProcInfo;
+class BgmDemoSyncedProcInfo;
+
+class DemoSyncedBgmCtrl : public HioNode, public IUseAudioKeeper {
+public:
+    static DemoSyncedBgmCtrl* tryCreate(AudioDirector*);
+    DemoSyncedBgmCtrl(AudioDirector* audioDirector);
+
+    void update(s32);
+    void finalize();
+    void startDemo(const char* demoName);
+    void endDemo(const char* demoName, bool);
+    void notifyDemoSkip();
+
+    AudioKeeper* getAudioKeeper() const override { return mAudioKeeper; }
+
+private:
+    AudioDirector* mAudioDirector;
+    AudioKeeper* mAudioKeeper;
+    BgmEventController<IUseAudioKeeper, BgmDemoProcInfo>* mBgmEventController;
+    AudioInfoListWithParts<BgmDemoSyncedProcInfo>* mDemoSyncedProcInfos;
+    BgmDemoSyncedProcInfo* mCurrentProcInfo;
+};
+
+static_assert(sizeof(DemoSyncedBgmCtrl) == 0x30);
+}  // namespace al

lib/al/Library/Demo/DemoSyncedEventKeeper.cpp

@@ -0,0 +1,73 @@
+#include "Library/Demo/DemoSyncedEventKeeper.h"
+
+#include "Library/Audio/AudioDirector.h"
+#include "Library/Audio/AudioEventController.h"
+#include "Library/Demo/DemoSyncedBgmCtrl.h"
+#include "Library/Demo/DemoSyncedSeCtrl.h"
+#include "Library/Se/SeKeeper.h"
+
+namespace al {
+
+DemoSyncedEventKeeper::DemoSyncedEventKeeper(AudioDirector* audioDirector)
+    : mAudioDirector(audioDirector) {
+    mDemoSyncedBgmCtrl = DemoSyncedBgmCtrl::tryCreate(mAudioDirector);
+    mDemoSyncedSeCtrl = DemoSyncedSeCtrl::tryCreate(mAudioDirector);
+}
+
+void DemoSyncedEventKeeper::updateOnlyWhenDemoRun(s32 param) {
+    if (mDemoSyncedBgmCtrl)
+        mDemoSyncedBgmCtrl->update(param);
+    if (mDemoSyncedSeCtrl)
+        mDemoSyncedSeCtrl->update(param);
+}
+
+void DemoSyncedEventKeeper::finalize() {
+    if (mDemoSyncedBgmCtrl)
+        mDemoSyncedBgmCtrl->finalize();
+    if (mDemoSyncedSeCtrl)
+        mDemoSyncedSeCtrl->finalize();
+    mDemoName = nullptr;
+}
+
+void DemoSyncedEventKeeper::startDemo(const char* demoName) {
+    endDemo(false, false);
+
+    alAudioEventControllerFunction::deactivateAudioEventCtrl(mAudioDirector);
+
+    mDemoName = demoName;
+    if (mDemoSyncedBgmCtrl)
+        mDemoSyncedBgmCtrl->startDemo(demoName);
+    if (mDemoSyncedSeCtrl)
+        mDemoSyncedSeCtrl->startDemo(mDemoName);
+}
+
+// TODO: parameter names
+void DemoSyncedEventKeeper::endDemo(bool param_1, bool param_2) {
+    if (!mDemoName)
+        return;
+
+    if (mDemoSyncedBgmCtrl)
+        mDemoSyncedBgmCtrl->endDemo(mDemoName, param_2);
+    if (mDemoSyncedSeCtrl)
+        mDemoSyncedSeCtrl->endDemo(mDemoName, param_2);
+
+    if (!param_1)
+        alAudioEventControllerFunction::activateAudioEventCtrl(mAudioDirector);
+
+    mDemoName = nullptr;
+}
+}  // namespace al
+
+void alDemoSyncedEventFunction::tryCreateAndSetSeKeeper(al::DemoSyncedEventKeeper* keeper,
+                                                        al::AudioDirector* audioDirector,
+                                                        const char* seName) {
+    if (!seName)
+        return;
+
+    al::SeKeeper* seKeeper =
+        al::SeKeeper::create(audioDirector->getAudioSystemInfo(), audioDirector->getSeDirector(),
+                             seName, nullptr, nullptr, nullptr, nullptr);
+
+    if (al::DemoSyncedSeCtrl* seCtrl = keeper->getDemoSyncedSeCtrl())
+        seCtrl->setSeKeeper(seKeeper);
+}

lib/al/Library/Demo/DemoSyncedEventKeeper.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+
+namespace al {
+class AudioDirector;
+class DemoSyncedBgmCtrl;
+class DemoSyncedSeCtrl;
+
+class DemoSyncedEventKeeper {
+public:
+    DemoSyncedEventKeeper(AudioDirector*);
+
+    void updateOnlyWhenDemoRun(s32);
+    void finalize();
+    void startDemo(const char* demoName);
+    void endDemo(bool, bool);
+
+    DemoSyncedSeCtrl* getDemoSyncedSeCtrl() const { return mDemoSyncedSeCtrl; }
+
+private:
+    DemoSyncedBgmCtrl* mDemoSyncedBgmCtrl = nullptr;
+    DemoSyncedSeCtrl* mDemoSyncedSeCtrl = nullptr;
+    AudioDirector* mAudioDirector = nullptr;
+    const char* mDemoName = nullptr;
+};
+
+static_assert(sizeof(DemoSyncedEventKeeper) == 0x20);
+}  // namespace al
+
+namespace alDemoSyncedEventFunction {
+void tryCreateAndSetSeKeeper(al::DemoSyncedEventKeeper* keeper, al::AudioDirector* audioDirector,
+                             const char* seName);
+}

lib/al/Library/Demo/DemoSyncedSeCtrl.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+
+#include "Library/Audio/AudioInfo.h"
+
+namespace al {
+class AudioDirector;
+class SeKeeper;
+class BgmDataBase;
+class SeDemoEventController;
+class SeDemoProcInfo;
+class SeDemoSyncedProcInfo;
+
+class DemoSyncedSeCtrl {
+public:
+    static DemoSyncedSeCtrl* tryCreate(AudioDirector*);
+    DemoSyncedSeCtrl(AudioDirector* audioDirector);
+
+    void update(s32);
+    void finalize();
+    void startDemo(const char* demoName);
+    void endDemo(const char* demoName, bool);
+    void notifyDemoSkip();
+
+    void setSeKeeper(SeKeeper*);
+    SeKeeper* getSeKeeper() const;
+
+    const char* getCurPlayingSeName() const;
+    s32 getCurPlayingSeStartFrame() const;
+
+private:
+    AudioDirector* mAudioDirector;
+    SeDemoEventController* mEventController;
+    AudioInfoListWithParts<SeDemoSyncedProcInfo>* mDemoSyncedProcInfos;
+    SeDemoSyncedProcInfo* mCurrentProcInfo;
+};
+
+static_assert(sizeof(DemoSyncedSeCtrl) == 0x20);
+}  // namespace al

lib/al/Library/Se/SeKeeper.h

@@ -16,8 +16,8 @@ class CameraDirector;
 
 class SeKeeper {
 public:
-    static void create(const AudioSystemInfo*, SeDirector*, const char*, const sead::Vector3f*,
-                       const sead::Matrix34f*, const ModelKeeper*, CameraDirector*);
+    static SeKeeper* create(const AudioSystemInfo*, SeDirector*, const char*, const sead::Vector3f*,
+                            const sead::Matrix34f*, const ModelKeeper*, CameraDirector*);
     SeKeeper(const AudioSystemInfo*, SeDirector*, const char*, const sead::Vector3f*,
              const sead::Matrix34f*, const ModelKeeper*, CameraDirector*);