al/Library/LiveActor: Decompile LiveActorKit

data/odyssey_functions.csv

@@ -58109,22 +58109,22 @@ Address,Quality,Size,Name
 0x000000710090f5a8,O,000084,_ZN2al14SubActorKeeper16registerSubActorEPNS_9LiveActorEj
 0x000000710090f5fc,O,000012,_ZN2al14SubActorKeeperC2EPNS_9LiveActorE
 0x000000710090f608,U,002172,_ZN2al14SubActorKeeper4initERKNS_13ActorInitInfoEPKci
-0x000000710090fe84,U,000168,_ZN2al12LiveActorKitC2Eii
-0x000000710090ff2c,U,000344,_ZN2al12LiveActorKitD2Ev
-0x0000007100910084,U,000036,_ZN2al12LiveActorKitD0Ev
-0x00000071009100a8,U,000540,_ZN2al12LiveActorKit4initEi
-0x00000071009102c4,U,000124,_ZN2al12LiveActorKit12initGraphicsERKNS_15GraphicsInitArgE
-0x0000007100910340,U,000052,_ZN2al12LiveActorKit21initHitSensorDirectorEv
-0x0000007100910374,U,000052,_ZN2al12LiveActorKit17initGravityHolderEv
-0x00000071009103a8,U,000004,_ZN2al12LiveActorKit18initShadowDirectorEv
-0x00000071009103ac,U,000048,_ZN2al12LiveActorKit16initEffectSystemEv
-0x00000071009103dc,U,000064,_ZN2al12LiveActorKit22initSwitchAreaDirectorEii
-0x000000710091041c,U,000052,_ZN2al12LiveActorKit18initNatureDirectorEv
-0x0000007100910450,U,000300,_ZN2al12LiveActorKit7endInitEv
-0x000000710091057c,U,000132,_ZN2al12LiveActorKit6updateEPKc
-0x0000007100910600,U,000016,_ZN2al12LiveActorKit20clearGraphicsRequestEv
-0x0000007100910610,U,000064,_ZN2al12LiveActorKit14updateGraphicsEv
-0x0000007100910650,U,000028,_ZN2al12LiveActorKit15preDrawGraphicsEv
+0x000000710090fe84,O,000168,_ZN2al12LiveActorKitC2Eii
+0x000000710090ff2c,O,000344,_ZN2al12LiveActorKitD1Ev
+0x0000007100910084,O,000036,_ZN2al12LiveActorKitD0Ev
+0x00000071009100a8,O,000540,_ZN2al12LiveActorKit4initEi
+0x00000071009102c4,O,000124,_ZN2al12LiveActorKit12initGraphicsERKNS_15GraphicsInitArgE
+0x0000007100910340,O,000052,_ZN2al12LiveActorKit21initHitSensorDirectorEv
+0x0000007100910374,O,000052,_ZN2al12LiveActorKit17initGravityHolderEv
+0x00000071009103a8,O,000004,_ZN2al12LiveActorKit18initShadowDirectorEv
+0x00000071009103ac,O,000048,_ZN2al12LiveActorKit16initEffectSystemEv
+0x00000071009103dc,O,000064,_ZN2al12LiveActorKit22initSwitchAreaDirectorEii
+0x000000710091041c,O,000052,_ZN2al12LiveActorKit18initNatureDirectorEv
+0x0000007100910450,O,000300,_ZN2al12LiveActorKit7endInitEv
+0x000000710091057c,O,000132,_ZN2al12LiveActorKit6updateEPKc
+0x0000007100910600,O,000016,_ZN2al12LiveActorKit20clearGraphicsRequestEv
+0x0000007100910610,O,000064,_ZN2al12LiveActorKit14updateGraphicsEv
+0x0000007100910650,O,000028,_ZN2al12LiveActorKit15preDrawGraphicsEv
 0x000000710091066c,O,000080,_ZN2al14LiveActorGroupC1EPKci
 0x00000071009106bc,O,000032,_ZN2al14LiveActorGroup13registerActorEPNS_9LiveActorE
 0x00000071009106dc,O,000084,_ZN2al14LiveActorGroup11removeActorEPKNS_9LiveActorE

lib/al/include/Library/Area/SwitchAreaDirector.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+
+#include "Library/Area/IUseAreaObj.h"
+
+namespace al {
+class PlayerHolder;
+class CameraDirector;
+class SwitchOnAreaGroup;
+class SwitchKeepOnAreaGroup;
+
+class SwitchAreaDirector : public IUseAreaObj {
+public:
+    static SwitchAreaDirector* tryCreate(AreaObjDirector*, const PlayerHolder*,
+                                         const CameraDirector*, s32, s32);
+
+    SwitchAreaDirector(AreaObjDirector*, const PlayerHolder*, const CameraDirector*, s32, s32);
+
+    AreaObjDirector* getAreaObjDirector() const override;
+
+    void update();
+    void endInit();
+    void registerSwitchOnAreaGroup(SwitchOnAreaGroup*);
+    void registerSwitchKeepOnAreaGroup(SwitchKeepOnAreaGroup*);
+
+private:
+    void* filler[9];
+};
+static_assert(sizeof(SwitchAreaDirector) == 0x50);
+
+}  // namespace al

