mirror/ss
1
0
Fork 0
mirror of https://github.com/zeldaret/ss synced 2026-07-01 11:48:50 -04:00
Code Issues Packages Projects Releases Wiki Activity

Pad stuff

Browse Source
This commit is contained in:
elijah-thomas774
2025-06-15 14:40:59 -04:00
parent 2707f74d70
commit e4b1c30f47
40 changed files with 2258 additions and 874 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/d/a/obj/d_a_obj_boomerang.h
+28 -18
View File
@@ -106,24 +106,34 @@ public: // TYPES
RB_FLY_MAX = 2,
};
static const char *sFlyChrAnims[RB_FLY_MAX];
// Macros until enum is solidified (0x8CC)
#define FLAG_BOOMERANG_CANCEL (0x3)
#define FLAG_BOOMERANG_RELEASE_ITEM (0x4)
#define FLAG_BOOMERANG_0x8 (0x8)
#define FLAG_BOOMERANG_0x10 (0x10)
#define FLAG_BOOMERANG_0x20 (0x20)
#define FLAG_BOOMERANG_0x40 (0x40)
#define FLAG_BOOMERANG_0x80 (0x80)
#define FLAG_BOOMERANG_STOP_TIMER_ACTIVE (0x100)
#define FLAG_BOOMERANG_DROP_ITEM (0x200) // related to 0x400
#define FLAG_BOOMERANG_REQUEST_0x400 (0x400) // related to 0x200
#define FLAG_BOOMERANG_REQUEST_MOVE (0x800)
#define FLAG_BOOMERANG_CONTROLLABLE (0x1000)
#define FLAG_BOOMERANG_0x2000 (0x2000)
#define FLAG_BOOMERANG_RUMBLE_ACTIVE (0x4000)
#define FLAG_BOOMERANG_WING_EFFECT_ACTIVE (0x8000)
#define FLAG_BOOMERANG_0x10000 (0x10000)
#define FLAG_BOOMERANG_0x40000 (0x40000)
enum Flags_e {
/* 0x00000001 */ FLAG_CANCEL_1 = 1 << 0,
/* 0x00000002 */ FLAG_CANCEL_2 = 1 << 1,
/* 0x00000003 */ FLAG_CANCEL = FLAG_CANCEL_1 | FLAG_CANCEL_2,
/* 0x00000004 */ FLAG_RELEASE_ITEM = 1 << 2,
/* 0x00000008 */ FLAG_0x8 = (0x8),
/* 0x00000010 */ FLAG_0x10 = (0x10),
/* 0x00000020 */ FLAG_0x20 = (0x20),
/* 0x00000040 */ FLAG_0x40 = (0x40),
/* 0x00000080 */ FLAG_0x80 = (0x80),
/* 0x00000100 */ FLAG_STOP_TIMER_ACTIVE = (0x100),
/* 0x00000200 */ FLAG_DROP_ITEM = (0x200), // related to 0x400
/* 0x00000400 */ FLAG_REQUEST_0x400 = (0x400), // related to 0x200
/* 0x00000800 */ FLAG_REQUEST_MOVE = (0x800),
/* 0x00001000 */ FLAG_CONTROLLABLE = (0x1000),
/* 0x00002000 */ FLAG_0x2000 = (0x2000),
/* 0x00004000 */ FLAG_RUMBLE_ACTIVE = (0x4000),
/* 0x00008000 */ FLAG_WING_EFFECT_ACTIVE = (0x8000),
/* 0x00010000 */ FLAG_0x10000 = (0x10000),
/* 0x00020000 */ FLAG_0x20000 = (0x40000),
/* 0x00040000 */ FLAG_0x40000 = (0x40000),
/* 0x00080000 */ FLAG_0x80000 = (0x80000),
/* 0x0001A117 */ FLAG_COMMON_INIT = FLAG_0x10000 | FLAG_WING_EFFECT_ACTIVE | FLAG_0x2000 |
FLAG_STOP_TIMER_ACTIVE | FLAG_0x10 | FLAG_RELEASE_ITEM | FLAG_CANCEL,
};
public: // INLINES
bool checkField_0x8CC(u32 mask) const {
include/d/d_gfx.h
+92 -1
View File
@@ -20,9 +20,100 @@ public:
return sInstance;
}
private:
public:
// clang-format off
static s32 getCurrentScreenWidth() { return g_CurrentScreenWidth_s32; }
static s32 getCurrentScreenHeight() { return g_CurrentScreenHeight_s32; }
static s32 getCurrentScreenWidthLimit() { return g_CurrentScreenWidthLimit_s32; }
static s32 getCurrentScreenHeightLimit() { return g_CurrentScreenHeightLimit_s32; }
static s32 getCurrentScreenLeft() { return g_CurrentScreenLeft_s32; }
static s32 getCurrentScreenRight() { return g_CurrentScreenRight_s32; }
static s32 getCurrentScreenTop() { return g_CurrentScreenTop_s32; }
static s32 getCurrentScreenBottom() { return g_CurrentScreenBottom_s32; }
static s32 getEFBHeight() { return g_CurrentEFBHeight_s32; }
static s32 getEFBHeightLimit() { return g_CurrentEFBHeightLimit_s32; }
static s32 getLetterboxAmount() { return g_CurrentLetterBoxAmount_s32; }
static f32 getCurrentScreenWidthF() { return g_CurrentScreenWidth_f32; }
static f32 getCurrentScreenHeightF() { return g_CurrentScreenHeight_f32; }
static f32 getCurrentScreenWidthLimitF() { return g_CurrentScreenWidthLimit_f32; }
static f32 getCurrentScreenHeightLimitF() { return g_CurrentScreenHeightLimit_f32; }
static f32 getCurrentScreenLeftF() { return g_CurrentScreenLeft_f32; }
static f32 getCurrentScreenRightF() { return g_CurrentScreenRight_f32; }
static f32 getCurrentScreenTopF() { return g_CurrentScreenTop_f32; }
static f32 getCurrentScreenBottomF() { return g_CurrentScreenBottom_f32; }
static f32 getScreenAspectF() { return g_CurrentScreenAspect; }
static f32 getEFBHeightF() { return g_CurrentEFBHeight_f32; }
static f32 getEFBHeightLimitF() { return g_CurrentEFBHeightLimit_f32; }
static f32 getLetterboxAmountF() { return g_CurrentEFBHeightDifference_f32; }
static f32 getHeightScaledF() { return g_CurrentHeightScaled_f32; }
static f32 getEFBHeightDifferenceF() { return g_CurrentEFBHeightDifference2_f32; }
static s32 getWidth4x3() { return g_Width4x3_s32; }
static s32 getWidth4x3Limit() { return g_Width4x3Limit_s32; }
static s32 getWidth16x9() { return g_Width16x9_s32; }
static s32 getWidth4x3Left() { return g_Width4x3Left_s32; }
static s32 getWidth4x3Right() { return g_Width4x3Right_s32; }
static f32 getWidth4x3F() { return g_Width4x3_f32; }
static f32 getWidth4x3LimitF() { return g_Width4x3Limit_f32; }
static f32 getWidth16x9F() { return g_Width16x9_f32; }
static f32 getWidth4x3LeftF() { return g_Width4x3Left_f32; }
static f32 getWidth4x3RightF() { return g_Width4x3Right_f32; }
static f32 get16x9to4x3WidthScaleF() { return g_16x9to4x3WidthScale; }
// clang-format on
public:
static dGfx_c *sInstance;
static s32 g_CurrentScreenWidth_s32;
static s32 g_CurrentScreenHeight_s32;
static s32 g_CurrentScreenWidthLimit_s32;
static s32 g_CurrentScreenHeightLimit_s32;
static s32 g_CurrentScreenLeft_s32;
static s32 g_CurrentScreenRight_s32;
static s32 g_CurrentScreenTop_s32;
static s32 g_CurrentScreenBottom_s32;
static s32 g_CurrentEFBHeight_s32;
static s32 g_CurrentEFBHeightLimit_s32;
static s32 g_CurrentLetterBoxAmount_s32;
static f32 g_CurrentScreenWidth_f32;
static f32 g_CurrentScreenHeight_f32;
static f32 g_CurrentScreenWidthLimit_f32;
static f32 g_CurrentScreenHeightLimit_f32;
static f32 g_CurrentScreenLeft_f32;
static f32 g_CurrentScreenRight_f32;
static f32 g_CurrentScreenTop_f32;
static f32 g_CurrentScreenBottom_f32;
static f32 g_CurrentScreenAspect;
static f32 g_CurrentEFBHeight_f32;
static f32 g_CurrentEFBHeightLimit_f32;
static f32 g_CurrentEFBHeightDifference_f32;
static f32 g_CurrentHeightScaled_f32;
static f32 g_CurrentEFBHeightDifference2_f32;
static s32 g_Width4x3_s32;
static s32 g_Width4x3Limit_s32;
static s32 g_Width16x9_s32;
static s32 g_Width4x3Left_s32;
static s32 g_Width4x3Right_s32;
static f32 g_Width4x3_f32;
static f32 g_Width4x3Limit_f32;
static f32 g_Width16x9_f32;
static f32 g_Width4x3Left_f32;
static f32 g_Width4x3Right_f32;
static f32 g_16x9to4x3WidthScale;
/* 0x00 */ u8 _0x00[0x04 - 0x00];
/* 0x04 */ DrawCallback mDrawCallback;
/* 0x08 */ u8 field_0x08;
include/d/d_pad.h
+232 -15
View File
@@ -1,24 +1,241 @@
#ifndef D_PAD_H
#define D_PAD_H
class dPad {
#include "common.h"
#include "egg/core/eggController.h"
#include "m/m_mtx.h"
#include "m/m_vec.h"
#include "rvl/KPAD/KPAD.h"
#include "rvl/WPAD/WPAD.h"
namespace dPad {
class ex_c {
// Complete Made up name
struct motion_c {
void init();
/* 0x0000 */ mVec3_c field_0x000[120];
/* 0x05A0 */ mVec3_c field_0x5A0[120];
/* 0x0B40 */ f32 field_0xB40[120];
/* 0x0D20 */ mVec3_c field_0xD20[39];
/* 0x0EF4 */ mVec3_c field_0xEF4[33];
/* 0x1080 */ mVec3_c field_0x1080;
/* 0x108C */ mVec3_c field_0x108C;
/* 0x1098 */ mMtx_c field_0x1098;
/* 0x10C8 */ u32 field_0x10C8;
/* 0x10CC */ u32 field_0x10CC;
/* 0x10D0 */ u32 field_0x10D0;
/* 0x10D4 */ f32 field_0x10D4;
/* 0x10D8 */ u32 field_0x10D8;
};
public:
static bool checkButtonAPressed();
static bool checkButtonBPressed();
static bool checkButtonZPressed();
static bool checkButtonCPressed();
static bool checkButtonMinusPressed();
static bool checkButtonPlusPressed();
static bool checkButton1Pressed();
static bool checkButton2Pressed();
void fn_80056AF0(s32 chan);
void fn_80056B90(s32 chan);
void fn_80056CE0(s32 chan);
void fn_80056DA0(s32 chan); // Deals with Mpls Calibration Start
void fn_80056DF0(s32 chan); // Deals with Mpls Calibration Work
f32 fn_80056E50();
void fn_80056E60(s32 chan); // Deals with Mpls Calibration Stop
void resetState(s32 chan);
static bool checkButtonDpadUpPressed();
static bool checkButtonDpadDownPressed();
static bool checkButtonDpadLeftPressed();
static bool checkButtonDpadRightPressed();
void fn_800572A0();
static bool checkButtonAHeld();
static bool checkButtonZHeld();
static bool isLowBattery();
static bool isOutOfBattery();
static void resetInfo();
static void clearInfo(s32 chan);
static s32 getInfo(s32 chan);
static s32 getBatteryLevel();
static s32 getBatteryLevel(s32 chan);
static void setInfo(s32 chan, const WPADInfo *pInfo);
static void on_0x54(s32 chan);
static void on_0x55(s32 chan);
static void on_0x56(s32 chan);
static void on_0x57(s32 chan);
static void fn_800592D0(s32 chan);
void fn_80059300(s32 chan);
void getUnifiedWpadStatus(s32 chan);
void fn_800593D0();
static ex_c *getInstance() {
return m_current_ex;
}
public:
/* 0x0000 */ mVec2_c mDpdPos;
/* 0x0008 */ mVec2_c field_0x8;
/* 0x0010 */ mVec2_c mFSStick;
/* 0x0018 */ f32 mFSStickDistance;
/* 0x001C */ mAng mFSStickAngle;
/* 0x0020 */ WPADResult mWPADProbeResult;
/* 0x0024 */ WPADResult mWPADProbeResultStable;
/* 0x0028 */ s32 mWPADProbeStableTimer;
/* 0x002C */ WPADDeviceType mWPADDeviceType;
/* 0x0030 */ u32 mWPADDeviceTypeStable;
/* 0x0034 */ s32 mWPADDeviceTypeStableTimer;
/* 0x0038 */ s32 field_0x38;
/* 0x003C */ s32 field_0x3C;
/* 0x0040 */ f32 field_0x40;
/* 0x0044 */ bool field_0x44;
/* 0x0045 */ bool field_0x45;
/* 0x0046 */ bool field_0x46;
/* 0x0047 */ bool field_0x47;
/* 0x0048 */ bool field_0x48;
/* 0x0049 */ bool field_0x49;
/* 0x004A */ bool field_0x4A;
/* 0x004B */ bool field_0x4B;
/* 0x004C */ bool mSpeakerSetup;
/* 0x004D */ bool mSpeakerShutdown;
/* 0x004E */ bool mIncorrectDeviceType;
/* 0x004F */ bool field_0x4F;
/* 0x0050 */ bool field_0x50;
/* 0x0051 */ bool field_0x51;
/* 0x0052 */ bool mMplsEnabled;
/* 0x0053 */ bool field_0x53;
/* 0x0054 */ bool field_0x54[4];
/* 0x0058 */ bool field_0x58[4];
/* 0x005C */ mVec2_c field_0x5C;
/* 0x0064 */ mVec2_c field_0x64;
/* 0x006C */ s32 field_0x6C;
/* 0x0070 */ mAng field_0x70;
/* 0x0074 */ mVec3_c field_0x74;
/* 0x0080 */ mVec3_c field_0x80;
/* 0x008C */ mVec3_c field_0x8C;
/* 0x0098 */ motion_c mMotion;
/* 0x1174 */ motion_c mFSMotion;
/* 0x2250 */ u8 _0x2250[0x2268 - 0x2250];
/* 0x2268 */ mVec3_c field_0x2268;
/* 0x2274 */ mVec3_c field_0x2274;
/* 0x2280 */ s32 mState;
/* 0x2284 */ s32 field_0x2284;
/* 0x2288 */ s32 field_0x2288;
/* 0x228C */ KPADUnifiedWpadStatus mStatus;
/* 0x22C0 */ u8 _0x22C0[0x22D0 - 0x22C4];
/* 0x22D0 */ u8 field_0x22D0;
/* 0x22D1 */ u8 field_0x22D1;
/* 0x22D4 */ s32 field_0x22D4;
/* 0x22D8 */ u8 field_0x22D8;
static WPADInfo m_info[2][4];
static bool m_connected[4];
static ex_c m_ex[4];
static ex_c *m_current_ex;
};
void initMpls(s32 chan);
void create();
void setMpls(bool enable, s32 chan);
void beginPad_BR();
void endPad_BR();
void setConnectCallback();
void enableMplsDirRevise(s32 chan);
void disableMplsDirRevise(s32 chan);
void setNoSleep();
void setAutoSleepTime();
// the next 4 funcs do nothing
void fn_80059620();
void fn_80059630();
void fn_80059640();
void fn_80059650();
bool getDownTrig(u32 btns);
bool getDownTrigA();
bool getDownTrigB();
bool getDownTrigC();
bool getDownTrigZ();
bool getDownTrigUp();
bool getDownTrigDown();
bool getDownTrigLeft();
bool getDownTrigRight();
bool getDownTrig1();
bool getDownTrig2();
bool getDownTrigMinus();
bool getDownTrigPlus();
bool getDown(u32 btns);
bool getDownAll(u32 btns);
bool getDownA();
bool getDownB();
bool getDownC();
bool getDownZ();
bool getDownUp();
bool getDownDown();
bool getDownLeft();
bool getDownRight();
bool getDown1();
bool getDown2();
bool getDownMinus();
bool getDownPlus();
bool getUpTrig(u32 btns);
bool getUpTrigA();
bool getUpTrigB();
bool getUpTrigC();
bool getUpTrigZ();
bool getUpTrigUp();
bool getUpTrigDown();
bool getUpTrigLeft();
bool getUpTrigRight();
bool getUpTrig1();
bool getUpTrig2();
bool getUpTrigMinus();
bool getUpTrigPlus();
bool getUp(u32 btns);
bool getUpAll(u32 btns);
bool getUpA();
bool getUpB();
bool getUpC();
bool getUpZ();
bool getUpUp();
bool getUpDown();
bool getUpLeft();
bool getUpRight();
bool getUp1();
bool getUp2();
bool getUpMinus();
bool getUpPlus();
mVec2_c &getDpdPos();
mVec2_c &getDpdStableMaybe();
mVec2_c &getFSStick();
f32 getFSStickX();
f32 getFSStickY();
f32 getFSStickDistance();
mAng getFSStickAngle();
mVec3_c getAcc();
/** returns m_current_ex->field_0x1160 >> 0 & 1 */
u32 fn_80059B750();
/** returns m_current_ex->field_0x1160 >> 1 & 1 */
u32 fn_80059B760();
/** returns m_current_ex->field_0x1160 >> 2 & 1 */
u32 fn_80059B70();
/** returns m_current_ex->field_0x1160 >> 3 & 1 */
u32 fn_80059B80();
/** returns m_current_ex->field_0x1160 >> 5 & 1 */
u32 fn_80059B90();
mVec3_c getFSAcc();
/** returns m_current_ex->field_0x223C >> 4 & 1 */
u32 fn_80059CC0();
/** returns m_current_ex->field_0x223C >> 5 & 1 */
u32 fn_80059CD0();
}; // namespace dPad
#endif
include/d/snd/d_snd_player_mgr.h
+3
View File
@@ -23,6 +23,9 @@ public:
public:
dSndPlayerMgr_c();
void setup(s32 channel);
void shutdown(s32 channel);
void shutdown();
void calc();
include/egg/audio/eggAudioRmtSpeakerMgr.h
+6 -6
View File
@@ -2,8 +2,8 @@
#define EGG_AUDIO_REMOTE_SPEAKER_MANAGER_H
#include "common.h"
#include "rvl/WPAD.h" // IWYU pragma: export
#include "rvl/WPAD.h" // IWYU pragma: export
namespace EGG {
@@ -19,8 +19,8 @@ class AudioRmtSpeakerMgr {
public:
static void calc();
static void fn_804B6D80(s32 i, WPADCallback *pCallback);
static void fn_804B6DE0(s32 i, WPADCallback *pCallback);
static void setup(s32 i, WPADCallback *pCallback);
static void shutdown(s32 i, WPADCallback *pCallback);
static void connectAllByForce();
static void disconnectAllByForce();
@@ -30,9 +30,9 @@ public:
private:
static void setupCallback(s32, s32);
static void shutdownCallback(s32, s32);
static void fn_804B6AF0(s32 i, WPADCallback *pCallback, bool);
static void fn_804B6B80(s32 i, WPADCallback *pCallback);
static void fn_804B6C00(s32 i, WPADCallback *pCallback);
static void add_task(s32 i, WPADCallback *pCallback, bool);
static void doSetup(s32 i, WPADCallback *pCallback);
static void doShutdown(s32 i, WPADCallback *pCallback);
static void setupCallbackDirect(s32, s32);
static void shutdownCallbackDirect(s32, s32);
static bool sAudioRmtSpeakerConnectCanncelSw;
include/egg/core/eggController.h
+334 -165
View File
@@ -2,107 +2,168 @@
#define EGG_CONTROLLER_H
#include "common.h"
#include "egg/core/eggSingleton.h"
#include "egg/math/eggMatrix.h"
#include "egg/math/eggVector.h"
#include "egg/prim/eggBitFlag.h"
#include "egg/prim/eggBuffer.h"
#include "rvl/KPAD/KPAD.h"
#include "rvl/KPAD.h" // IWYU pragma: exports
#include "rvl/PAD.h" // IWYU pragma: exports
#include "rvl/WPAD.h" // IWYU pragma: exports
namespace EGG {
class ControllerRumbleMgr;
class CoreController;
// To Be Filled out
enum eCoreDevType {
cDEV_CORE = WPAD_DEV_CORE,
cDEV_FREESTYLE = WPAD_DEV_FREESTYLE,
cDEV_CLASSIC = WPAD_DEV_CLASSIC,
cDEV_MPLS_PT_FS = WPAD_DEV_MPLS_PT_FS,
cDEV_FUTURE = WPAD_DEV_FUTURE,
cDEV_NOT_SUPPORTED = WPAD_DEV_NOT_SUPPORTED,
cDEV_NOT_FOUND = WPAD_DEV_NOT_FOUND,
cDEV_NULL = WPAD_DEV_NULL,
cDEV_UNKNOWN = WPAD_DEV_UNKNOWN,
};
typedef void (*ConnectCallback)(int args[]);
typedef class CoreController *(*ControllerFactory)();
enum eCoreButton {
cCORE_BUTTON_UP = 1 << 3,
cCORE_BUTTON_DOWN = 1 << 2,
cCORE_BUTTON_LEFT = 1 << 0,
cCORE_BUTTON_RIGHT = 1 << 1,
class CoreStatus {
cCORE_BUTTON_PLUS = 1 << 4,
cCORE_BUTTON_MINUS = 1 << 12,
cCORE_BUTTON_1 = 1 << 9,
cCORE_BUTTON_2 = 1 << 8,
cCORE_BUTTON_A = 1 << 11,
cCORE_BUTTON_B = 1 << 10,
cCORE_BUTTON_HOME = 1 << 15,
cCORE_FSSTICK_UP = 1 << 16,
cCORE_FSSTICK_DOWN = 1 << 17,
cCORE_FSSTICK_LEFT = 1 << 18,
cCORE_FSSTICK_RIGHT = 1 << 19,
cCORE_FSSTICK_BUTTONS = cCORE_FSSTICK_UP | cCORE_FSSTICK_DOWN | cCORE_FSSTICK_LEFT | cCORE_FSSTICK_RIGHT
};
typedef CoreController *(*CoreControllerFactory)();
struct CoreControllerConnectArg {
s32 chan; // at 0x0
s32 result; // at 0x4
};
typedef void (*CoreControllerConnectCallback)(const CoreControllerConnectArg &rArg);
struct CoreControllerExtensionArg {
eCoreDevType newDevType; // at 0x0
eCoreDevType oldDevType; // at 0x4
s32 chan; // at 0x8
};
class CoreControllerExtensionCallback {
public:
/* 0x00 */ u32 mHold;
/* 0x04 */ u32 mTrig;
/* 0x08 */ u32 mRelease;
/* 0x0C */ Vector3f mAccel;
/* 0x18 */ u8 field_0x01[0x20 - 0x18];
/* 0x20 */ f32 mDpdRawX;
/* 0x24 */ f32 mDpdRawY;
/* 0x28 */ u8 field_0x02[0x48 - 0x28];
/* 0x48 */ f32 mDpdDistance;
/* 0x4C */ f32 float_0x4C;
/* 0x50 */ f32 float_0x50;
/* 0x54 */ f32 float_0x54;
/* 0x58 */ f32 float_0x58;
/* 0x5C */ u8 mDevType;
/* 0x5D */ u8 field_0x5D;
/* 0x5E */ s8 mDpdValid;
/* 0x5F */ s8 unknown;
/* 0x60 */ f32 mFSStickX;
/* 0x64 */ f32 mFSStickY;
/* 0x68 */ u8 field_0x03[0x88];
virtual void onConnect(const CoreControllerExtensionArg &rArg); // at 0x8
};
/******************************************************************************
*
* CoreStatus
*
******************************************************************************/
class CoreStatus : public KPADStatus {
friend class CoreController;
public:
CoreStatus() {}
public:
void init();
u32 getFSStickButton() const;
f32 getFSStickX() const {
return mFSStickX;
}
f32 getFSStickY() const {
return mFSStickY;
}
bool down(u32 mask) const {
return (mask & mHold);
}
bool up(u32 mask) const {
return (mask & mHold) != mask;
}
bool downTrigger(u32 mask) const {
return (mask & mTrig);
}
bool upTrigger(u32 mask) const {
return (mask & mRelease);
}
bool downAll(u32 mask) const {
return (mask & mHold) == mask;
}
bool upAll(u32 mask) const {
return (mask & mHold) == 0;
}
s32 getDevType() const {
return mDevType;
}
bool isCore() const {
return getDevType() == WPAD_DEV_CORE;
}
bool isFreestyle() const {
return getDevType() == WPAD_DEV_FS;
}
u32 getHold() const {
return mHold;
return hold;
}
u32 getRelease() const {
return release;
}
u32 getTrigger() const {
return trig;
}
s8 getDpdValidFlag() const {
return mDpdValid;
};
bool down(u32 buttons) const {
return buttons & hold;
}
bool up(u32 buttons) const {
return (buttons & hold) != buttons;
}
Vector2f getUnk() {
return Vector2f(float_0x54, float_0x58);
bool downAll(u32 buttons) const {
return (buttons & hold) == buttons;
}
bool upAll(u32 buttons) const {
return (buttons & hold) == 0;
}
bool downTrigger(u32 buttons) const {
return buttons & trig;
}
bool upTrigger(u32 buttons) const {
return buttons & release;
}
const Vector3f &getAccel() const {
return mAccel;
return *reinterpret_cast<const Vector3f *>(&acc);
}
};
Vector2f getAccelVertical() {
return Vector2f(acc_vertical.x, acc_vertical.y);
}
eCoreDevType getDevType() const {
return static_cast<eCoreDevType>(dev_type);
}
bool isCore() const {
return getDevType() == cDEV_CORE || isFreestyle();
}
bool isFreestyle() const {
return getDevType() == cDEV_FREESTYLE;
}
s8 getDPDValidFlag() const {
return dpd_valid_fg;
}
f32 getFSStickX() const {
return ex_status.fs.stick.x;
}
f32 getFSStickY() const {
return ex_status.fs.stick.y;
}
u32 getFSStickButton();
};
/******************************************************************************
*
* CoreController
*
******************************************************************************/
class CoreController {
friend class CoreControllerMgr;
public:
CoreController();
// vtable 0x0000
/* vt 0x08 */ virtual void setPosParam(f32 f1, f32 f2) {
KPADSetPosParam(mChannelID, f1, f2);
@@ -116,86 +177,145 @@ public:
/* vt 0x14 */ virtual void setAccParam(f32 f1, f32 f2) {
KPADSetAccParam(mChannelID, f1, f2);
}
/* vt 0x18 */ virtual bool down(u32 mask) const {
return mCoreStatus[0].down(mask);
/* vt 0x18 */ virtual bool down(u32 buttons) const {
return mCoreStatus[0].down(buttons);
}
/* vt 0x1C */ virtual bool up(u32 mask) const {
return mCoreStatus[0].up(mask);
/* vt 0x1C */ virtual bool up(u32 buttons) const {
return mCoreStatus[0].up(buttons);
}
/* vt 0x20 */ virtual bool downTrigger(u32 mask) const {
return mCoreStatus[0].downTrigger(mask);
/* vt 0x20 */ virtual bool downTrigger(u32 buttons) const {
return mCoreStatus[0].downTrigger(buttons);
}
/* vt 0x24 */ virtual bool upTrigger(u32 mask) const {
return mCoreStatus[0].upTrigger(mask);
/* vt 0x24 */ virtual bool upTrigger(u32 buttons) const {
return mCoreStatus[0].upTrigger(buttons);
}
/* vt 0x28 */ virtual bool downAll(u32 mask) const {
return mCoreStatus[0].downAll(mask);
/* vt 0x28 */ virtual bool downAll(u32 buttons) const {
return mCoreStatus[0].downAll(buttons);
}
/* vt 0x2C */ virtual bool upAll(u32 mask) const {
return mCoreStatus[0].upAll(mask);
/* vt 0x2C */ virtual bool upAll(u32 buttons) const {
return mCoreStatus[0].upAll(buttons);
}
/* vt 0x30 */ virtual void beginFrame(PADStatus *padStatus);
/* vt 0x34 */ virtual void endFrame();
public:
/* 0x004 */ s32 mChannelID;
/* 0x008 */ u32 mButtonHeld;
/* 0x00C */ u32 mButtonTriggered;
/* 0x010 */ u32 mButtonReleased;
/* 0x014 */ u32 field_0x14;
/* 0x018 */ CoreStatus mCoreStatus[16];
/* 0xf18 */ int mReadStatusIdx;
/* 0xf1c */ TBitFlag<u8> mFlag;
/* 0xf20 */ Vector3f mAccel;
/* 0xf2c */ Vector2f mDpdPos;
/* 0xf34 */ u32 mIdleTime;
/* 0xf38 */ u32 mMotorPattern;
/* 0xf3c */ bool mEnableMotor;
/* 0xf40 */ s32 mMotorFrameDuration;
/* 0xf44 */ u8 mMotorPatternLength;
/* 0xf45 */ u8 mMotorPatternPos;
/* 0xf48 */ ControllerRumbleMgr *mRumbleMgr;
/* 0xf4c */ Matrix34f mPostureMatrix;
/* 0xf7c */ Matrix34f mPostureMatrixPrev;
/* 0xfac */ TBitFlag<u8> mAccelFlags; // May not be TBitFlag?
/* 0xfb0 */ s32 mMaxAccelFrameTime;
/* 0xfb4 */ s32 mAccelFrameTime[3];
/* 0xfc0 */ f32 mMaxAccelDiff;
/* 0xfc4 */ Vector3f mPrevAccel;
public:
CoreController();
void sceneReset();
Vector2f getDpdRawPos();
f32 getDpdDistance();
s32 getDpdValidFlag(); // Name Assumed. BBA hints at variable
void startMotor();
void stopMotor();
void createRumbleMgr(u8);
void startPatternRumble(const char *, int, bool);
void stopRumbleMgr();
CoreStatus *getCoreStatus(int idx);
void calc_posture_matrix(Matrix34f &mat, bool);
s32 getDpdValidFlag();
f32 getFreeStickX() const;
f32 getFreeStickY() const;
s32 getChannelID() const {
return mChannelID;
}
const Vector3f &getAccel() const {
return mCoreStatus[0].getAccel();
}
// Guess ?
bool isStable(u8 p1) const {
return (mAccelFlags.getDirect() & p1) == p1;
eCoreDevType getDevType() const {
return mCoreStatus[0].getDevType();
}
bool isCore() const {
return mCoreStatus[0].isCore();
}
bool isFreestyle() const {
return mCoreStatus[0].isFreestyle();
}
s32 getReadLength() const {
return mKPADReadLength;
}
bool isStable(u8 bits) const {
return (mStableFlags & bits) == bits;
}
void setStableFrame(int frame) {
mStableFrame = frame;
}
void setStableMag(f32 mag) {
mStableMag = mag;
}
void sceneReset();
void startMotor();
void stopMotor();
void createRumbleMgr(u8 overlap_num);
void startPatternRumble(const char *pPattern, int frame, bool force);
void startPowerFrameRumble(f32 power, int frame, bool force);
void stopRumbleMgr();
bool isConnected() const {
return mFlag.onBit(0);
}
CoreStatus *getCoreStatus(int idx);
CoreStatus *getCoreStatus() {
return mCoreStatus;
}
private:
enum StableAxis {
STABLE_AXIS_X,
STABLE_AXIS_Y,
STABLE_AXIS_Z,
STABLE_AXIS_MAX
};
enum StableFlag {
STABLE_FLAG_X = 1 << STABLE_AXIS_X,
STABLE_FLAG_Y = 1 << STABLE_AXIS_Y,
STABLE_FLAG_Z = 1 << STABLE_AXIS_Z,
STABLE_FLAG_XYZ = STABLE_FLAG_X | STABLE_FLAG_Y | STABLE_FLAG_Z
};
private:
void calc_posture_matrix(Matrix34f &rPostureMtx, bool checkStable);
private:
/* 0x004 */ s32 mChannelID;
/* 0x008 */ u32 mFSStickHold;
/* 0x00C */ u32 mFSStickTrig;
/* 0x010 */ u32 mFSStickRelease;
/* 0x014 */ u32 field_0x14;
/* 0x018 */ CoreStatus mCoreStatus[16];
/* 0xf18 */ int mKPADReadLength;
/* 0xf1c */ TBitFlag<u8> mFlag;
/* 0xf20 */ Vector3f mAccelPrev;
/* 0xf2c */ Vector2f mDpdPosPrev;
/* 0xf34 */ u32 mIdleTime;
/* 0xf38 */ u32 mSimpleRumblePattern;
/* 0xf3c */ bool mEnableSimpleRumble;
/* 0xf40 */ s32 mSimpleRumbleFrame;
/* 0xf44 */ u8 mSimpleRumbleSize;
/* 0xf45 */ u8 mSimpleRumbleIndex;
/* 0xf48 */ ControllerRumbleMgr *mRumbleMgr;
/* 0xf4c */ Matrix34f mPostureMatrix;
/* 0xf7c */ Matrix34f mPostureMatrixPrev;
/* 0xfac */ u8 mStableFlags; // May not be TBitFlag?
/* 0xfb0 */ s32 mStableFrame;
/* 0xfb4 */ s32 mStableTimer[3];
/* 0xfc0 */ f32 mStableMag;
/* 0xfc4 */ Vector3f mStableAccel;
};
/******************************************************************************
*
* CoreControllerMgr
*
******************************************************************************/
class CoreControllerMgr {
public:
struct T__Disposer : Disposer {
/* vt 0x08 */ virtual ~T__Disposer();
static T__Disposer *sStaticDisposer;
};
/* 0x0000 */ T__Disposer mDisposer;
EGG_SINGLETON_DECL(CoreControllerMgr);
struct UnkField0x10A0 {
virtual void v_08(UNKTYPE *);
@@ -206,81 +326,130 @@ public:
/* vt 0x08 */ virtual void beginFrame();
/* vt 0x0C */ virtual void endFrame();
public:
CoreController *getNthController(int index);
eCoreDevType getDevType(const int i) const {
return mDevTypes(i);
}
static void setConnectCallback(CoreControllerConnectCallback cb) {
sConnectCallback = cb;
}
private:
CoreControllerMgr();
static void *allocThunk(size_t size);
static int deleteThunk(void *ptr);
static void connectCallback(s32, s32);
private:
/* 0x0014 */ TBuffer<CoreController *> mControllers;
/* 0x0020 */ u8 field_0x20[0x10a0 - 0x0020];
/* 0x10A0 */ UnkField0x10A0 *field_0x10A0;
/* 0x10A4 */ TBuffer<eCoreDevType> mDevTypes;
/* 0x10b0 */ u8 field_0x10B0[0x10e0 - 0x10b0];
public:
static CoreControllerMgr *createInstance();
static void deleteInstance();
CoreController *getNthController(int);
static void *allocThunk(size_t size);
static int deleteThunk(void *ptr);
static void connectCallback(s32, s32);
CoreControllerMgr();
public:
static CoreControllerMgr *sInstance;
static CoreController *(*sCoreControllerFactory)();
static ConnectCallback sConnectCallback;
static CoreControllerFactory sCoreControllerFactory;
static CoreControllerConnectCallback sConnectCallback;
static bool sUseBuiltinWpadAllocator;
static s32 sWPADWorkSize;
};
/******************************************************************************
*
* NullController
*
******************************************************************************/
class NullController : public CoreController {
public:
NullController() {
unk[92] = 0xfe;
}
private:
// idk this has NO effect on anything
u8 unk[0x80674c00 - 0x80674b10];
};
/******************************************************************************
*
* ControllerRumbleUnit
*
******************************************************************************/
class ControllerRumbleUnit {
friend class ControllerRumbleMgr;
public:
// 0x00 vtable
inline ControllerRumbleUnit() : mFlag(0) {
ControllerRumbleUnit() : mFlags(0) {
init();
}
/* vt 0x08 */ virtual ~ControllerRumbleUnit() {}
public:
/* 0x04 */ const char *mPattern;
/* 0x08 */ const char *mPatternPos;
/* 0x0C */ s32 mTimer; // guess
/* 0x10 */ f32 mRampUp; // guess
/* 0x14 */ f32 mIntensity; // guess
/* 0x18 */ TBitFlag<u8> mFlag;
/* 0x1C */ nw4r::ut::Node mNode;
/* 0x24 */ u32 field_0x24; // could just be part of the node (List)
public:
void init();
void startPattern(const char *patter, int);
void startPattern(const char *pPattern, int frame);
f32 calc();
private:
enum {
BIT_USE_PATTERN,
BIT_USE_POWER,
BIT_POWER_LOOP,
BIT_ENABLED,
BIT_PATTERN_LOOP,
BIT_PATTERN_TIMER,
};
private:
void init();
void setFlags(u8 bit) {
mFlags.setBit(bit);
}
void clrFlags(u8 bit) {
mFlags.resetBit(bit);
}
bool tstFlags(u8 bit) {
return mFlags.onBit(bit);
}
private:
/* 0x04 */ const char *mRumblePattern;
/* 0x08 */ const char *mRumblePatternPtr;
/* 0x0C */ s32 mRumbleFrame;
/* 0x10 */ f32 mRumblePower;
/* 0x14 */ f32 mRumbleValue;
/* 0x18 */ TBitFlag<u8> mFlags;
/* 0x1C */ nw4r::ut::Node mNode;
/* 0x24 */ u32 field_0x24;
};
/******************************************************************************
*
* ControllerRumbleMgr
*
******************************************************************************/
class ControllerRumbleMgr {
public:
// 0x00 vtable
/* vt 0x08 */ virtual ~ControllerRumbleMgr() {}
public:
/* 0x04 */ nw4r::ut::List mActiveUnitList;
/* 0x10 */ nw4r::ut::List mInactiveUnitList;
/* 0x1C */ CoreController *mController;
public:
ControllerRumbleMgr();
void createUnit(u8 numUnits, CoreController *controller);
virtual ~ControllerRumbleMgr() {} // at 0x8
void createUnit(u8 overlap_num, CoreController *pController);
void stop();
void calc();
void startPattern(const char *pattern, int, bool);
private:
ControllerRumbleUnit *getUnitFromList(bool bGrabActive);
private:
/* 0x04 */ nw4r::ut::List mActiveUnitList;
/* 0x10 */ nw4r::ut::List mStoppedUnitList;
/* 0x1C */ CoreController *mController;
};
} // namespace EGG
include/egg/core/eggSingleton.h
+55
View File
@@ -0,0 +1,55 @@
#ifndef EGG_CORE_SINGLETON_H
#define EGG_CORE_SINGLETON_H
#include "egg/core/eggDisposer.h"
#include "egg/prim/eggAssert.h"
/**
* @brief Declares functions and data for a disposable singleton class
*/
#define EGG_SINGLETON_DECL(T) \
protected: \
class T__Disposer : public EGG::Disposer { \
public: \
virtual ~T__Disposer(); /* at 0x8 */ \
static T__Disposer *sStaticDisposer; \
}; \
\
T__Disposer mDisposer; \
\
public: \
static T *createInstance(); \
static void deleteInstance(); \
\
static T *instance() { \
return sInstance; \
} \
\
protected: \
static T *sInstance;
/**
* @brief Defines functions and data for a disposable singleton class
*/
#define EGG_SINGLETON_IMPL(T) \
T::T__Disposer::~T__Disposer() { \
T::deleteInstance(); \
} \
\
T *T::createInstance() { \
if (sInstance == NULL) { \
sInstance = new T(); \
} else { \
EGG_ASSERT_MSG(false, "Create Singleton Twice (%s) : addr %x\n", #T, sInstance); \
} \
\
return sInstance; \
} \
\
void T::deleteInstance() { \
sInstance = NULL; \
} \
\
T *T::sInstance = NULL;
#endif
include/egg/prim/eggAssert.h
+16 -1
View File
@@ -9,8 +9,23 @@ namespace EGG {
// TODO: Fixup funtions
namespace Assert {
typedef void (*AssertCallback)();
#if 1
#define EGG_ASSERT(EXP)
#define EGG_ASSERT_MSG(EXP, ...)
#define EGG_PRINT(...)
#else
#define EGG_ASSERT(EXP) \
if (!(EXP)) \
system_halt(__FILE__, __LINE__, #EXP)
#define EGG_ASSERT_MSG(EXP, ...) \
if (!(EXP)) \
system_halt(__FILE__, __LINE__, __VA_ARGS__)
#define EGG_PRINT(...) system_print(true, __FILE__, __VA_ARGS__)
#endif
typedef void (*AssertCallback)();
void wait(u32 time);
void system_vreport(const char *str, va_list list);
void system_report(const char *str, ...);
include/egg/prim/eggBuffer.h
+98 -38
View File
@@ -4,67 +4,127 @@
#include "common.h"
#include "egg/core/eggHeap.h"
namespace EGG {
template <typename T>
class TBuffer {
public:
// vtable 0x00
/* vt 0x08 */ virtual ~TBuffer() {
if (mBuffer != nullptr) {
delete[] mBuffer;
mBuffer = nullptr;
class iterator {
public:
iterator(TBuffer *pBuffer, int index) : mBuffer(pBuffer), mIndex(index) {}
int get_index() const {
return mIndex;
}
}
/* vt 0x0C */ virtual void allocate(int n, int);
/* vt 0x10 */ virtual void allocate(int n, Heap *heap, int);
/* vt 0x14 */ virtual void onAllocate(Heap *) {
return;
}
/* vt 0x18 */ virtual void errRangeOver() {
return;
}
iterator &operator++() {
mIndex++;
return *this;
}
T &operator*() {
return (*mBuffer)(mIndex);
}
friend bool operator==(const iterator &rLhs, const iterator &rRhs) {
return rLhs.mBuffer == rRhs.mBuffer && rLhs.mIndex == rRhs.mIndex;
}
friend bool operator!=(const iterator &rLhs, const iterator &rRhs) {
return !(rLhs == rRhs);
}
private:
TBuffer *mBuffer; // at 0x0
int mIndex; // at 0x4
};
public:
/* 0x08 */ s32 mSize;
/* 0x0C */ T *mBuffer;
TBuffer() : mSize(0), mBuffer(NULL) {}
public:
inline TBuffer() : mSize(0), mBuffer(nullptr) {}
virtual ~TBuffer() {
if (mBuffer == NULL) {
return;
}
inline bool isRangeValid(int i) {
return (i >= 0 && i < mSize);
delete[] mBuffer;
mBuffer = NULL;
} // at 0x8
virtual void allocate(int size, int align = 0); // at 0xC
virtual void allocate(int size, Heap *pHeap, int align = 0); // at 0x10
virtual void onAllocate(Heap * /* pHeap */) {} // at 0x14
virtual void errRangeOver() const {} // at 0x18
T &operator()(int i) {
checkRange(i);
return mBuffer[i];
}
inline void checkRange(int i) {
const T &operator()(int i) const {
checkRange(i);
return mBuffer[i];
}
T &get(int i) {
checkRange(i);
return mBuffer[i];
}
const T &get(int i) const {
checkRange(i);
return mBuffer[i];
}
int getSize() const {
return mSize;
}
int size() const {
return mSize;
}
iterator begin() {
return iterator(this, 0);
}
iterator end() {
return iterator(this, getSize());
}
private:
void flush() {}
void checkRange(int i) const {
if (!isRangeValid(i)) {
errRangeOver();
}
}
inline T &operator()(int i) {
checkRange(i);
return mBuffer[i];
}
inline s32 getSize() {
return mSize;
bool isRangeValid(int i) const {
return i >= 0 && i < mSize;
}
private:
int mSize; // at 0x4
T *mBuffer; // at 0x8
};
template <typename T>
void TBuffer<T>::allocate(int n, int) {
mSize = n;
mBuffer = new T[n];
void TBuffer<T>::allocate(int size, int) {
mSize = size;
mBuffer = new T[size];
onAllocate(nullptr);
}
template <typename T>
void TBuffer<T>::allocate(int n, Heap *heap, int) {
mSize = n;
if (heap == nullptr) {
heap = Heap::sCurrentHeap;
void TBuffer<T>::allocate(int size, Heap *pHeap, int) {
mSize = size;
if (pHeap == NULL) {
pHeap = Heap::getCurrentHeap();
}
mBuffer = new (heap, 4) T[mSize];
onAllocate(heap);
mBuffer = new (pHeap) T[mSize];
flush();
onAllocate(pHeap);
}
} // namespace EGG
include/m/m_pad.h
+32 -2
View File
@@ -10,10 +10,40 @@ extern int g_currentCoreId;
extern EGG::CoreController *g_currentCore;
extern EGG::CoreController *g_core[4];
enum Button {
BUTTON_LEFT = 0x1,
BUTTON_RIGHT = 0x2,
BUTTON_DOWN = 0x4,
BUTTON_UP = 0x8,
BUTTON_PLUS = 0x10,
BUTTON_2 = 0x100,
BUTTON_1 = 0x200,
BUTTON_B = 0x400,
BUTTON_A = 0x800,
BUTTON_MINUS = 0x1000,
BUTTON_Z = 0x2000,
BUTTON_C = 0x4000,
};
inline EGG::CoreController *getCore(int i) {
return g_core[i];
}
inline EGG::CoreController *getCore() {
return g_currentCore;
}
inline EGG::CoreControllerMgr *getMgr() {
return g_padMg;
}
inline int getCurrentCoreID() {
return g_currentCoreId;
}
// Defined in dPad, referenced in both mPad and dPad
extern "C" void async_info_callback(s32 chan, s32 result);
void create();
void beginPad();
void endPad();
} // namespace mPad
}; // namespace mPad
#endif
include/rvl/KPAD/KPAD.h
+104 -12
View File
@@ -1,27 +1,119 @@
#ifndef REVOSDK_KPAD_H
#define REVOSDK_KPAD_H
#ifdef __cplusplus
#include "common.h"
#include "rvl/WPAD/WPAD.h"
#include "rvl/MTX.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
// TODO
#define KPAD_MAX_SAMPLES 16
typedef union KPADEXStatus {
struct {
Vec2 stick; // at 0x0
Vec acc; // at 0x8
f32 acc_value; // at 0x14
f32 acc_speed; // at 0x18
} fs; // at 0x0
struct {
u32 hold; // at 0x0
u32 trig; // at 0x4
u32 release; // at 0x8
Vec2 lstick; // at 0xC
Vec2 rstick; // at 0x14
f32 ltrigger; // at 0x1C
f32 rtrigger; // at 0x20
} cl; // at 0x0
struct {
f64 tgc_weight; // at 0x0
f64 weight[4]; // at 0x8
f64 weight_ave[4]; // at 0x28
s32 weight_err; // at 0x48
s32 tgc_weight_err; // at 0x4C
} bl; // at 0x0
} KPADEXStatus;
typedef struct KPADStatus {
u32 hold; // at 0x0
u32 trig; // at 0x4
u32 release; // at 0x8
Vec acc; // at 0xC
f32 acc_value; // at 0x18
f32 acc_speed; // at 0x1C
Vec2 pos; // at 0x20
Vec2 vec; // at 0x28
f32 speed; // at 0x30
Vec2 horizon; // at 0x34
Vec2 hori_vec; // at 0x3C
f32 hori_speed; // at 0x44
f32 dist; // at 0x48
f32 dist_vec; // at 0x4C
f32 dist_speed; // at 0x50
Vec2 acc_vertical; // at 0x54
u8 dev_type; // at 0x5C
s8 wpad_err; // at 0x5D
s8 dpd_valid_fg; // at 0x5E
u8 data_format; // at 0x5F
KPADEXStatus ex_status; // at 0x60
u8 _0xB0[0xF0 - 0xB0]; // at 0xB0
} KPADStatus;
typedef void (*KPADConnectCallback)(s32, s32);
// TODO: Create Proper Headers
void KPADInitEx(void * /* UNKTYPE */, u32);
typedef struct KPADUnifiedWpadStatus {
union {
WPADStatus core;
WPADFSStatus fs;
WPADCLStatus cl;
WPADTRStatus tr;
WPADBLStatus bl;
} u; // at 0x0
u8 fmt; // 0x36;
u8 padding; // 0x37;
s32 KPADRead(s32 chan, UNKTYPE *status, s32);
s32 KPADReadEx(s32 chan, UNKTYPE *status, s32, s32 *);
} KPADUnifiedWpadStatus;
typedef void (*KPADConnectCallback)(s32, s32);
void KPADSetConnectCallback(u32, KPADConnectCallback);
void KPADSetPosParam(u32, f32, f32);
void KPADSetHoriParam(u32, f32, f32);
void KPADSetDistParam(u32, f32, f32);
void KPADSetAccParam(u32, f32, f32);
void KPADSetPosParam(s32 chan, f32 playRadius, f32 sensitivity);
void KPADSetHoriParam(s32 chan, f32 playRadius, f32 sensitivity);
void KPADSetDistParam(s32 chan, f32 playRadius, f32 sensitivity);
void KPADSetAccParam(s32 chan, f32 playRadius, f32 sensitivity);
s32 KPADRead(s32 chan, KPADStatus *pSamples, s32 numSamples);
s32 KPADReadEx(s32 chan, UNKTYPE *status, s32, s32 *);
void KPADGetUnifiedWpadStatus(s32 chan, KPADUnifiedWpadStatus *pStatus, int);
void KPADInit(void);
void KPADInitEx(void * /* UNKTYPE */, u32);
void KPADSetBtnRepeat(s32 chan, f32, f32);
void KPADSetReviseMode(s32 chan, s32);
void KPADEnableMpls(s32 chan, s32);
void KPADDisableMpls(s32 chan);
s32 KPADGetMplsWorkSize();
void KPADSetMplsWorkarea(void *);
void KPADSetControlMplsCallback(s32 chan, KPADConnectCallback cb);
void KPADResetMpls(s32 chan);
void KPADDisableMplsZeroPlay(s32 chan);
void KPADSetMplsZeroPlayParam(s32 chan, f32);
void KPADSetMplsZeroDriftMode(s32 chan, s32);
void KPADEnableMplsDirRevise(s32 chan);
void KPADDisableMplsDirRevise(s32 chan);
void KPADSetMplsDirReviseParam(s32 chan, f32);
void KPADEnableMplsAccRevise(s32 chan);
void KPADSetMplsAccReviseParam(s32 chan, f32, f32);
void KPADEnableMplsDpdRevise(s32 chan);
void KPADSetMplsDpdReviseParam(s32 chan, f32);
#ifdef __cplusplus
}
include/rvl/MTX/mtx.h
+17 -13
View File
@@ -20,26 +20,30 @@ typedef struct Vec {
f32 x, y, z;
} Vec;
typedef struct Vec2 {
f32 x, y;
} Vec2;
typedef struct Quaternion {
f32 x, y, z, w;
} Quaternion;
#define MTXIdentity PSMTXIdentity
#define MTXCopy PSMTXCopy
#define MTXConcat PSMTXConcat
#define MTXInverse PSMTXInverse
#define MTXTranspose PSMTXTranspose
#define MTXInverse PSMTXInverse
#define MTXInvXpose PSMTXInvXpose
#define MTXRotRad PSMTXRotRad
#define MTXRotTrig PSMTXRotTrig
#define MTXIdentity PSMTXIdentity
#define MTXCopy PSMTXCopy
#define MTXConcat PSMTXConcat
#define MTXInverse PSMTXInverse
#define MTXTranspose PSMTXTranspose
#define MTXInverse PSMTXInverse
#define MTXInvXpose PSMTXInvXpose
#define MTXRotRad PSMTXRotRad
#define MTXRotTrig PSMTXRotTrig
#define MTXRotAxisRad PSMTXRotAxisRad
#define MTXTrans PSMTXTrans
#define MTXTrans PSMTXTrans
#define MTXTransApply PSMTXTransApply
#define MTXScale PSMTXScale
#define MTXScale PSMTXScale
#define MTXScaleApply PSMTXScaleApply
#define MTXQuat PSMTXQuat
#define MTXReflect PSMTXReflect
#define MTXQuat PSMTXQuat
#define MTXReflect PSMTXReflect
void PSMTXIdentity(Mtx);
void PSMTXCopy(const Mtx, Mtx);
include/rvl/WPAD/WPAD.h
+18 -15
View File
@@ -8,7 +8,6 @@
#include "rvl/SC/scsystem.h"
#include "rvl/WPAD/WUD.h"
/*******************************************************************************
* macros
*/
@@ -31,13 +30,13 @@ typedef s32 WPADResult;
enum WPADResult_et {
WPAD_ERR_OK = 0,
WPAD_ERR_NO_CONTROLLER = -1, /* name known from asserts */
WPAD_ERR_BUSY = -2, // [RT3P54] has this as WPAD_ERR_BUSY
WPAD_ERR_TRANSFER = -3, // [RT3P54] has this as WPAD_ERR_TRANSFER
WPAD_ERR_INVALID = -4, /* name comes from [R89JEL] */
// WPAD_ERR_5 = -5, /* unknown */
// WPAD_ERR_6 = -6, /* unknown */
WPAD_ERR_CORRUPTED = -7, /* name comes from [R89JEL] */
WPAD_ERR_NO_CONTROLLER = -1, /* name known from asserts */
WPAD_ERR_BUSY = -2, // [RT3P54] has this as WPAD_ERR_BUSY
WPAD_ERR_TRANSFER = -3, // [RT3P54] has this as WPAD_ERR_TRANSFER
WPAD_ERR_INVALID = -4, /* name comes from [R89JEL] */
// WPAD_ERR_5 = -5, /* unknown */
// WPAD_ERR_6 = -6, /* unknown */
WPAD_ERR_CORRUPTED = -7, /* name comes from [R89JEL] */
#define WPAD_ESUCCESS WPAD_ERR_OK
#define WPAD_ENODEV WPAD_ERR_NO_CONTROLLER
@@ -86,7 +85,7 @@ enum WPADChannel_et {
typedef s32 WPADDeviceType;
enum WPADDeviceType_et {
WPAD_DEV_CORE = 0,
WPAD_DEV_FS = 1,
WPAD_DEV_FREESTYLE = 1,
WPAD_DEV_CLASSIC = 2, /* name known from asserts, but not value */
WPAD_DEV_BALANCE_CHECKER = 3,
WPAD_DEV_VSM = 4,
@@ -114,12 +113,11 @@ enum WPADDeviceType_et {
WPAD_DEV_MPLS_PT_UNKNOWN = 250,
WPAD_DEV_251 = 251,
WPAD_DEV_252 = 252, // invalid device mode?
WPAD_DEV_NONE =
253, // sort of like WPAD_ENODEV (see __wpadAbortInitExtension in WPADHIDParser.c)
// WPAD_DEV_254 = 254, /* unknown, doesn't seem to be used anywhere */
WPAD_DEV_INITIALIZING = 255, // see __a1_20_status_report
WPAD_DEV_FUTURE = 251,
WPAD_DEV_NOT_SUPPORTED = 252,
WPAD_DEV_NOT_FOUND = 253, // sort of like WPAD_ENODEV (see __wpadAbortInitExtension in WPADHIDParser.c)
WPAD_DEV_NULL = 254, /* unknown, doesn't seem to be used anywhere */
WPAD_DEV_UNKNOWN = 255, // see __a1_20_status_report
};
typedef u32 WPADDataFormat;
@@ -621,6 +619,11 @@ void WPADRecalibrate(WPADChannel chan);
BOOL WPADIsUsedCallbackByKPAD(void);
void WPADSetCallbackByKPAD(BOOL isKPAD);
void WPADSetAutoSleepTime(int min);
void WPADSetControllerLastDataUpdateTime(int min);
void WPADSetAcceptConnection(int);
#ifdef __cplusplus
}
#endif
include/toBeSorted/lyt_related_floats.h
-66
View File
@@ -1,66 +0,0 @@
#ifndef LYT_RELATED_FLOATS_H
#define LYT_RELATED_FLOATS_H
#include "common.h"
extern "C" f32 lbl_80575144;
inline f32 get_80575144() {
return lbl_80575144;
}
extern "C" f32 lbl_80575148;
inline f32 get_80575148() {
return lbl_80575148;
}
extern "C" f32 lbl_805751A4;
inline f32 get_805751A4() {
return lbl_805751A4;
}
extern "C" s32 lbl_80575134;
inline s32 get_80575134() {
return lbl_80575134;
}
extern "C" s32 lbl_80575118;
inline s32 get_80575118() {
return lbl_80575118;
}
extern "C" s32 lbl_8057511C;
inline s32 get_8057511C() {
return lbl_8057511C;
}
extern "C" f32 lbl_8057514C;
inline f32 get_8057514C() {
return lbl_8057514C;
}
extern "C" f32 lbl_80575150;
inline f32 get_80575150() {
return lbl_80575150;
}
extern "C" f32 lbl_8057515C;
inline f32 get_8057515C() {
return lbl_8057515C;
}
extern "C" f32 lbl_8057519C;
inline f32 get_8057519C() {
return lbl_8057519C;
}
extern "C" f32 lbl_80575190;
inline f32 get_80575190() {
return lbl_80575190;
}
extern "C" s32 lbl_80575184;
inline s32 get_80575184() {
return lbl_80575184;
}
#endif