Decompile dBg_c

include/game/bases/d_3d.hpp

@@ -0,0 +1,10 @@
+#pragma once
+#include <game/mLib/m_3d.hpp>
+
+namespace d3d {
+
+class proc_c : public m3d::proc_c {
+
+};
+
+} // namespace d3d

include/game/bases/d_a_player_manager.hpp

@@ -43,12 +43,15 @@ class daPyMng_c {
         }
         return res;
     }
+    static u8 getActScrollInfo(); /// @unofficial
+    static int getScrollNum();
+    static bool isScrollMode1() { return getScrollNum() == 1; }
 
     static bool checkPlayer(u8 plrNo) { return mActPlayerInfo & (1 << plrNo); }
     static int getRest(PLAYER_TYPE_e plrNo) { return mRest[plrNo]; }
     static PLAYER_TYPE_e getPlayerType(int plrNo) { return mPlayerType[plrNo]; }
     static int getPlayerMode(int plrNo) { return mPlayerMode[plrNo]; }
-    static nw4r::math::VEC3 getPlayerSetPos(u8 file, u8 gotoNo);
+    static mVec3_c getPlayerSetPos(u8 file, u8 gotoNo);
 
     static int mNum;
     static u32 mPauseDisable;

include/game/bases/d_bg.hpp

@@ -1,12 +1,98 @@
 #pragma once
+#include <game/bases/d_base.hpp>
+#include <game/bases/d_3d.hpp>
+#include <game/bases/d_actor.hpp>
+#include <game/bases/d_bg_global.hpp>
+#include <game/bases/d_bg_tex.hpp>
+#include <game/bases/d_cd.hpp>
 #include <game/mLib/m_vec.hpp>
+#include <game/mLib/m_3d.hpp>
 