lib/al/include/Library/Camera/CameraDirector.h

@@ -26,6 +26,7 @@ class CameraInSwitchOnAreaDirector;
 class CameraTicket;
 class ICameraInput;
 class PlacementId;
+class PlayerHolder;
 class CameraPoser;
 class AreaObjDirector;
 class IUseAudioKeeper;
@@ -34,6 +35,7 @@ class NameToCameraParamTransferFunc;
 
 class CameraDirector : public HioNode, IUseExecutor {
 public:
+    CameraDirector(s32 maxCameras);
     virtual ~CameraDirector();
 
     void init(CameraPoserSceneInfo*, const CameraPoserFactory*);
@@ -47,7 +49,7 @@ public:
 
     void execute() override;
     void update();
-    void endInit();
+    void endInit(const PlayerHolder*);
 
     CameraPoseUpdater* getPoseUpdater(s32 index);
     CameraTicket* createCameraFromFactory(const char*, const PlacementId*, const char*, s32,
@@ -76,6 +78,8 @@ public:
     void startSnapShotMode(bool);
     void endSnapShotMode();
 
+    SceneCameraInfo* getSceneCameraInfo() const { return mSceneCameraInfo; }
+
 private:
     s32 mCountCameraPoseUpdaters;
     SceneCameraInfo* mSceneCameraInfo;

lib/al/include/Library/Controller/PadRumbleDirector.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <math/seadVector.h>
+
+namespace al {
+class PlayerHolder;
+class CameraDirector;
+class WaveVibrationHolder;
+class PadRumbleParam;
+
+class PadRumbleDirector {
+public:
+    PadRumbleDirector(const PlayerHolder*, const CameraDirector*);
+
+    void setWaveVibrationHolder(WaveVibrationHolder*);
+    void update();
+    void updateInfoListAll();
+    void startRumble(const char*, const sead::Vector3f&, const PadRumbleParam&, s32);
+    void* findDeadInfoOneTime();  // unknown return type
+    void startRumbleNo3D(const char*, const PadRumbleParam&, s32);
+    void stopPadRumbleOneTime(const char*, s32);
+    void startRumbleLoop(const char*, const sead::Vector3f*, const PadRumbleParam&, s32);
+    void* findDeadInfo();  // unknown return type
+    void startRumbleLoopNo3D(const char*, const sead::Vector3f*, const PadRumbleParam&, s32);
+    void stopRumbleLoop(const char*, const sead::Vector3f*, s32);
+    void* findInfo(const char*, const sead::Vector3f*, s32);  // unknown return type
+    bool checkIsAliveRumbleLoop(const char*, const sead::Vector3f*, s32);
+    void stopAllRumble();
+    void clearAllInfoList();
+    void pause();
+    void endPause();
+    void changeRumbleLoopVolume(const char*, const sead::Vector3f*, f32, f32, s32);
+    void updateInfoListLoop();
+    void changeRumbleLoopPitch(const char*, const sead::Vector3f*, f32, f32, s32);
+    void startRumbleWithVolume(const char*, f32, f32, s32);
+    void startRumbleDirectValue(f32, f32, f32, f32, f32, f32, s32);
+    void stopRumbleDirectValue(s32);
+    void updateInfoListOneTime();
+    void testStartPadRumbleWithVolumeNoActor(const char*, f32, f32);
+
+private:
+    void* filler[14];
+};
+
+}  // namespace al

lib/al/include/Library/Draw/GraphicsSystemInfo.h

@@ -0,0 +1,37 @@
+#pragma once
+
+namespace agl {
+class DrawContext;
+}
+
+namespace al {
+class GraphicsInitArg;
+class AreaObjDirector;
+class ExecuteDirector;
+class EffectSystem;
+class PlayerHolder;
+class SceneCameraInfo;
+class ShaderHolder;
+
+class GraphicsSystemInfo {
+public:
+    GraphicsSystemInfo();
+    ~GraphicsSystemInfo();
+
+    void init(const GraphicsInitArg&, AreaObjDirector*, ExecuteDirector*, EffectSystem*,
+              PlayerHolder*, SceneCameraInfo*, ShaderHolder*);
+
+    agl::DrawContext* getDrawContext() const;
+    void endInit();
+    void initAfterPlacement();
+    void clearGraphicsRequest();
+    void updateGraphics();
+    void preDrawGraphics(SceneCameraInfo*);
+
+    // incomplete
+private:
+    void* filler[312];
+};
+static_assert(sizeof(GraphicsSystemInfo) == 0x9c0);
+
+}  // namespace al

lib/al/include/Library/Effect/EffectSystem.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <heap/seadHeap.h>
+
+namespace agl {
+class DrawContext;
+}
+
+namespace al {
+class CameraDirector;
+class GraphicsSystemInfo;
+class ExecuteDirector;
+
+class EffectSystem {
+public:
+    static EffectSystem* initializeSystem(agl::DrawContext*, sead::Heap*);
+
+    EffectSystem();
+
+    void initScene();
+    void startScene(ExecuteDirector*);
+    void endScene();
+    void endInit();
+    void setCameraDirector(CameraDirector*);
+    void setGraphicsSystemInfo(const GraphicsSystemInfo*);
+
+    // incomplete
+private:
+    // missing
+};
+
+}  // namespace al

lib/al/include/Library/Execute/ExecuteSystemInitInfo.h

@@ -7,6 +7,8 @@ class DrawContext;
 
 namespace al {
 struct ExecuteSystemInitInfo {
+    ExecuteSystemInitInfo();
+
     agl::DrawContext* mDrawCtx;
 };
 }  // namespace al

lib/al/include/Library/Execute/ExecuteTableHolderUpdate.h

@@ -3,6 +3,7 @@
 #include <container/seadPtrArray.h>
 
 namespace al {
+class ExecuteDirector;
 struct ExecuteOrder;
 struct ExecuteSystemInitInfo;
 class ExecutorListActorExecuteBase;
@@ -45,6 +46,8 @@ private:
     sead::PtrArray<ExecutorListIUseExecutorUpdate> mExecutorsUser;
     sead::PtrArray<ExecutorListFunctor> mExecutorsFunctor;
 };
+
+void registerExecutorUser(IUseExecutor*, ExecuteDirector*, const char*);
 }  // namespace al
 
 namespace alActorSystemFunction {

lib/al/include/Library/Execute/IUseExecutor.h

@@ -5,7 +5,7 @@ namespace al {
 class IUseExecutor {
 public:
     virtual void execute() = 0;
-    virtual void draw() const = 0;
+    virtual void draw() const;
 };
 
 }  // namespace al

lib/al/include/Library/LiveActor/LiveActorGroup.h

@@ -3,6 +3,7 @@
 #include <basis/seadTypes.h>
 
 #include "Library/HostIO/HioNode.h"
+#include "Library/LiveActor/LiveActor.h"
 
 namespace al {
 class LiveActor;
@@ -25,6 +26,9 @@ public:
     void makeActorAliveAll();
     void makeActorDeadAll();
 
+    s32 getActorCount() const { return mActorCount; }
+    LiveActor* getActor(s32 idx) const { return mActors[idx]; }
+
 private:
     const char* mGroupName;
     s32 mMaxActorCount;

lib/al/include/Library/LiveActor/LiveActorKit.h

@@ -0,0 +1,101 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+
+#include "Library/HostIO/HioNode.h"
+
+namespace agl {
+class DrawContext;
+}
+
+namespace al {
+class GraphicsInitArg;
+class ActorResourceHolder;
+class AreaObjDirector;
+class ExecuteDirector;
+class GravityHolder;
+class EffectSystem;
+class GraphicsSystemInfo;
+class ModelDrawBufferUpdater;
+class ExecuteAsyncExecutorUpdate;
+class ModelDisplayListController;
+class LiveActorGroup;
+class CameraDirector;
+class ClippingDirector;
+class CollisionDirector;
+class ItemDirectorBase;
+class PlayerHolder;
+class HitSensorDirector;
+class ScreenPointDirector;
+class ShadowDirector;
+class StageSwitchDirector;
+class SwitchAreaDirector;
+class LiveActorGroup;
+class DemoDirector;
+class GamePadSystem;
+class PadRumbleDirector;
+class NatureDirector;
+class ModelGroup;
+
+class LiveActorKit : public HioNode {
+public:
+    class DrawBufferDirector {
+    public:
+        DrawBufferDirector() = default;
+
+    private:
+        s32 mMaxDrawBuffer = 3;
+        s32 mCurrentDrawBuffer = 0;
+    };
+
+    LiveActorKit(s32 maxActors, s32 maxPlayers);
+    virtual ~LiveActorKit();
+
+    void init(s32 maxCameras);
+    void initGraphics(const GraphicsInitArg& graphics);
+    void initHitSensorDirector();
+    void initGravityHolder();
+    void initShadowDirector();
+    void initEffectSystem();
+    void initSwitchAreaDirector(s32, s32);
+    void initNatureDirector();
+    void endInit();
+    void update(const char*);
+    void clearGraphicsRequest();
+    void updateGraphics();
+    void preDrawGraphics();
+
+private:
+    s32 mMaxActors;
+    ActorResourceHolder* mActorResourceHolder = nullptr;
+    AreaObjDirector* mAreaObjDirector = nullptr;
+    ExecuteDirector* mExecuteDirector = nullptr;
+    GravityHolder* mGravityHolder = nullptr;
+    EffectSystem* mEffectSystem = nullptr;
+    GraphicsSystemInfo* mGraphicsSystemInfo = nullptr;
+    DrawBufferDirector* mDrawBufferDirector = nullptr;
+    ModelDrawBufferUpdater* mModelDrawBufferUpdater = nullptr;
+    ExecuteAsyncExecutorUpdate* mExecutorCore1 = nullptr;
+    ExecuteAsyncExecutorUpdate* mExecutorCore2 = nullptr;
+    ModelDisplayListController* mModelDisplayListController = nullptr;
+    agl::DrawContext* mSceneDrawContext = nullptr;
+    LiveActorGroup* mDynamicDrawActorGroup = nullptr;
+    CameraDirector* mCameraDirector = nullptr;
+    ClippingDirector* mClippingDirector = nullptr;
+    CollisionDirector* mCollisionDirector = nullptr;
+    ItemDirectorBase* mItemDirector = nullptr;
+    PlayerHolder* mPlayerHolder = nullptr;
+    HitSensorDirector* mHitSensorDirector = nullptr;
+    ScreenPointDirector* mScreenPointDirector = nullptr;
+    ShadowDirector* mShadowDirector = nullptr;
+    StageSwitchDirector* mStageSwitchDirector = nullptr;
+    SwitchAreaDirector* mSwitchAreaDirector = nullptr;
+    LiveActorGroup* mLiveActorGroupAllActors = nullptr;
+    DemoDirector* mDemoDirector = nullptr;
+    GamePadSystem* mGamePadSystem = nullptr;
+    PadRumbleDirector* mPadRumbleDirector = nullptr;
+    NatureDirector* mNatureDirector = nullptr;
+    ModelGroup* mModelGroup = nullptr;
+};
+
+}  // namespace al

lib/al/include/Library/Model/ModelDisplayListController.h

@@ -0,0 +1,23 @@
+#pragma once
+
+namespace al {
+class ModelGroup;
+class GraphicsSystemInfo;
+
+class ModelDisplayListController {
+public:
+    ModelDisplayListController(ModelGroup*);
+    void update();
+
+    void setGraphicsSystemInfo(GraphicsSystemInfo* graphicsSystemInfo) {
+        mGraphicsSystemInfo = graphicsSystemInfo;
+    }
+
+private:
+    ModelGroup* mModelGroup;
+    GraphicsSystemInfo* mGraphicsSystemInfo;
+    void* filler[4];
+};
+static_assert(sizeof(ModelDisplayListController) == 0x30);
+
+}  // namespace al

lib/al/include/Library/Model/ModelDrawBufferUpdater.h

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace al {
+class ExecuteDirector;
+
+class ModelDrawBufferUpdater {
+public:
+    ModelDrawBufferUpdater(const ExecuteDirector*);
+    ~ModelDrawBufferUpdater();
+
+    // incomplete
+private:
+    void* filler[3];
+};
+static_assert(sizeof(ModelDrawBufferUpdater) == 0x18);
+
+}  // namespace al

lib/al/include/Library/Model/ModelGroup.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+
+#include "Library/HostIO/HioNode.h"
+
+namespace al {
+class ModelKeeper;
+
+class ModelGroup : public HioNode {
+public:
+    ModelGroup(s32 maxModels);
+    virtual ~ModelGroup();
+
+    void registerModel(ModelKeeper*);
+
+private:
+    void* filler[2];
+};
+static_assert(sizeof(ModelGroup) == 0x18);
+
+}  // namespace al

lib/al/include/Library/Nature/NatureDirector.h

@@ -0,0 +1,20 @@
+#pragma once
+
+namespace al {
+class AreaObjGroup;
+class FluidSurfaceHolder;
+
+class NatureDirector {
+public:
+    NatureDirector();
+    void init();
+
+    void setWaterAreaGroup(AreaObjGroup* waterAreaGroup) { mWaterAreaGroup = waterAreaGroup; }
+
+private:
+    AreaObjGroup* mWaterAreaGroup;
+    FluidSurfaceHolder* mFluidSurfaceHolder;
+};
+static_assert(sizeof(NatureDirector) == 0x10);
+
+}  // namespace al

lib/al/include/Library/Obj/DynamicDrawActor.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Library/LiveActor/LiveActor.h"
+
+namespace al {
+
+class IUseFinalize {
+public:
+    virtual void finalize() = 0;
+};
+
+class DynamicDrawActor : public LiveActor, public IUseFinalize {
+public:
+    // incomplete
+    void finalize() override;
+
+private:
+    // missing
+};
+
+}  // namespace al

lib/al/include/Library/Resource/ActorResourceHolder.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <prim/seadSafeString.h>
+
+#include "Library/HostIO/HioNode.h"
+
+namespace al {
+class Resource;
+class ActorResource;
+
+class ActorResourceHolder : public HioNode {
+public:
+    ActorResourceHolder(s32);
+    ~ActorResourceHolder();
+
+    ActorResource* tryFindActorResource(const sead::SafeString&);
+    ActorResource* findActorResourceImpl(const sead::SafeString&);
+    ActorResource* createActorResource(const sead::SafeString&, Resource*, Resource*);
+    void removeAll();
+    void eraseResourceUser(Resource*);
+    void freeErasedActorResource();
+
+private:
+    void* filler[9];
+};
+static_assert(sizeof(ActorResourceHolder) == 0x48);
+
+}  // namespace al

lib/al/include/Library/Scene/ItemDirectorBase.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <math/seadQuat.h>
+#include <math/seadVector.h>
+
+#include "Library/LiveActor/LiveActorKit.h"
+
+namespace al {
+class ActorInitInfo;
+class HitSensor;
+class LiveActor;
+
+class ItemDirectorBase {
+public:
+    virtual void appearItem(const char*, const sead::Vector3f&, const sead::Quatf&,
+                            const HitSensor*) = 0;
+    virtual void acquireItem(const LiveActor*, HitSensor*, const char*) = 0;
+    virtual void declareItem(const char*, const ActorInitInfo&) = 0;
+    virtual void endInit() = 0;
+};
+
+}  // namespace al

lib/al/include/Library/Screen/ScreenPointDirector.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <container/seadObjArray.h>
+#include <math/seadVector.h>
+
+namespace al {
+class ScreenPointer;
+class ScreenPointCheckGroup;
+class ScreenPointTarget;
+class ScreenPointTargetHitInfo;
+
+class ScreenPointDirector {
+public:
+    ScreenPointDirector();
+    void registerTarget(ScreenPointTarget*);
+    void setCheckGroup(ScreenPointTarget*);
+    bool hitCheckSegment(ScreenPointer*, sead::ObjArray<ScreenPointTargetHitInfo>*, s32,
+                         const sead::Vector3f&, const sead::Vector3f&);
+    bool hitCheckScreenCircle(ScreenPointer*, sead::ObjArray<ScreenPointTargetHitInfo>*, s32,
+                              const sead::Vector2f&, float, float);
+    bool hitCheckLayoutCircle(ScreenPointer*, sead::ObjArray<ScreenPointTargetHitInfo>*, s32,
+                              const sead::Vector2f&, float, float,
+                              s32 (*)(const ScreenPointTargetHitInfo*,
+                                      const ScreenPointTargetHitInfo*));
+
+private:
+    ScreenPointCheckGroup* mCheckGroup;
+};
+static_assert(sizeof(ScreenPointDirector) == 0x8);
+
+}  // namespace al

lib/al/include/Library/Shader/ForwardRendering/ShaderHolder.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <heap/seadDisposer.h>
+
+#include "Library/HostIO/HioNode.h"
+
+namespace al {
+
+class ShaderHolder : public HioNode {
+    SEAD_SINGLETON_DISPOSER(ShaderHolder)
+public:
+    // incomplete
+private:
+    // missing
+};
+
+}  // namespace al

lib/al/include/Library/Shadow/ShadowDirector.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+
+namespace sead {
+class Camera;
+}
+
+namespace agl {
+class DrawContext;
+class RenderTargetDepth;
+class TextureData;
+}  // namespace agl
+
+namespace al {
+class GraphicsSystemInfo;
+class AreaObjDirector;
+class ExecuteDirector;
+class EffectSystem;
+class SceneCameraInfo;
+class PlayerHolder;
+class Projection;
+class ShaderHolder;
+class DepthShadowParam;
+class DepthShadowClipParam;
+
+class ShadowDirector {
+public:
+    ShadowDirector(s32, GraphicsSystemInfo*, AreaObjDirector*, ExecuteDirector*, EffectSystem*,
+                   SceneCameraInfo*, const PlayerHolder*);
+    ~ShadowDirector();
+
+    void initShader(ShaderHolder*);
+    void endInit();
+    void initAfterPlacement();
+    void clearRequest();
+    void update();
+    void* getCurrentShadowParam();  // unknown return type
+    void* getCurrentClipParam();    // unknown return type
+    bool isUsingShadowCamera() const;
+    void preDrawGraphics();
+    void isEnableShadowPrePass() const;
+    void updateViewGpu(s32, const sead::Camera*, const Projection*);
+    void* getDepthShadow();  // unknown return type
+    void drawShadowPrePass(agl::DrawContext*, s32, const agl::RenderTargetDepth*,
+                           const agl::RenderTargetDepth*, const agl::TextureData*);
+    void* getShadowPrePassSampler(s32) const;  // unknown return type
+    void* getShadowPrePassTexture(s32) const;  // unknown return type
+    bool isEnableDepthShadow() const;
+    void* getCurrentShadowParam() const;  // unknown return type
+    void* getCurrentClipParam() const;    // unknown return type
+    void* getCurrentNear() const;         // unknown return type
+    void* getCurrentFar() const;          // unknown return type
+    bool requestParam(s32, s32, const DepthShadowParam&);
+    bool requestParam(s32, s32, const DepthShadowClipParam&);
+};
+
+}  // namespace al

lib/al/include/Library/Stage/StageSwitchKeeper.h

@@ -2,11 +2,16 @@
 
 #include <basis/seadTypes.h>
 
+#include "Library/Execute/IUseExecutor.h"
+#include "Library/HostIO/HioNode.h"
 #include "Library/HostIO/IUseName.h"
 
 namespace al {
+class ExecuteDirector;
+class PlacementId;
 class StageSwitchAccesser;
 class StageSwitchDirector;
+class StageSwitchListener;
 class PlacementInfo;
 
 class StageSwitchKeeper {
@@ -20,4 +25,23 @@ private:
     s32 mAccesserNum;
     void* field_10;
 };
+
+class StageSwitchDirector : public HioNode, public IUseExecutor {
+public:
+    StageSwitchDirector(ExecuteDirector*);
+
+    void execute() override;
+
+    void useSwitch(const StageSwitchAccesser*);
+    void* findSwitchNoFromObjId(const PlacementId*);  // unknown return type
+    void onSwitch(const StageSwitchAccesser*);
+    void offSwitch(const StageSwitchAccesser*);
+    bool isOnSwitch(const StageSwitchAccesser*);
+    void addListener(StageSwitchListener*, StageSwitchAccesser*);
+
+private:
+    void* filler[3];
+};
+static_assert(sizeof(StageSwitchDirector) == 0x20);
+
 }  // namespace al

lib/al/include/Project/Clipping/ClippingDirector.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+
+#include "Library/Execute/IUseExecutor.h"
+#include "Library/HostIO/HioNode.h"
+
+namespace al {
+class AreaObjDirector;
+class PlayerHolder;
+class SceneCameraInfo;
+class ViewIdHolder;
+class ActorInitInfo;
+class LiveActor;
+
+class ClippingDirector : public HioNode, public IUseExecutor {
+public:
+    ClippingDirector(s32, const AreaObjDirector*, const PlayerHolder*, const SceneCameraInfo*);
+    ~ClippingDirector();
+
+    void execute() override;
+
+    void endInit(const AreaObjDirector*);
+    void setDefaultFarClipDistance(f32);
+    void setDefaultFarClipDistanceSub(f32);
+    void getFarClipDistance();
+    void registerActor(LiveActor*, const ViewIdHolder*);
+    void addToGroupClipping(LiveActor*, const ActorInitInfo&);
+    void onGroupClipping(LiveActor*);
+    void offGroupClipping(LiveActor*);
+    void startCheckViewCtrlByCameraPos();
+    void startCheckViewCtrlByLookAtPos();
+    void startCheckViewCtrlByPlayerPos();
+
+private:
+    void* filler[6];
+};
+static_assert(sizeof(ClippingDirector) == 0x38);
+
+}  // namespace al

lib/al/include/Project/Execute/ExecuteAsyncExecutor.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <mc/seadCoreInfo.h>
+#include <thread/seadThread.h>
+
+#include "Library/HostIO/HioNode.h"
+
+namespace al {
+class ExecuteDirector;
+
+class ExecuteAsyncExecutor : public HioNode {
+public:
+    ExecuteAsyncExecutor(const ExecuteDirector*, const char*, sead::CoreId);
+    virtual ~ExecuteAsyncExecutor();
+
+    virtual void execute() = 0;
+
+    void executeAsync(sead::Thread*, long);
+    void executeAsync();
+    void waitAsync();
+
+private:
+    void* filler[4];
+};
+
+class ExecuteAsyncExecutorUpdate : public ExecuteAsyncExecutor {
+public:
+    ExecuteAsyncExecutorUpdate(const ExecuteDirector* director, const char* name,
+                               sead::CoreId coreId)
+        : ExecuteAsyncExecutor(director, name, coreId) {}
+    ~ExecuteAsyncExecutorUpdate() override;
+    void execute() override;
+
+private:
+    // missing
+};
+static_assert(sizeof(ExecuteAsyncExecutorUpdate) == 0x28);
+
+class ExecuteAsyncExecutorDraw : public ExecuteAsyncExecutor {
+public:
+    ExecuteAsyncExecutorDraw(const ExecuteDirector* director, const char* name, sead::CoreId coreId)
+        : ExecuteAsyncExecutor(director, name, coreId) {}
+    ~ExecuteAsyncExecutorDraw() override;
+    void execute() override;
+
+private:
+    // missing
+};
+
+}  // namespace al

lib/al/include/Project/Gravity/GravityHolder.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <math/seadVector.h>
+
+namespace al {
+class PlacementInfo;
+
+class GravityHolder {
+public:
+    GravityHolder();
+    void init();
+    void createGravity(const PlacementInfo&);
+    bool tryCalcGravity(sead::Vector3f*, const sead::Vector3f&) const;
+    bool tryCalcBlendGravity(sead::Vector3f*, const sead::Vector3f&) const;
+
+private:
+    void* filler[2];
+};
+static_assert(sizeof(GravityHolder) == 0x10);
+
+}  // namespace al

lib/al/include/Project/HitSensor/HitSensorDirector.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "Library/Execute/IUseExecutor.h"
+#include "Library/HostIO/HioNode.h"
+
+namespace al {
+class ExecuteDirector;
+class HitSensor;
+class SensorHitGroup;
+
+class HitSensorDirector : public IUseExecutor, public IUseHioNode {
+public:
+    HitSensorDirector(ExecuteDirector*);
+
+    void execute() override;
+
+    void initGroup(HitSensor*);
+    void executeHitCheckInSameGroup(SensorHitGroup*) const;
+    void executeHitCheckGroup(SensorHitGroup*, SensorHitGroup*) const;
+    void executeHitCheck(HitSensor*, HitSensor*) const;
+
+private:
+    void* filler[8];
+};
+static_assert(sizeof(HitSensorDirector) == 0x48);
+
+}  // namespace al

lib/al/src/Library/LiveActor/LiveActorKit.cpp

@@ -0,0 +1,228 @@
+#include "Library/LiveActor/LiveActorKit.h"
+
+#include "Library/Area/AreaObjDirector.h"
+#include "Library/Area/SwitchAreaDirector.h"
+#include "Library/Camera/CameraDirector.h"
+#include "Library/Collision/CollisionDirector.h"
+#include "Library/Controller/PadRumbleDirector.h"
+#include "Library/Draw/GraphicsSystemInfo.h"
+#include "Library/Effect/EffectSystem.h"
+#include "Library/Execute/ExecuteDirector.h"
+#include "Library/Execute/ExecuteSystemInitInfo.h"
+#include "Library/Execute/ExecuteTableHolderUpdate.h"
+#include "Library/LiveActor/LiveActorGroup.h"
+#include "Library/Model/ModelDisplayListController.h"
+#include "Library/Model/ModelDrawBufferUpdater.h"
+#include "Library/Model/ModelGroup.h"
+#include "Library/Nature/NatureDirector.h"
+#include "Library/Obj/DynamicDrawActor.h"
+#include "Library/Player/PlayerHolder.h"
+#include "Library/Resource/ActorResourceHolder.h"
+#include "Library/Scene/ItemDirectorBase.h"
+#include "Library/Screen/ScreenPointDirector.h"
+#include "Library/Shader/ForwardRendering/ShaderHolder.h"
+#include "Library/Shadow/ShadowDirector.h"
+#include "Library/Shadow/ShadowKeeper.h"
+#include "Library/Stage/StageSwitchKeeper.h"
+#include "Project/Clipping/ClippingDirector.h"
+#include "Project/Execute/ExecuteAsyncExecutor.h"
+#include "Project/Gravity/GravityHolder.h"
+#include "Project/HitSensor/HitSensorDirector.h"
+
+namespace al {
+
+LiveActorKit::LiveActorKit(s32 maxActors, s32 maxPlayers) : mMaxActors(maxActors) {
+    mLiveActorGroupAllActors = new LiveActorGroup("全てのアクター", maxActors);
+    mPlayerHolder = new PlayerHolder(maxPlayers);
+    mDynamicDrawActorGroup = new LiveActorGroup("独自描画グループ", 256);
+}
+
+LiveActorKit::~LiveActorKit() {
+    if (mExecuteDirector) {
+        delete mExecuteDirector;
+        mExecuteDirector = nullptr;
+    }
+    if (mCameraDirector) {
+        delete mCameraDirector;
+        mCameraDirector = nullptr;
+    }
+    if (mClippingDirector) {
+        delete mClippingDirector;
+        mClippingDirector = nullptr;
+    }
+    if (mModelGroup) {
+        delete mModelGroup;
+        mModelGroup = nullptr;
+    }
+    if (mGraphicsSystemInfo) {
+        delete mGraphicsSystemInfo;
+    }
+    if (mModelDrawBufferUpdater) {
+        delete mModelDrawBufferUpdater;
+    }
+
+    if (mExecutorCore1)
+        delete mExecutorCore1;
+    if (mExecutorCore2)
+        delete mExecutorCore2;
+
+    if (mDynamicDrawActorGroup) {
+        for (s32 i = 0; i < mDynamicDrawActorGroup->getActorCount(); i++) {
+            ((DynamicDrawActor*)mDynamicDrawActorGroup->getActor(i))->finalize();
+        }
+    }
+
+    if (mEffectSystem) {
+        mEffectSystem->endScene();
+        mEffectSystem->setCameraDirector(nullptr);
+        if (mEffectSystem) {
+            mEffectSystem->setGraphicsSystemInfo(nullptr);
+        }
+    }
+}
+
+void LiveActorKit::init(s32 maxCameras) {
+    mDrawBufferDirector = new DrawBufferDirector();
+
+    ExecuteSystemInitInfo info{};
+    mExecuteDirector = new ExecuteDirector(mMaxActors);
+    info.mDrawCtx = mSceneDrawContext;
+    mExecuteDirector->init(info);
+
+    mModelDrawBufferUpdater = new ModelDrawBufferUpdater(mExecuteDirector);
+    mExecutorCore1 = new ExecuteAsyncExecutorUpdate(mExecuteDirector, "ビュー更新(コア1)", 1);
+    mExecutorCore2 = new ExecuteAsyncExecutorUpdate(mExecuteDirector, "ビュー更新(コア2)", 2);
+    mAreaObjDirector = new AreaObjDirector();
+    mCollisionDirector = new CollisionDirector(mExecuteDirector);
+    mCameraDirector = new CameraDirector(maxCameras);
+
+    if (mEffectSystem) {
+        mEffectSystem->setCameraDirector(mCameraDirector);
+        mEffectSystem->initScene();
+    }
+
+    mPadRumbleDirector = new PadRumbleDirector(mPlayerHolder, mCameraDirector);
+    mClippingDirector = new ClippingDirector(mMaxActors, mAreaObjDirector, mPlayerHolder,
+                                             mCameraDirector->getSceneCameraInfo());
+    registerExecutorUser(mClippingDirector, mExecuteDirector, "クリッピング");
+    mStageSwitchDirector = new StageSwitchDirector(mExecuteDirector);
+    mScreenPointDirector = new ScreenPointDirector();
+    mModelGroup = new ModelGroup(mMaxActors);
+    mModelDisplayListController = new ModelDisplayListController(mModelGroup);
+    mActorResourceHolder = new ActorResourceHolder(mMaxActors);
+}
+
+void LiveActorKit::initGraphics(const GraphicsInitArg& graphics) {
+    mGraphicsSystemInfo = new (0x10) GraphicsSystemInfo();
+    mGraphicsSystemInfo->init(graphics, mAreaObjDirector, mExecuteDirector, mEffectSystem,
+                              mPlayerHolder, mCameraDirector->getSceneCameraInfo(),
+                              ShaderHolder::instance());
+
+    if (mModelDisplayListController)
+        mModelDisplayListController->setGraphicsSystemInfo(mGraphicsSystemInfo);
+}
+
+void LiveActorKit::initHitSensorDirector() {
+    mHitSensorDirector = new HitSensorDirector(mExecuteDirector);
+}
+
+void LiveActorKit::initGravityHolder() {
+    mGravityHolder = new GravityHolder();
+    mGravityHolder->init();
+}
+
+void LiveActorKit::initShadowDirector() {}
+
+void LiveActorKit::initEffectSystem() {
+    mEffectSystem = EffectSystem::initializeSystem(mGraphicsSystemInfo->getDrawContext(), nullptr);
+}
+
+void LiveActorKit::initSwitchAreaDirector(s32 val1, s32 val2) {
+    mSwitchAreaDirector =
+        SwitchAreaDirector::tryCreate(mAreaObjDirector, mPlayerHolder, mCameraDirector, val1, val2);
+}
+
+void LiveActorKit::initNatureDirector() {
+    mNatureDirector = new NatureDirector();
+    mNatureDirector->init();
+}
+
+void LiveActorKit::endInit() {
+    mCollisionDirector->endInit();
+    mClippingDirector->endInit(mAreaObjDirector);
+    mAreaObjDirector->endInit();
+    mCameraDirector->endInit(mPlayerHolder);
+
+    if (mEffectSystem)
+        mEffectSystem->startScene(mExecuteDirector);
+
+    if (mSwitchAreaDirector)
+        mSwitchAreaDirector->endInit();
+
+    if (mItemDirector)
+        mItemDirector->endInit();
+
+    if (mShadowDirector)
+        mShadowDirector->endInit();
+
+    if (mNatureDirector && mAreaObjDirector) {
+        AreaObjGroup* waterArea = mAreaObjDirector->getAreaObjGroup("WaterArea");
+        mNatureDirector->setWaterAreaGroup(waterArea);
+    }
+
+    if (mEffectSystem)
+        mEffectSystem->setGraphicsSystemInfo(mGraphicsSystemInfo);
+
+    mGraphicsSystemInfo->endInit();
+
+    if (mEffectSystem)
+        mEffectSystem->endInit();
+
+    for (s32 i = 0; i < mLiveActorGroupAllActors->getActorCount(); i++) {
+        LiveActor* actor = mLiveActorGroupAllActors->getActor(i);
+        actor->initAfterPlacement();
+        if (actor->getShadowKeeper())
+            actor->getShadowKeeper()->initAfterPlacement(mGraphicsSystemInfo);
+    }
+
+    mGraphicsSystemInfo->initAfterPlacement();
+    mExecuteDirector->createExecutorListTable();
+}
+
+void LiveActorKit::update(const char* unk) {
+    clearGraphicsRequest();
+
+    if (mPadRumbleDirector)
+        mPadRumbleDirector->update();
+
+    if (mExecuteDirector)
+        mExecuteDirector->execute(unk);
+
+    updateGraphics();
+
+    if (mAreaObjDirector)
+        mAreaObjDirector->update();
+
+    if (mSwitchAreaDirector)
+        mSwitchAreaDirector->update();
+}
+
+void LiveActorKit::clearGraphicsRequest() {
+    if (mGraphicsSystemInfo)
+        mGraphicsSystemInfo->clearGraphicsRequest();
+}
+
+void LiveActorKit::updateGraphics() {
+    mExecutorCore1->executeAsync();
+    mExecutorCore2->executeAsync();
+
+    if (mGraphicsSystemInfo)
+        mGraphicsSystemInfo->updateGraphics();
+}
+
+void LiveActorKit::preDrawGraphics() {
+    if (mGraphicsSystemInfo)
+        mGraphicsSystemInfo->preDrawGraphics(mCameraDirector->getSceneCameraInfo());
+}
+
+}  // namespace al