-class dBg_c {
+class dProcShareProc_c : public d3d::proc_c {
+public:
+    dProcShareProc_c() : idk(0) {}
+    // virtual ~dProcShareProc_c() {}
+    mAllocator_c mAlloc;
+    u32 idk;
+};
+
+class dShareBgTexProc_c : public dProcShareProc_c {
+public:
+    dShareBgTexProc_c() {}
+    // virtual ~dShareBgTexProc_c() {}
+    virtual void remove();
+
+    void create(bgTex_c *, EGG::Heap *);
+};
+
+struct dBgScrollLimit_c {
+    float mL, mR, mU, mD;
+    float mL2, mR2, mU2, mD2;
+    float mL3, mR3, mU3, mD3;
+    float mL4, mR4, mU4, mD4;
+    u16 mFlags;
+};
+
+class dBgBound_c {
+public:
+    dBgBound_c() : mLeft(0.0f), mRight(0.0f), mUp(0.0f), mDown(0.0f) {}
+
+    float getR() const { return mRight; }
+    float getL() const { return mLeft; }
+    float getU() const { return mUp; }
+    float getD() const { return mDown; }
+    float getW() const { return getR() - getL(); }
+    float getH() const { return getU() - getD(); }
+
+    float mLeft, mRight, mUp, mDown;
+};
+
+struct dBgSomeInfo_c {
+    dBgSomeInfo_c() :
+        m_10(nullptr), m_14(nullptr), m_18(nullptr), m_1c(nullptr) {}
+
+    dBgBound_c mBounds;
+    dAcPy_c *m_10, *m_14, *m_18, *m_1c;
+    int m_20, m_24, m_28, m_2c, m_30;
+};
+
+struct dBgSubstruct2_c {
+public:
+    float mFloat1, mFloat2, mFloat3, mFloat4;
+    u8 mU8_1;
+    u8 mU8_2;
+    u8 mU8_3;
+};
+
+struct dBgAnimObj_c {
+    void set(dBgAnimObj_c obj) { *this = obj; }
+
+    float mX, mY;
+    u8 mType;
+};
+
+struct dHeapSize_c {
+public:
+    dHeapSize_c(size_t size) : mSize(size) {}
+
+    size_t mSize;
+};
+
+struct sBgThing {
+    u16 m_00;
+    u16 m_02;
+    int m_04;
+    int m_08;
+    int m_0c;
+};;
+
+class dBg_c : public dBase_c {
     class dBg_autoScroll_c {
     public:
         dBg_autoScroll_c() {}
         ~dBg_autoScroll_c() {}
 
+        // char data[0x1c];
         mVec3_c mPos;
         float m_0c;
         float m_10;
@@ -17,31 +103,240 @@ class dBg_c {
     };
 
 public:
-    u8 mPad1[0x8fe70];
-    float m_8fe00;
-    u8 mPad2[0x2c];
-    float mLoopOffset;
-    u8 mPad3[0x20];
-    float mLiquidHeight;
-    u8 mPad4[0x144];
-    float mDispScale;
-    float m_8ffa8;
-    float mPrevDispScale;
-    u8 mPad5[0x61];
-    u8 m_90009;
-    u8 mPad6[0x30];
-    dBg_autoScroll_c mAutoscrolls[2];
-    u8 mPad7[0x1a];
-    u8 m_9008e;
+    dBg_c();
+    virtual ~dBg_c();
 
-    float getLiquidHeight() const { return mLiquidHeight; }
+    void CreateBgCheckBuffer();
 
-    void setWaterInWave(float x, float y, u8 type);
+    unsigned long long CvtBgCheckFromUnitNo(u16);
+    static unsigned long long fn_80081960(unsigned long long, int);
+    dBgUnit_c *__GetUnitPointer(u16 param_2, u16 param_3, u8 param_4, int *param_5, bool b);
+
+    unsigned long long getBgCheckBuff(u16);
+    unsigned long long *getpBgCheckBuff(u16);
+    u16 GetUnitNumber(u16, u16, u8, bool);
+    u16 GetMaskedUnitNumber(u16, u16, u8);
+    unsigned long long GetBgCheckData(u16, u16, u8);
+    u32 GetUnitTypeInfo(u16, u16, u8);
+    u32 GetUnitKindInfo(u16, u16, u8);
+    void CoinGetCommon(u16, u16, int, u16 *, u16 *, u16 *);
+    void CoinGetBitSet(u16, u16, int);
+    bool CoinGetBitCheck(u16, u16, int);
+    void BgUnitChange(u16, u16, int, u16);
+    bool CheckExistLayer(u8);
+    void DispScaleCalc();
+    void CreateBgTex();
+    void RemoveBgTex();
+
+    bgTex_c *__createBgTex(int, u16, u16, u16, u16, int, int);
+    void EntryWakuCoin(ulong, u16, u16, int);
+    void SetWakuCoin();
+    void fn_80077860(u16, u16, int, u16);
+    void setWaterInWave(float, float, u8);
+    void setBubble(float, float, u8, u8);
+
+    void InitWmSwitchPushed();
+    bool IsWmSwitchPushed();
+
+    dPanelObjMgr_c *getPanelObjMgr(int idx);
+
+    static u16 dBg_getUpLimitScroll(u8);
+    static int dBg_getScrlAreaDataSize(u8);
+    static sScrollAreaData *dBg_getScrlAreaDataP(u8, u8);
+    bool dBg_isFlyPlayer();
+    int dBg_isCloudFlyPlayer();
+    int dBg_isCloudFlyPlayerMulti(); // [Not static? bruh]
+
+    float fn_80078860(float);
+
+    float getMaxLeftPos();
     float getLeftLimit();
+    float getMaxRightPos();
     float getRightLimit();
+    float getLeftLimitSingle();
+    float getLeftLimitMulti();
+    float getZoomTargetMin_Common();
+    float getZoomTargetMin();
+    float getZoomTargetMid_Common();
+    float getZoomTargetMid();
+    float getZoomTargetMax_Common();
+    float getZoomTargetMax();
+
+    float calcDispScale(float bgVal, float tmp1) {
+        return (1.0f / getZoomTargetMin()) + bgVal * (1.0f / tmp1 - (1.0f / getZoomTargetMin()));
+    }
+
+    float invZoomTargetMin() {
+        return 1.0f / getZoomTargetMin();
+    }
+
+    float getZoomSpreadLine();
+    float getZoomSpreadLine2();
+    float getZoomShrinkLine();
+    float getZoomShrinkLine2();
+
+    void calcLookatOffs();
+    void calcLookatOffsLimit();
+    void calcLookatOffsX(dActor_c *);
+    void calcLookatOffsY(dActor_c *);
+
+    void initAutoScroll();
+    void calcLoopAutoScroll();
+    void calcAutoScroll();
+    void AutoScroll_start();
+    void AutoScroll_stop();
+    void calcScroll(const mVec3_c&, int);
+    void calcMultiScroll( int );
+    void initScroll();
+
+    void fn_8007ac40(const dBgSomeInfo_c *, int); ///< @unofficial
+    void fn_8007ba70(const dBgSomeInfo_c *); ///< @unofficial
+    float fn_8007bba0(const dBgSomeInfo_c *); ///< @unofficial
+    float fn_8007bbf0(const dBgSomeInfo_c *); ///< @unofficial
+    bool fn_8007bc40(const dBgSomeInfo_c *, float); ///< @unofficial
+    mVec2_c fn_8007bd40(const dBgSomeInfo_c *, float, float); ///< @unofficial
+    float fn_8007c7d0(float); ///< @unofficial
+    void fn_8007ca90(dBgSomeInfo_c *, int, int); ///< @unofficial
+    void fn_8007cd70(dBgSomeInfo_c *, dBgSomeInfo_c *, int); ///< @unofficial
+
+    u8 freeUpScrollLimit(const dBgScrollLimit_c &scrollLimit, int group, int area); ///< @unofficial
+    u8 freeUpScrollLimit2(const dBgScrollLimit_c &scrollLimit, int group, int area); ///< @unofficial
+
+    void setScrollLimit(dBgScrollLimit_c *scrollLimit, int areaNo, int type, int group); ///< @unofficial
+
+    void fn_8007E060(dBgSubstruct2_c *s, int idx);
+
+    float getAreaUpLimitScroll();
+
+    static void bg_createHeap();
+    static void bg_destroyHeap();
 
     float getDispScale() { return mDispScale; }
-    float getPrevDispScale() { return mPrevDispScale; }
+    float getPrevDispScale() { return mMoreFloats3[0]; }
+    float getScaleFactor() { return 1.0f / mDispScale; }
+    float getZoom() { return 1.0f / mZoomDenom; }
+    float getLiquidHeight() const { return mMoreFloats7[5]; }
+
+    float getL() { return mL; }
+    float getU() { return mU; }
+    float getD() { return mD; }
+    float getR() { return mR; }
+    u16 cvtL() { return getL(); }
+    u16 cvtR() { return getR(); }
+    u16 cvtU() { return getU(); }
+    u16 cvtD() { return getD(); }
+    u16 cvtW() { return getR() - getL(); }
+    u16 cvtH() { return getU() - getD(); }
+
+    float getDownLimit() { return mDLimit; }
+    float getUpLimit() { return mULimit; }
+
+    float getSomePosX() { return mSomePos.x; }
+    float getSomePosY() { return mSomePos.y; }
+    float getPrevSomePosX() { return mPrevSomePos.x; }
+    float getPrevSomePosY() { return mPrevSomePos.y; }
+    float getSomeSizeX() { return mSomeSize.x; }
+    float getSomeSizeY() { return mSomeSize.y; }
+    float getPrevSomeSizeX() { return mPrevSomeSize.x; }
+    float getPrevSomeSizeY() { return mPrevSomeSize.y; }
+
+    float get_900acX() { return m_900ac.x; }
+    float get_900acY() { return m_900ac.y; }
+
+    float getSomeScale() { return mSomeScale; }
+
+    float getZoomDenom() { return mZoomDenom; }
+
+    float getLoopOffsetX() { return mLoopOffsetX; }
+
+    dBgScrollLimit_c *getScrLim(int area, int group, int idx) { return &mScrLimit[area][group][idx]; }
+    dBgSubstruct2_c * getData2(int idx, int i) { return &mData2[idx][i]; }
+
+    typedef void (dBg_c::*callbackFunc)(const dBgSomeInfo_c *, int);
+
+    unsigned long long *mBgCheckBuffer;
+    int mBgThingsRelated;
+    sBgThing mBgThings[256];
+    dBgScrollLimit_c mScrLimit[64][8][16];
+    dBgSubstruct2_c mData2[64][20];
+    int mGrassCount;
+    int mFlowerCount;
+    dBgAnimObj_c mGrass[100];
+    dBgAnimObj_c mFlowers[100];
+    u8 mUnused1[56];
+    float m_8fda8;
+    u8 mUnused2[40];
+    float mBounds4[4];
+    float mBounds3[4];
+    float mL, mR, mU, mD;
+    float mMoreFloats[1];
+    mVec2_c mSomeSize;
+    mVec2_c mPrevSomeSize;
+    mVec2_c mSomePos;
+    mVec2_c mPrevSomePos;
+    float mMoreFloats6[2];
+    float mLoopOffsetX;
+    float mLoopOffsetY;
+    mVec2_c mSomeParameterPos;
+    float mMoreFloats7[7];
+    float mWaveRelated[80];
+    float mDispScale;
+    float mSomeScale;
+    float mMoreFloats3[3];
+    u8 mU8s[6];
+    float mZoomDenom;
+    u8 m_8ffbc;
+    float mLLimit, mRLimit, mULimit, mDLimit;
+    float mLLimitSingle, mRLimitSingle, mULimitSingle, mDLimitSingle;
+    float mLLimitMulti, mRLimitMulti, mULimitMulti, mDLimitMulti;
+    float mPlayerPosY;
+    int mIdkI;
+    float mIdkF[4];
+    u8 m_90008;
+    u8 m_90009;
+    u8 m_9000a;
+    callbackFunc mCallbackFunc;
+    float m_90018;
+    int m_9001c;
+    float m_90020;
+    u8 m_90024;
+    float mMoreFloats5[5];
+    dBg_autoScroll_c mAutoscrolls[2];
+    u8 mPad2[8];
+    int m_9007c, m_90080;
+    float m_90084;
+    short m_90088, m_9008a;
+    u8 m_9008c, m_9008d;
+    u8 mLimitRelated;
+    u8 mLimitRelated2;
+    u8 m_90090, mScrollID, m_90092, m_90093;
+    u8 mPad[12];
+    float mZoomWeight;
+    u8 mZoomRelated;
+    u8 m_900a5, m_900a6, m_900a7, m_900a8;
+    mVec2_c m_900ac;
+    u8 m_900b4;
+    short m_900b6;
+    float m_900b8, m_900bc;
+    float mWaveX[20];
+    float mWaveY[20];
+    u8 mWaveType[20];
+    bool mWaveActive[20];
+    float mBubbleX[200];
+    float mBubbleY[200];
+    u8 mBubbleType[200];
+    u8 mBubbleType2[200];
+    short m_90958;
+    u8 m_9095a, m_9095b, m_9095c, m_9095d;
+    float m_90960;
+    float m_90964;
+    dBgSomeInfo_c mSomeInfo1;
+    dBgSomeInfo_c mSomeInfo2;
+    bgTex_c *mTex[3];
+    dShareBgTexProc_c *mTexProc;
+    dBgTexMng_c mTexMng;
 
     static dBg_c *m_bg_p;
+    static dHeapSize_c m_HeapSize;
+    static EGG::FrmHeap *m_FrmHeap_p;
 };