From a5d1c8aa82dd979835e736611c5f5b66c01a20c2 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Sun, 12 Oct 2025 19:53:37 +0200 Subject: [PATCH 01/24] decompile RumbleData.cpp --- configure.py | 2 +- include/MarioUtil/RumbleType.hpp | 1 + src/MarioUtil/RumbleData.cpp | 313 +++++++++++++++++++++++++++++++ src/MarioUtil/RumbleType.cpp | 5 + 4 files changed, 320 insertions(+), 1 deletion(-) diff --git a/configure.py b/configure.py index 17361954..dd6ff9cc 100644 --- a/configure.py +++ b/configure.py @@ -795,7 +795,7 @@ def MatchingFor(*versions): Object(NonMatching, "MarioUtil/EffectUtil.cpp"), Object(NonMatching, "MarioUtil/ModelUtil.cpp"), Object(NonMatching, "MarioUtil/RumbleMgr.cpp"), - Object(NonMatching, "MarioUtil/RumbleData.cpp"), + Object(Matching, "MarioUtil/RumbleData.cpp"), Object(Matching, "MarioUtil/RumbleType.cpp"), Object(NonMatching, "MarioUtil/PacketUtil.cpp"), Object(Matching, "MarioUtil/GDUtil.cpp"), diff --git a/include/MarioUtil/RumbleType.hpp b/include/MarioUtil/RumbleType.hpp index eb610e48..7dff1dba 100644 --- a/include/MarioUtil/RumbleType.hpp +++ b/include/MarioUtil/RumbleType.hpp @@ -2,6 +2,7 @@ #define MARIO_UTIL_RUMBLE_TYPE_HPP class RumbleType { +public: float foo; static int getIndex(char* strIn); }; diff --git a/src/MarioUtil/RumbleData.cpp b/src/MarioUtil/RumbleData.cpp index e69de29b..c3a35d96 100644 --- a/src/MarioUtil/RumbleData.cpp +++ b/src/MarioUtil/RumbleData.cpp @@ -0,0 +1,313 @@ +// order is Point, Frame, Power +// point = sizeof(Frame) +// static_assert(sizeof(Frame) == sizeof(Power)) + +// also some of these are marked as static and some arent wtf???? + +// struct RumbleData_t { +// int* point; +// int* frame; +// int* power; +// }; + +#define MAX_RUMBLE_ID (25) + +static int rumblePoint_00 = 11; +static int rumbleFrame_00[] = { + 0x00000000, 0x3D4CCCCD, 0x3DCCCCCD, 0x3E19999A, 0x3E4CCCCD, 0x3E800000, + 0x3E800000, 0x3EA8F5C3, 0x3ECCCCCD, 0x3F000000, 0x3F19999A, +}; +static int rumblePower_00[] = { + 0x3F800000, 0x3F800000, 0x3F800000, 0x3F666666, 0x00000000, 0x00000000, + 0x3F19999A, 0x3F19999A, 0x3F000000, 0x3E4CCCCD, 0x00000000, +}; + +static int rumblePoint_01 = 24; +static int rumbleFrame_01[] = { + 0x00000000, 0x3E23D70A, 0x3E428F5C, 0x3E75C28F, 0x3E851EB8, 0x3EBD70A4, + 0x3ECCCCCD, 0x3EE66666, 0x3EEB851F, 0x3F0A3D71, 0x3F0F5C29, 0x3F1C28F6, + 0x3F1EB852, 0x3F333333, 0x3F3AE148, 0x3F47AE14, 0x3F4A3D71, 0x3F5C28F6, + 0x3F6B851F, 0x3F75C28F, 0x3F83D70A, 0x3F90A3D7, 0x3F95C28F, 0x3FB33333, +}; +static int rumblePower_01[] = { + 0x3F800000, 0x3F800000, 0x00000000, 0x00000000, 0x3F733333, 0x3F59999A, + 0x00000000, 0x00000000, 0x3F4CCCCD, 0x3F3AE148, 0x00000000, 0x00000000, + 0x3F23D70A, 0x3F07AE14, 0x00000000, 0x00000000, 0x3EE147AE, 0x3EB33333, + 0x00000000, 0x3E8A3D71, 0x3CA3D70A, 0x3E23D70A, 0x3C23D70A, 0x00000000, +}; + +static int rumblePoint_02 = 2; +static int rumbleFrame_02[] = { + 0x00000000, + 0x3DCCCCCD, +}; +static int rumblePower_02[] = { + 0x3F4CCCCD, + 0x3F19999A, +}; + +static int rumblePoint_03 = 2; +static int rumbleFrame_03[] = { + 0x00000000, + 0x3DCCCCCD, +}; +static int rumblePower_03[] = { + 0x3F800000, + 0x3F800000, +}; + +static int rumblePoint_04 = 7; +static int rumbleFrame_04[] = { + 0x00000000, 0x3DCCCCCD, 0x3E19999A, 0x3E4CCCCD, + 0x3E800000, 0x3E99999A, 0x3F000000, +}; +static int rumblePower_04[] = { + 0x3F800000, 0x3F800000, 0x00000000, 0x3F4CCCCD, + 0x3F4CCCCD, 0x00000000, 0x00000000, +}; + +static int rumblePoint_05 = 21; +static int rumbleFrame_05[] = { + 0x00000000, 0x3E3851EC, 0x3E570A3D, 0x3E8F5C29, 0x3E8F5C29, 0x3ECCCCCD, + 0x3EE66666, 0x3F028F5C, 0x3F051EB8, 0x3F23D70A, 0x3F30A3D7, 0x3F400000, + 0x3F547AE1, 0x3F63D70A, 0x3F7D70A4, 0x3F83D70A, 0x3F8F5C29, 0x3F9851EC, + 0x3FA00000, 0x3FA66666, 0x3FB33333, +}; +static int rumblePower_05[] = { + 0x3F800000, 0x3F6B851F, 0x00000000, 0x00000000, 0x3F4A3D71, 0x3F2147AE, + 0x00000000, 0x3CA3D70A, 0x3EE66666, 0x3E9EB852, 0x3CA3D70A, 0x3E75C28F, + 0x3CF5C28F, 0x3E3851EC, 0x3D23D70A, 0x3E051EB8, 0x3D23D70A, 0x3DCCCCCD, + 0x3D23D70A, 0x3D75C28F, 0x00000000, +}; + +static int rumblePoint_06 = 10; +static int rumbleFrame_06[] = { + 0x00000000, 0x3DB851EC, 0x3DB851EC, 0x3DCCCCCD, 0x3E2E147B, + 0x3E2E147B, 0x3E3851EC, 0x3E851EB8, 0x3E851EB8, 0x3F000000, +}; +static int rumblePower_06[] = { + 0x3F59999A, 0x3F59999A, 0x3DCCCCCD, 0x3EE66666, 0x3EE66666, + 0x3D4CCCCD, 0x3E800000, 0x3E800000, 0x3C23D70A, 0x00000000, +}; + +static int rumblePoint_07 = 20; +static int rumbleFrame_07[] = { + 0x00000000, 0x3DE147AE, 0x3DF5C28F, 0x3E051EB8, 0x3E4CCCCD, + 0x3E570A3D, 0x3E947AE1, 0x3E9EB852, 0x3EA8F5C3, 0x3ED1EB85, + 0x3ED70A3D, 0x3F051EB8, 0x3F07AE14, 0x3F0A3D71, 0x3F1EB852, + 0x3F23D70A, 0x3F3851EC, 0x3F3D70A4, 0x3F400000, 0x3F800000, +}; +static int rumblePower_07[] = { + 0x3F733333, 0x3F7851EC, 0x3F59999A, 0x00000000, 0x00000000, + 0x3F400000, 0x3F3AE148, 0x3F0CCCCD, 0x00000000, 0x00000000, + 0x3F19999A, 0x3F2147AE, 0x3EA3D70A, 0x00000000, 0x00000000, + 0x3F028F5C, 0x3EF5C28F, 0x3E428F5C, 0x3CA3D70A, 0x00000000, +}; + +static int rumblePoint_08 = 4; +static int rumbleFrame_08[] = { + 0x00000000, 0x3E99999A, 0x3F000000, 0x3F333333, 0x3F800000, +}; +static int rumblePower_08[] = { + 0x3F800000, 0x3F000000, 0x3EB33333, 0x3F000000, 0x3F800000, +}; + +static int rumblePoint_09 = 4; +static int rumbleFrame_09[] = { + 0x00000000, + 0x3E99999A, + 0x3F000000, + 0x3F333333, +}; +static int rumblePower_09[] = { + 0x3F000000, + 0x3E75C28F, + 0x3E3851EC, + 0x3E6B851F, +}; + +static int rumblePoint_10 = 1; +static int rumbleFrame_10[] = { + 0x00000000, +}; +static int rumblePower_10[] = { + 0x00000000, +}; + +static int rumblePoint_11 = 1; +static int rumbleFrame_11[] = { + 0x00000000, +}; +static int rumblePower_11[] = { + 0x00000000, +}; + +static int rumblePoint_12 = 1; +static int rumbleFrame_12[] = { + 0x00000000, +}; +static int rumblePower_12[] = { + 0x00000000, +}; + +static int rumblePoint_13 = 1; +static int rumbleFrame_13[] = { + 0x00000000, +}; +static int rumblePower_13[] = { + 0x00000000, +}; + +static int rumblePoint_14 = 1; +static int rumbleFrame_14[] = { + 0x00000000, +}; +static int rumblePower_14[] = { + 0x00000000, +}; + +static int rumblePoint_15 = 1; +static int rumbleFrame_15[] = { + 0x00000000, +}; +static int rumblePower_15[] = { + 0x00000000, +}; + +static int rumblePoint_16 = 1; +static int rumbleFrame_16[] = { + 0x00000000, +}; +static int rumblePower_16[] = { + 0x00000000, +}; + +static int rumblePoint_17 = 1; +static int rumbleFrame_17[] = { + 0x00000000, +}; +static int rumblePower_17[] = { + 0x00000000, +}; + +static int rumblePoint_18 = 1; +static int rumbleFrame_18[] = { + 0x00000000, +}; +static int rumblePower_18[] = { + 0x00000000, +}; + +static int rumblePoint_19 = 5; +static int rumbleFrame_19[] = { + 0x00000000, 0x3DE147AE, 0x3E4CCCCD, 0x3EA3D70A, 0x3ECCCCCD, +}; +static int rumblePower_19[] = { + 0x3F19999A, 0x3ECCCCCD, 0x3F19999A, 0x3ECCCCCD, 0x3F19999A, +}; + +static int rumblePoint_20 = 2; +static int rumbleFrame_20[] = { + 0x00000000, + 0x3C888889, +}; +static int rumblePower_20[] = { + 0x3F000000, + 0x3F000000, +}; + +static int rumblePoint_21 = 2; +static int rumbleFrame_21[] = { + 0x00000000, + 0x3C888889, +}; +static int rumblePower_21[] = { + 0x3F400000, + 0x3F400000, +}; + +static int rumblePoint_22 = 2; +static int rumbleFrame_22[] = { + 0x00000000, + 0x40000000, +}; +static int rumblePower_22[] = { + 0x3F400000, + 0x3F400000, +}; + +static int rumblePoint_23 = 77; +static int rumbleFrame_23[] = { + 0x00000000, 0x3D8F5C29, 0x3E051EB8, 0x3E800000, 0x3E851EB8, 0x3F828F5C, + 0x3F83D70A, 0x3F91EB85, 0x3F91EB85, 0x3F99999A, 0x3F9AE148, 0x3FA51EB8, + 0x3FAA3D71, 0x40700000, 0x4073D70A, 0x407AE148, 0x407C28F6, 0x40800000, + 0x40851EB8, 0x408570A4, 0x408B851F, 0x408CCCCD, 0x408E147B, 0x408E147B, + 0x40928F5C, 0x4096147B, 0x40A51EB8, 0x40A5C28F, 0x40A8F5C3, 0x40AA3D71, + 0x40ACCCCD, 0x40AD1EB8, 0x40B0A3D7, 0x40B1EB85, 0x40B28F5C, 0x40B51EB8, + 0x40B5C28F, 0x40CB3333, 0x40CB851F, 0x40D23D71, 0x40D5C28F, 0x40DB3333, + 0x40DC28F6, 0x40E3851F, 0x40E5C28F, 0x40F00000, 0x40F51EB8, 0x410170A4, + 0x410AB852, 0x411147AE, 0x4111999A, 0x411A147B, 0x411A3D71, 0x411A6666, + 0x411CF5C3, 0x411D70A4, 0x411E3D71, 0x411E8F5C, 0x412051EC, 0x4120A3D7, + 0x4120CCCD, 0x4120F5C3, 0x41230A3D, 0x41235C29, 0x4123851F, 0x4123AE14, + 0x4125999A, 0x4126147B, 0x4126E148, 0x41273333, 0x412828F6, 0x41291EB8, + 0x4129C28F, 0x412AE148, 0x412C7AE1, 0x412D1EB8, 0x41300000, +}; +static int rumblePower_23[] = { + 0x3F4CCCCD, 0x3F800000, 0x3F733333, 0x3F4CCCCD, 0x00000000, 0x00000000, + 0x3F733333, 0x3F733333, 0x3ED1EB85, 0x3EE147AE, 0x3F3851EC, 0x3F147AE1, + 0x00000000, 0x00000000, 0x3F4F5C29, 0x3F666666, 0x3F30A3D7, 0x00000000, + 0x00000000, 0x3F7AE148, 0x3F733333, 0x3F07AE14, 0x3F000000, 0x3F5EB852, + 0x3F333333, 0x00000000, 0x00000000, 0x3F5EB852, 0x3F570A3D, 0x3EA3D70A, + 0x3E8A3D71, 0x3F30A3D7, 0x3F0CCCCD, 0x00000000, 0x3EAE147B, 0x3E8A3D71, + 0x00000000, 0x00000000, 0x3F47AE14, 0x3F35C28F, 0x00000000, 0x00000000, + 0x3F47AE14, 0x3F2E147B, 0x00000000, 0x00000000, 0x3ED70A3D, 0x3F3851EC, + 0x3F5EB852, 0x3F800000, 0x00000000, 0x00000000, 0x3F800000, 0x3F800000, + 0x3F800000, 0x00000000, 0x00000000, 0x3F733333, 0x3F59999A, 0x00000000, + 0x00000000, 0x3F4CCCCD, 0x3F3AE148, 0x00000000, 0x00000000, 0x3F23D70A, + 0x3F07AE14, 0x00000000, 0x00000000, 0x3EE147AE, 0x3EB33333, 0x00000000, + 0x3E8A3D71, 0x3CA3D70A, 0x3E23D70A, 0x3C23D70A, 0x00000000, +}; + +static int rumblePoint_24 = 37; +static int rumbleFrame_24[] = { + 0x00000000, 0x3D8F5C29, 0x3E051EB8, 0x3E800000, 0x3E851EB8, 0x3F828F5C, + 0x3F83D70A, 0x3F91EB85, 0x3F91EB85, 0x3F99999A, 0x3F9AE148, 0x3FA51EB8, + 0x3FAA3D71, 0x40700000, 0x4073D70A, 0x407AE148, 0x407C28F6, 0x40800000, + 0x40851EB8, 0x408570A4, 0x408B851F, 0x408CCCCD, 0x408E147B, 0x408E147B, + 0x40928F5C, 0x4096147B, 0x40A51EB8, 0x40A5C28F, 0x40A8F5C3, 0x40AA3D71, + 0x40ACCCCD, 0x40AD1EB8, 0x40B0A3D7, 0x40B1EB85, 0x40B28F5C, 0x40B51EB8, + 0x40B5C28F, +}; +static int rumblePower_24[] = { + 0x3F4CCCCD, 0x3F800000, 0x3F733333, 0x3F4CCCCD, 0x00000000, 0x00000000, + 0x3F733333, 0x3F733333, 0x3ED1EB85, 0x3EE147AE, 0x3F3851EC, 0x3F147AE1, + 0x00000000, 0x00000000, 0x3F4F5C29, 0x3F666666, 0x3F30A3D7, 0x00000000, + 0x00000000, 0x3F7AE148, 0x3F733333, 0x3F07AE14, 0x3F000000, 0x3F5EB852, + 0x3F333333, 0x00000000, 0x00000000, 0x3F5EB852, 0x3F570A3D, 0x3EA3D70A, + 0x3E8A3D71, 0x3F30A3D7, 0x3F0CCCCD, 0x00000000, 0x3EAE147B, 0x3E8A3D71, + 0x00000000, +}; + +const int* channelDataTbl[] = { + &rumblePoint_00, rumbleFrame_00, rumblePower_00, &rumblePoint_01, + rumbleFrame_01, rumblePower_01, &rumblePoint_02, rumbleFrame_02, + rumblePower_02, &rumblePoint_03, rumbleFrame_03, rumblePower_03, + &rumblePoint_04, rumbleFrame_04, rumblePower_04, &rumblePoint_05, + rumbleFrame_05, rumblePower_05, &rumblePoint_06, rumbleFrame_06, + rumblePower_06, &rumblePoint_07, rumbleFrame_07, rumblePower_07, + &rumblePoint_08, rumbleFrame_08, rumblePower_08, &rumblePoint_09, + rumbleFrame_09, rumblePower_09, &rumblePoint_10, rumbleFrame_10, + rumblePower_10, &rumblePoint_11, rumbleFrame_11, rumblePower_11, + &rumblePoint_12, rumbleFrame_12, rumblePower_12, &rumblePoint_13, + rumbleFrame_13, rumblePower_13, &rumblePoint_14, rumbleFrame_14, + rumblePower_14, &rumblePoint_15, rumbleFrame_15, rumblePower_15, + &rumblePoint_16, rumbleFrame_16, rumblePower_16, &rumblePoint_17, + rumbleFrame_17, rumblePower_17, &rumblePoint_18, rumbleFrame_18, + rumblePower_18, &rumblePoint_19, rumbleFrame_19, rumblePower_19, + &rumblePoint_20, rumbleFrame_20, rumblePower_20, &rumblePoint_21, + rumbleFrame_21, rumblePower_21, &rumblePoint_22, rumbleFrame_22, + rumblePower_22, &rumblePoint_23, rumbleFrame_23, rumblePower_23, + &rumblePoint_24, rumbleFrame_24, rumblePower_24, +}; + +int channelNum = MAX_RUMBLE_ID; diff --git a/src/MarioUtil/RumbleType.cpp b/src/MarioUtil/RumbleType.cpp index 7691718e..8a172521 100644 --- a/src/MarioUtil/RumbleType.cpp +++ b/src/MarioUtil/RumbleType.cpp @@ -1,5 +1,6 @@ #include #include +#include extern int channelNum; @@ -44,5 +45,9 @@ int RumbleType::getIndex(char* strIn) return _info[i].unk0; } } + ASSERTMSGLINE( + __LINE__, -1, + "Invalid RumbleType"); // this feels more correct but the string is + // getting omitted by the preprocessor return -1; } From 4cd6afa5c0954d2f7767a4e28eed2ea9c30b4362 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Sun, 12 Oct 2025 19:54:26 +0200 Subject: [PATCH 02/24] decompile Koga::ToolData --- configure.py | 2 +- include/MarioUtil/ToolData.hpp | 112 +++++++++++++++++++++++++++++++++ src/MarioUtil/ToolData.cpp | 34 ++++++++++ 3 files changed, 147 insertions(+), 1 deletion(-) create mode 100644 include/MarioUtil/ToolData.hpp diff --git a/configure.py b/configure.py index dd6ff9cc..48dd6e79 100644 --- a/configure.py +++ b/configure.py @@ -801,7 +801,7 @@ def MatchingFor(*versions): Object(Matching, "MarioUtil/GDUtil.cpp"), Object(Matching, "MarioUtil/TexUtil.cpp"), Object(Matching, "MarioUtil/MapUtil.cpp"), - Object(NonMatching, "MarioUtil/ToolData.cpp"), + Object(Matching, "MarioUtil/ToolData.cpp"), ], }, { diff --git a/include/MarioUtil/ToolData.hpp b/include/MarioUtil/ToolData.hpp new file mode 100644 index 00000000..dfa14a8d --- /dev/null +++ b/include/MarioUtil/ToolData.hpp @@ -0,0 +1,112 @@ +#ifndef MARIO_UTIL_TOOL_DATA_HPP +#define MARIO_UTIL_TOOL_DATA_HPP +#include + +namespace Koga { +/** + * @brief ToolData is a class that reads BCSV data. Usage is as follows: + * Create a ToolData instance, fetch the BCSV data from disk and attach it. + * One can then call GetValue to retrieve data from the file. + * + * The structures and parsing logic are based off the Mario Galaxy decomp's + * handling of JMap files + */ +class ToolData { +public: + ToolData(); + virtual ~ToolData(); // if not explicitly defined its not generated ok + BOOL Attach(const void* bcsvFileData); + // returns TRUE if the value was found, otherwise FALSE + BOOL GetValue(int entryIndex, const char* key, long& pValueOut) const; + // returns TRUE if the value was found, otherwise FALSE + BOOL GetValue(int entryIndex, const char* key, + const char*& pValueOut) const; + + inline bool dataExists() const { return !!mData; } + +private: +// JMAP value types, ignored in sunshine +#define JMAP_VALUE_TYPE_LONG 0 +#define JMAP_VALUE_TYPE_STRING 1 +#define JMAP_VALUE_TYPE_FLOAT 2 +#define JMAP_VALUE_TYPE_LONG_2 3 +#define JMAP_VALUE_TYPE_SHORT 4 +#define JMAP_VALUE_TYPE_BYTE 5 +#define JMAP_VALUE_TYPE_STRING_PTR 6 +#define JMAP_VALUE_TYPE_NULL 7 + + struct JMapItem { + u32 mHash; // 0x0 + u32 mMask; // 0x4 + u16 mOffsData; // 0x8 + u8 mShift; // 0xA + u8 mType; // 0xB + }; + + struct JMapData { + s32 mNumEntries; // 0x0 + s32 mNumFields; // 0x4 + s32 mDataOffset; // 0x8 + u32 mEntrySize; // 0xC + const JMapItem mItems[]; // 0x10 + }; + + inline u32 hashString(const char* key) const + { + u32 stringHash = 0; + char current_char; + + while ((current_char = *key) != 0) { + key++; + stringHash = (current_char + (stringHash << 8)) % 0x1FFFFD9; + } + return stringHash; + } + + inline s32 searchItemInfo(const char* pKey) const + { + s32 nFields = mData->mNumFields; + u32 hash = hashString(pKey); + + for (int i = 0; i < nFields; ++i) { + if (hash == mData->mItems[i].mHash) { + return i; + } + } + + return -1; + } + + inline const char* getEntryAddress(const JMapData* pData, + const s32 dataOffset, + const int entryIndex) const + { + return reinterpret_cast(pData) + dataOffset + + entryIndex * pData->mEntrySize; + } + + inline BOOL getValue(const int entryIndex, const int itemIndex, + s32* pValueOut) const + { + const JMapItem* item = &mData->mItems[itemIndex]; + const char* valuePtr + = getEntryAddress(mData, mData->mDataOffset, entryIndex) + + item->mOffsData; + *pValueOut = *reinterpret_cast(valuePtr); + return TRUE; + } + + inline BOOL getValue(const int entryIndex, const int itemIndex, + const char** pValueOut) const + { + const JMapItem* item = &mData->mItems[itemIndex]; + *pValueOut = getEntryAddress(mData, mData->mDataOffset, entryIndex) + + item->mOffsData; + return TRUE; + } + +public: + const JMapData* mData; +}; +} // namespace Koga +#endif diff --git a/src/MarioUtil/ToolData.cpp b/src/MarioUtil/ToolData.cpp index e69de29b..8e3fd04c 100644 --- a/src/MarioUtil/ToolData.cpp +++ b/src/MarioUtil/ToolData.cpp @@ -0,0 +1,34 @@ +#include +#include + +namespace Koga { +ToolData::ToolData() { mData = nullptr; } +ToolData::~ToolData() { } + +BOOL ToolData::Attach(const void* jmapData) +{ + if (!jmapData) + return FALSE; + this->mData = (JMapData*)jmapData; + return TRUE; +} + +BOOL ToolData::GetValue(int entryIndex, const char* key, long& pValueOut) const +{ + s32 itemIndex = searchItemInfo(key); + if (itemIndex < 0) { + return FALSE; + } + return getValue(entryIndex, itemIndex, &pValueOut); +} + +BOOL ToolData::GetValue(int entryIndex, const char* key, + const char*& pValueOut) const +{ + s32 itemIndex = searchItemInfo(key); + if (itemIndex < 0) { + return FALSE; + } + return getValue(entryIndex, itemIndex, &pValueOut); +} +} // namespace Koga From a2151229a7427dca21287e07ce2c1b20ee23ab3f Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Mon, 13 Oct 2025 00:51:30 +0200 Subject: [PATCH 03/24] mostly decompile MovieRumble --- include/GC2D/MovieRumble.hpp | 51 ++++++++++++++++++++++++++++++ src/GC2D/MovieRumble.cpp | 61 ++++++++++++++++++++++++++++++++++++ 2 files changed, 112 insertions(+) create mode 100644 include/GC2D/MovieRumble.hpp diff --git a/include/GC2D/MovieRumble.hpp b/include/GC2D/MovieRumble.hpp new file mode 100644 index 00000000..4c54989d --- /dev/null +++ b/include/GC2D/MovieRumble.hpp @@ -0,0 +1,51 @@ +#ifndef GC2D_MOVIE_RUMBLE_HPP +#define GC2D_MOVIE_RUMBLE_HPP + +#include +#include +#include +#include + +class TMovieRumble : public JDrama::TViewObj { +public: + TMovieRumble(const TTHPRender* thpRender); + virtual ~TMovieRumble(); + void init(const char* subtitleName); + virtual void perform(u32 flags, JDrama::TGraphics* graphics); + void checkRumbleOff(); + +private: + inline void updateRumbleState(Koga::ToolData* bcsvData, s32 entryOffset) + { + const char* rumbleTypeString; + + int nextEntryIndex = entryIndex + entryOffset; + bool dataAndIndexValid = (bcsvData != nullptr) && (nextEntryIndex >= 0); + + // this if statement feels wrong + if (dataAndIndexValid + && (nextEntryIndex < bcsvData->mData->mNumEntries)) { + // get this rumble entry's data, and update this instance + bcsvData->GetValue(nextEntryIndex, "start_frame", startFrame); + bcsvData->GetValue(nextEntryIndex, "end_frame", endFrame); + bcsvData->GetValue(nextEntryIndex, "type", rumbleTypeString); + rumbleTypeIndex = RumbleType::getIndex((char*)rumbleTypeString); + } else { + rumbleTypeIndex = -1; + } + + isRumbleActive = false; + } + +public: + const TTHPRender* thpRenderer; + Koga::ToolData* toolData; // this is supposedly the only usage of tooldata + // in the entire game lmao + int entryIndex; + int startFrame; + int endFrame; + int rumbleTypeIndex; + bool isRumbleActive; +}; + +#endif // GC2D_MOVIE_RUMBLE_HPP diff --git a/src/GC2D/MovieRumble.cpp b/src/GC2D/MovieRumble.cpp index e69de29b..09e03cce 100644 --- a/src/GC2D/MovieRumble.cpp +++ b/src/GC2D/MovieRumble.cpp @@ -0,0 +1,61 @@ +#include +#include +#include +#include +#include + +TMovieRumble::TMovieRumble(const TTHPRender* thpRender) +{ + thpRenderer = thpRender; +} + +void TMovieRumble::init(const char* subtitleName) +{ + char* szSubtitlePathExtension; + char szSubtitlePath[128]; + sprintf(szSubtitlePath, "/subtitle/rnbl/%s", subtitleName); + szSubtitlePathExtension = (char*)strrchr(szSubtitlePath, 46); + strcpy(szSubtitlePathExtension, ".bcr"); + + Koga::ToolData* data = new Koga::ToolData; + toolData = data; + void* glbResource = JKRFileLoader::getGlbResource(szSubtitlePath); + toolData->Attach(glbResource); + + if (toolData->dataExists()) + entryIndex = 0; + else + entryIndex = -1; + + updateRumbleState(toolData, 0); +} + +void TMovieRumble::perform(u32 flags, JDrama::TGraphics* graphics) +{ + if ((flags & 1) != 0) { + if (isRumbleActive) { + checkRumbleOff(); + } else { + if (rumbleTypeIndex != -1 + && startFrame <= thpRenderer->frameNumber) { + SMSRumbleMgr->start(rumbleTypeIndex, -1, (float*)0); + isRumbleActive = true; + } + } + } +} + +#pragma dont_inline on +void TMovieRumble::checkRumbleOff() +{ + if (rumbleTypeIndex != -1) { + if (endFrame <= thpRenderer->frameNumber) { + SMSRumbleMgr->stop(); + entryIndex++; + updateRumbleState(toolData, 0); + } + } +} +#pragma dont_inline off + +TMovieRumble::~TMovieRumble() { } From 7d4cd6b6cf5d265ca88ede19ce54944447e271ba Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Mon, 13 Oct 2025 00:51:44 +0200 Subject: [PATCH 04/24] correct type --- include/System/THPRender.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/System/THPRender.hpp b/include/System/THPRender.hpp index 0f2d02c9..3c5d17a2 100644 --- a/include/System/THPRender.hpp +++ b/include/System/THPRender.hpp @@ -17,7 +17,7 @@ class TTHPRender : public JDrama::TViewObj { /* 0x14 */ u32 y; /* 0x18 */ u32 polyW; /* 0x1c */ u32 polyH; - /* 0x20 */ u32 frameNumber; + /* 0x20 */ s32 frameNumber; }; #endif // SYSTEM_THP_RENDER_HPP From 1d26c8b1d86cb157f4b761c09e80546fe6899ac7 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Fri, 17 Oct 2025 02:21:00 +0200 Subject: [PATCH 05/24] fix missing category in M3DUtil and System --- configure.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/configure.py b/configure.py index 48dd6e79..4320904d 100644 --- a/configure.py +++ b/configure.py @@ -808,6 +808,7 @@ def MatchingFor(*versions): "lib": "M3DUtil", "mw_version": "GC/1.2.5", "cflags": [*cflags_system, "-inline deferred"], + "progress_category": "game", "objects": [ Object(NonMatching, "M3DUtil/M3UJoint.cpp"), Object(NonMatching, "M3DUtil/M3UModel.cpp"), @@ -826,6 +827,7 @@ def MatchingFor(*versions): "lib": "System", "mw_version": "GC/1.2.5", "cflags": cflags_system, + "progress_category": "game", "objects": [ Object(Matching, "System/BaseParam.cpp"), Object(NonMatching, "System/EmitterViewObj.cpp"), From 29c4d6c50cb12e7ab2f1d869c2c95605da47756c Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Fri, 17 Oct 2025 12:03:00 +0200 Subject: [PATCH 06/24] minor fixes --- include/MarioUtil/ToolData.hpp | 2 +- src/MarioUtil/RumbleData.cpp | 2 -- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/include/MarioUtil/ToolData.hpp b/include/MarioUtil/ToolData.hpp index dfa14a8d..a30b6313 100644 --- a/include/MarioUtil/ToolData.hpp +++ b/include/MarioUtil/ToolData.hpp @@ -24,7 +24,6 @@ class ToolData { inline bool dataExists() const { return !!mData; } -private: // JMAP value types, ignored in sunshine #define JMAP_VALUE_TYPE_LONG 0 #define JMAP_VALUE_TYPE_STRING 1 @@ -50,6 +49,7 @@ class ToolData { u32 mEntrySize; // 0xC const JMapItem mItems[]; // 0x10 }; +private: inline u32 hashString(const char* key) const { diff --git a/src/MarioUtil/RumbleData.cpp b/src/MarioUtil/RumbleData.cpp index c3a35d96..9b253434 100644 --- a/src/MarioUtil/RumbleData.cpp +++ b/src/MarioUtil/RumbleData.cpp @@ -2,8 +2,6 @@ // point = sizeof(Frame) // static_assert(sizeof(Frame) == sizeof(Power)) -// also some of these are marked as static and some arent wtf???? - // struct RumbleData_t { // int* point; // int* frame; From 7cd1b2c0ba8f1094086d3b6fc24d198eb0db9e4d Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Fri, 17 Oct 2025 12:03:25 +0200 Subject: [PATCH 07/24] 99% accuracy (stack mismatches afaik) --- include/GC2D/MovieRumble.hpp | 31 ++++-------------------- src/GC2D/MovieRumble.cpp | 46 ++++++++++++++++++++++++++++++++---- 2 files changed, 45 insertions(+), 32 deletions(-) diff --git a/include/GC2D/MovieRumble.hpp b/include/GC2D/MovieRumble.hpp index 4c54989d..e3609449 100644 --- a/include/GC2D/MovieRumble.hpp +++ b/include/GC2D/MovieRumble.hpp @@ -14,37 +14,14 @@ class TMovieRumble : public JDrama::TViewObj { virtual void perform(u32 flags, JDrama::TGraphics* graphics); void checkRumbleOff(); -private: - inline void updateRumbleState(Koga::ToolData* bcsvData, s32 entryOffset) - { - const char* rumbleTypeString; - - int nextEntryIndex = entryIndex + entryOffset; - bool dataAndIndexValid = (bcsvData != nullptr) && (nextEntryIndex >= 0); - - // this if statement feels wrong - if (dataAndIndexValid - && (nextEntryIndex < bcsvData->mData->mNumEntries)) { - // get this rumble entry's data, and update this instance - bcsvData->GetValue(nextEntryIndex, "start_frame", startFrame); - bcsvData->GetValue(nextEntryIndex, "end_frame", endFrame); - bcsvData->GetValue(nextEntryIndex, "type", rumbleTypeString); - rumbleTypeIndex = RumbleType::getIndex((char*)rumbleTypeString); - } else { - rumbleTypeIndex = -1; - } - - isRumbleActive = false; - } - public: const TTHPRender* thpRenderer; Koga::ToolData* toolData; // this is supposedly the only usage of tooldata // in the entire game lmao - int entryIndex; - int startFrame; - int endFrame; - int rumbleTypeIndex; + s32 entryIndex; + s32 startFrame; + s32 endFrame; + s32 rumbleTypeIndex; bool isRumbleActive; }; diff --git a/src/GC2D/MovieRumble.cpp b/src/GC2D/MovieRumble.cpp index 09e03cce..0ea51f49 100644 --- a/src/GC2D/MovieRumble.cpp +++ b/src/GC2D/MovieRumble.cpp @@ -22,12 +22,29 @@ void TMovieRumble::init(const char* subtitleName) void* glbResource = JKRFileLoader::getGlbResource(szSubtitlePath); toolData->Attach(glbResource); - if (toolData->dataExists()) - entryIndex = 0; - else + if (toolData->dataExists() == FALSE) entryIndex = -1; + else + entryIndex = 0; + + const char* rumbleTypeString; + + Koga::ToolData* pData = toolData; + s32 nextEntryIndex = entryIndex; + bool dataAndIndexValid = (pData != nullptr) && (nextEntryIndex >= 0); - updateRumbleState(toolData, 0); + // this if statement feels wrong + if (dataAndIndexValid && (nextEntryIndex < pData->mData->mNumEntries)) { + // get this rumble entry's data, and update this instance + pData->GetValue(nextEntryIndex, "start_frame", startFrame); + pData->GetValue(nextEntryIndex, "end_frame", endFrame); + pData->GetValue(nextEntryIndex, "type", rumbleTypeString); + rumbleTypeIndex = RumbleType::getIndex((char*)rumbleTypeString); + } else { + rumbleTypeIndex = -1; + } + + isRumbleActive = false; } void TMovieRumble::perform(u32 flags, JDrama::TGraphics* graphics) @@ -52,7 +69,26 @@ void TMovieRumble::checkRumbleOff() if (endFrame <= thpRenderer->frameNumber) { SMSRumbleMgr->stop(); entryIndex++; - updateRumbleState(toolData, 0); + const char* rumbleTypeString; + + Koga::ToolData* pData = toolData; + s32 nextEntryIndex = entryIndex; + bool dataAndIndexValid + = (pData != nullptr) && (nextEntryIndex >= 0); + + // this if statement feels wrong + if (dataAndIndexValid + && (nextEntryIndex < pData->mData->mNumEntries)) { + // get this rumble entry's data, and update this instance + pData->GetValue(nextEntryIndex, "start_frame", startFrame); + pData->GetValue(nextEntryIndex, "end_frame", endFrame); + pData->GetValue(nextEntryIndex, "type", rumbleTypeString); + rumbleTypeIndex = RumbleType::getIndex((char*)rumbleTypeString); + } else { + rumbleTypeIndex = -1; + } + + isRumbleActive = false; } } } From 759f80560cbb58f47ae895fe98a9ea983b29bcaf Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Fri, 17 Oct 2025 12:24:30 +0200 Subject: [PATCH 08/24] bruh bruh --- include/MarioUtil/ToolData.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/MarioUtil/ToolData.hpp b/include/MarioUtil/ToolData.hpp index a30b6313..65068ca8 100644 --- a/include/MarioUtil/ToolData.hpp +++ b/include/MarioUtil/ToolData.hpp @@ -49,8 +49,8 @@ class ToolData { u32 mEntrySize; // 0xC const JMapItem mItems[]; // 0x10 }; -private: +private: inline u32 hashString(const char* key) const { u32 stringHash = 0; From 4d00b23660c9de2a90b0ec90b8aca86dd278ec4e Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Wed, 22 Oct 2025 20:30:53 +0200 Subject: [PATCH 09/24] rumble data struct + convert hex to floats --- include/MarioUtil/RumbleMgr.hpp | 23 +- src/MarioUtil/RumbleData.cpp | 442 +++++++++++++++----------------- 2 files changed, 218 insertions(+), 247 deletions(-) diff --git a/include/MarioUtil/RumbleMgr.hpp b/include/MarioUtil/RumbleMgr.hpp index 6696c4c9..0c6a9b1a 100644 --- a/include/MarioUtil/RumbleMgr.hpp +++ b/include/MarioUtil/RumbleMgr.hpp @@ -2,20 +2,23 @@ #define MARIO_UTIL_RUMBLE_MGR_HPP #include +#include +#include -class RumbleBase { -public: - void init(); - void stop(); - void update(f32, bool); -}; +#define MAX_RUMBLE_ID (25) +#define MAX_RUMBLE_CHANNELS (32) -class RumbleChannelDataMgr { -public: - void init(); - void getChannelDataTbl(int); +struct RumbleChannelData { + int* point; + float* frame; + float* power; }; +extern const RumbleChannelData channelDataTbl[]; +extern int channelNum; + +// RumbleMgr + class RumbleChannelMgr { public: RumbleChannelMgr(); diff --git a/src/MarioUtil/RumbleData.cpp b/src/MarioUtil/RumbleData.cpp index 9b253434..d22b6043 100644 --- a/src/MarioUtil/RumbleData.cpp +++ b/src/MarioUtil/RumbleData.cpp @@ -1,311 +1,279 @@ -// order is Point, Frame, Power -// point = sizeof(Frame) -// static_assert(sizeof(Frame) == sizeof(Power)) - -// struct RumbleData_t { -// int* point; -// int* frame; -// int* power; -// }; +#include #define MAX_RUMBLE_ID (25) -static int rumblePoint_00 = 11; -static int rumbleFrame_00[] = { - 0x00000000, 0x3D4CCCCD, 0x3DCCCCCD, 0x3E19999A, 0x3E4CCCCD, 0x3E800000, - 0x3E800000, 0x3EA8F5C3, 0x3ECCCCCD, 0x3F000000, 0x3F19999A, +static int rumblePoint_00 = 11; +static float rumbleFrame_00[] = { + 0.0f, 0.05f, 0.1f, 0.15f, 0.2f, 0.25f, 0.25f, 0.33f, 0.4f, 0.5f, 0.6f, }; -static int rumblePower_00[] = { - 0x3F800000, 0x3F800000, 0x3F800000, 0x3F666666, 0x00000000, 0x00000000, - 0x3F19999A, 0x3F19999A, 0x3F000000, 0x3E4CCCCD, 0x00000000, +static float rumblePower_00[] = { + 1.0f, 1.0f, 1.0f, 0.9f, 0.0f, 0.0f, 0.6f, 0.6f, 0.5f, 0.2f, 0.0f, }; -static int rumblePoint_01 = 24; -static int rumbleFrame_01[] = { - 0x00000000, 0x3E23D70A, 0x3E428F5C, 0x3E75C28F, 0x3E851EB8, 0x3EBD70A4, - 0x3ECCCCCD, 0x3EE66666, 0x3EEB851F, 0x3F0A3D71, 0x3F0F5C29, 0x3F1C28F6, - 0x3F1EB852, 0x3F333333, 0x3F3AE148, 0x3F47AE14, 0x3F4A3D71, 0x3F5C28F6, - 0x3F6B851F, 0x3F75C28F, 0x3F83D70A, 0x3F90A3D7, 0x3F95C28F, 0x3FB33333, -}; -static int rumblePower_01[] = { - 0x3F800000, 0x3F800000, 0x00000000, 0x00000000, 0x3F733333, 0x3F59999A, - 0x00000000, 0x00000000, 0x3F4CCCCD, 0x3F3AE148, 0x00000000, 0x00000000, - 0x3F23D70A, 0x3F07AE14, 0x00000000, 0x00000000, 0x3EE147AE, 0x3EB33333, - 0x00000000, 0x3E8A3D71, 0x3CA3D70A, 0x3E23D70A, 0x3C23D70A, 0x00000000, +static int rumblePoint_01 = 24; +static float rumbleFrame_01[] = { + 0.0f, 0.16f, 0.19f, 0.24f, 0.26f, 0.37f, 0.4f, 0.45f, + 0.46f, 0.54f, 0.56f, 0.61f, 0.62f, 0.7f, 0.73f, 0.78f, + 0.79f, 0.86f, 0.92f, 0.96f, 1.03f, 1.13f, 1.17f, 1.4f, +}; +static float rumblePower_01[] = { + 1.0f, 1.0f, 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, 0.0f, + 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, 0.53f, 0.0f, 0.0f, + 0.44f, 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f, }; -static int rumblePoint_02 = 2; -static int rumbleFrame_02[] = { - 0x00000000, - 0x3DCCCCCD, +static int rumblePoint_02 = 2; +static float rumbleFrame_02[] = { + 0.0f, + 0.1f, }; -static int rumblePower_02[] = { - 0x3F4CCCCD, - 0x3F19999A, +static float rumblePower_02[] = { + 0.8f, + 0.6f, }; -static int rumblePoint_03 = 2; -static int rumbleFrame_03[] = { - 0x00000000, - 0x3DCCCCCD, +static int rumblePoint_03 = 2; +static float rumbleFrame_03[] = { + 0.0f, + 0.1f, }; -static int rumblePower_03[] = { - 0x3F800000, - 0x3F800000, +static float rumblePower_03[] = { + 1.0f, + 1.0f, }; -static int rumblePoint_04 = 7; -static int rumbleFrame_04[] = { - 0x00000000, 0x3DCCCCCD, 0x3E19999A, 0x3E4CCCCD, - 0x3E800000, 0x3E99999A, 0x3F000000, +static int rumblePoint_04 = 7; +static float rumbleFrame_04[] = { + 0.0f, 0.1f, 0.15f, 0.2f, 0.25f, 0.3f, 0.5f, }; -static int rumblePower_04[] = { - 0x3F800000, 0x3F800000, 0x00000000, 0x3F4CCCCD, - 0x3F4CCCCD, 0x00000000, 0x00000000, +static float rumblePower_04[] = { + 1.0f, 1.0f, 0.0f, 0.8f, 0.8f, 0.0f, 0.0f, }; -static int rumblePoint_05 = 21; -static int rumbleFrame_05[] = { - 0x00000000, 0x3E3851EC, 0x3E570A3D, 0x3E8F5C29, 0x3E8F5C29, 0x3ECCCCCD, - 0x3EE66666, 0x3F028F5C, 0x3F051EB8, 0x3F23D70A, 0x3F30A3D7, 0x3F400000, - 0x3F547AE1, 0x3F63D70A, 0x3F7D70A4, 0x3F83D70A, 0x3F8F5C29, 0x3F9851EC, - 0x3FA00000, 0x3FA66666, 0x3FB33333, -}; -static int rumblePower_05[] = { - 0x3F800000, 0x3F6B851F, 0x00000000, 0x00000000, 0x3F4A3D71, 0x3F2147AE, - 0x00000000, 0x3CA3D70A, 0x3EE66666, 0x3E9EB852, 0x3CA3D70A, 0x3E75C28F, - 0x3CF5C28F, 0x3E3851EC, 0x3D23D70A, 0x3E051EB8, 0x3D23D70A, 0x3DCCCCCD, - 0x3D23D70A, 0x3D75C28F, 0x00000000, +static int rumblePoint_05 = 21; +static float rumbleFrame_05[] = { + 0.0f, 0.18f, 0.21f, 0.28f, 0.28f, 0.4f, 0.45f, 0.51f, 0.52f, 0.64f, 0.69f, + 0.75f, 0.83f, 0.89f, 0.99f, 1.03f, 1.12f, 1.19f, 1.25f, 1.3f, 1.4f, +}; +static float rumblePower_05[] = { + 1.0f, 0.92f, 0.0f, 0.0f, 0.79f, 0.63f, 0.0f, 0.02f, 0.45f, 0.31f, 0.02f, + 0.24f, 0.03f, 0.18f, 0.04f, 0.13f, 0.04f, 0.1f, 0.04f, 0.06f, 0.0f, }; -static int rumblePoint_06 = 10; -static int rumbleFrame_06[] = { - 0x00000000, 0x3DB851EC, 0x3DB851EC, 0x3DCCCCCD, 0x3E2E147B, - 0x3E2E147B, 0x3E3851EC, 0x3E851EB8, 0x3E851EB8, 0x3F000000, +static int rumblePoint_06 = 10; +static float rumbleFrame_06[] = { + 0.0f, 0.09f, 0.09f, 0.1f, 0.17f, 0.17f, 0.18f, 0.26f, 0.26f, 0.5f, }; -static int rumblePower_06[] = { - 0x3F59999A, 0x3F59999A, 0x3DCCCCCD, 0x3EE66666, 0x3EE66666, - 0x3D4CCCCD, 0x3E800000, 0x3E800000, 0x3C23D70A, 0x00000000, +static float rumblePower_06[] = { + 0.85f, 0.85f, 0.1f, 0.45f, 0.45f, 0.05f, 0.25f, 0.25f, 0.01f, 0.0f, }; -static int rumblePoint_07 = 20; -static int rumbleFrame_07[] = { - 0x00000000, 0x3DE147AE, 0x3DF5C28F, 0x3E051EB8, 0x3E4CCCCD, - 0x3E570A3D, 0x3E947AE1, 0x3E9EB852, 0x3EA8F5C3, 0x3ED1EB85, - 0x3ED70A3D, 0x3F051EB8, 0x3F07AE14, 0x3F0A3D71, 0x3F1EB852, - 0x3F23D70A, 0x3F3851EC, 0x3F3D70A4, 0x3F400000, 0x3F800000, -}; -static int rumblePower_07[] = { - 0x3F733333, 0x3F7851EC, 0x3F59999A, 0x00000000, 0x00000000, - 0x3F400000, 0x3F3AE148, 0x3F0CCCCD, 0x00000000, 0x00000000, - 0x3F19999A, 0x3F2147AE, 0x3EA3D70A, 0x00000000, 0x00000000, - 0x3F028F5C, 0x3EF5C28F, 0x3E428F5C, 0x3CA3D70A, 0x00000000, +static int rumblePoint_07 = 20; +static float rumbleFrame_07[] = { + 0.0f, 0.11f, 0.12f, 0.13f, 0.2f, 0.21f, 0.29f, 0.31f, 0.33f, 0.41f, + 0.42f, 0.52f, 0.53f, 0.54f, 0.62f, 0.64f, 0.72f, 0.74f, 0.75f, 1.0f, +}; +static float rumblePower_07[] = { + 0.95f, 0.97f, 0.85f, 0.0f, 0.0f, 0.75f, 0.73f, 0.55f, 0.0f, 0.0f, + 0.6f, 0.63f, 0.32f, 0.0f, 0.0f, 0.51f, 0.48f, 0.19f, 0.02f, 0.0f, }; -static int rumblePoint_08 = 4; -static int rumbleFrame_08[] = { - 0x00000000, 0x3E99999A, 0x3F000000, 0x3F333333, 0x3F800000, +static int rumblePoint_08 = 4; +static float rumbleFrame_08[] = { + 0.0f, 0.3f, 0.5f, 0.7f, 1.0f, }; -static int rumblePower_08[] = { - 0x3F800000, 0x3F000000, 0x3EB33333, 0x3F000000, 0x3F800000, +static float rumblePower_08[] = { + 1.0f, 0.5f, 0.35f, 0.5f, 1.0f, }; -static int rumblePoint_09 = 4; -static int rumbleFrame_09[] = { - 0x00000000, - 0x3E99999A, - 0x3F000000, - 0x3F333333, -}; -static int rumblePower_09[] = { - 0x3F000000, - 0x3E75C28F, - 0x3E3851EC, - 0x3E6B851F, +static int rumblePoint_09 = 4; +static float rumbleFrame_09[] = { + 0.0f, + 0.3f, + 0.5f, + 0.7f, +}; +static float rumblePower_09[] = { + 0.5f, + 0.24f, + 0.18f, + 0.23f, }; -static int rumblePoint_10 = 1; -static int rumbleFrame_10[] = { - 0x00000000, +static int rumblePoint_10 = 1; +static float rumbleFrame_10[] = { + 0.0f, }; -static int rumblePower_10[] = { - 0x00000000, +static float rumblePower_10[] = { + 0.0f, }; -static int rumblePoint_11 = 1; -static int rumbleFrame_11[] = { - 0x00000000, +static int rumblePoint_11 = 1; +static float rumbleFrame_11[] = { + 0.0f, }; -static int rumblePower_11[] = { - 0x00000000, +static float rumblePower_11[] = { + 0.0f, }; -static int rumblePoint_12 = 1; -static int rumbleFrame_12[] = { - 0x00000000, +static int rumblePoint_12 = 1; +static float rumbleFrame_12[] = { + 0.0f, }; -static int rumblePower_12[] = { - 0x00000000, +static float rumblePower_12[] = { + 0.0f, }; -static int rumblePoint_13 = 1; -static int rumbleFrame_13[] = { - 0x00000000, +static int rumblePoint_13 = 1; +static float rumbleFrame_13[] = { + 0.0f, }; -static int rumblePower_13[] = { - 0x00000000, +static float rumblePower_13[] = { + 0.0f, }; -static int rumblePoint_14 = 1; -static int rumbleFrame_14[] = { - 0x00000000, +static int rumblePoint_14 = 1; +static float rumbleFrame_14[] = { + 0.0f, }; -static int rumblePower_14[] = { - 0x00000000, +static float rumblePower_14[] = { + 0.0f, }; -static int rumblePoint_15 = 1; -static int rumbleFrame_15[] = { - 0x00000000, +static int rumblePoint_15 = 1; +static float rumbleFrame_15[] = { + 0.0f, }; -static int rumblePower_15[] = { - 0x00000000, +static float rumblePower_15[] = { + 0.0f, }; -static int rumblePoint_16 = 1; -static int rumbleFrame_16[] = { - 0x00000000, +static int rumblePoint_16 = 1; +static float rumbleFrame_16[] = { + 0.0f, }; -static int rumblePower_16[] = { - 0x00000000, +static float rumblePower_16[] = { + 0.0f, }; -static int rumblePoint_17 = 1; -static int rumbleFrame_17[] = { - 0x00000000, +static int rumblePoint_17 = 1; +static float rumbleFrame_17[] = { + 0.0f, }; -static int rumblePower_17[] = { - 0x00000000, +static float rumblePower_17[] = { + 0.0f, }; -static int rumblePoint_18 = 1; -static int rumbleFrame_18[] = { - 0x00000000, +static int rumblePoint_18 = 1; +static float rumbleFrame_18[] = { + 0.0f, }; -static int rumblePower_18[] = { - 0x00000000, +static float rumblePower_18[] = { + 0.0f, }; -static int rumblePoint_19 = 5; -static int rumbleFrame_19[] = { - 0x00000000, 0x3DE147AE, 0x3E4CCCCD, 0x3EA3D70A, 0x3ECCCCCD, +static int rumblePoint_19 = 5; +static float rumbleFrame_19[] = { + 0.0f, 0.11f, 0.2f, 0.32f, 0.4f, }; -static int rumblePower_19[] = { - 0x3F19999A, 0x3ECCCCCD, 0x3F19999A, 0x3ECCCCCD, 0x3F19999A, +static float rumblePower_19[] = { + 0.6f, 0.4f, 0.6f, 0.4f, 0.6f, }; -static int rumblePoint_20 = 2; -static int rumbleFrame_20[] = { - 0x00000000, - 0x3C888889, +static int rumblePoint_20 = 2; +static float rumbleFrame_20[] = { + 0.0f, + 0.01666666666f, }; -static int rumblePower_20[] = { - 0x3F000000, - 0x3F000000, +static float rumblePower_20[] = { + 0.5f, + 0.5f, }; -static int rumblePoint_21 = 2; -static int rumbleFrame_21[] = { - 0x00000000, - 0x3C888889, +static int rumblePoint_21 = 2; +static float rumbleFrame_21[] = { + 0.0f, + 0.01666666666f, }; -static int rumblePower_21[] = { - 0x3F400000, - 0x3F400000, +static float rumblePower_21[] = { + 0.75f, + 0.75f, }; -static int rumblePoint_22 = 2; -static int rumbleFrame_22[] = { - 0x00000000, - 0x40000000, +static int rumblePoint_22 = 2; +static float rumbleFrame_22[] = { + 0.0f, + 2.0f, }; -static int rumblePower_22[] = { - 0x3F400000, - 0x3F400000, +static float rumblePower_22[] = { + 0.75f, + 0.75f, }; -static int rumblePoint_23 = 77; -static int rumbleFrame_23[] = { - 0x00000000, 0x3D8F5C29, 0x3E051EB8, 0x3E800000, 0x3E851EB8, 0x3F828F5C, - 0x3F83D70A, 0x3F91EB85, 0x3F91EB85, 0x3F99999A, 0x3F9AE148, 0x3FA51EB8, - 0x3FAA3D71, 0x40700000, 0x4073D70A, 0x407AE148, 0x407C28F6, 0x40800000, - 0x40851EB8, 0x408570A4, 0x408B851F, 0x408CCCCD, 0x408E147B, 0x408E147B, - 0x40928F5C, 0x4096147B, 0x40A51EB8, 0x40A5C28F, 0x40A8F5C3, 0x40AA3D71, - 0x40ACCCCD, 0x40AD1EB8, 0x40B0A3D7, 0x40B1EB85, 0x40B28F5C, 0x40B51EB8, - 0x40B5C28F, 0x40CB3333, 0x40CB851F, 0x40D23D71, 0x40D5C28F, 0x40DB3333, - 0x40DC28F6, 0x40E3851F, 0x40E5C28F, 0x40F00000, 0x40F51EB8, 0x410170A4, - 0x410AB852, 0x411147AE, 0x4111999A, 0x411A147B, 0x411A3D71, 0x411A6666, - 0x411CF5C3, 0x411D70A4, 0x411E3D71, 0x411E8F5C, 0x412051EC, 0x4120A3D7, - 0x4120CCCD, 0x4120F5C3, 0x41230A3D, 0x41235C29, 0x4123851F, 0x4123AE14, - 0x4125999A, 0x4126147B, 0x4126E148, 0x41273333, 0x412828F6, 0x41291EB8, - 0x4129C28F, 0x412AE148, 0x412C7AE1, 0x412D1EB8, 0x41300000, -}; -static int rumblePower_23[] = { - 0x3F4CCCCD, 0x3F800000, 0x3F733333, 0x3F4CCCCD, 0x00000000, 0x00000000, - 0x3F733333, 0x3F733333, 0x3ED1EB85, 0x3EE147AE, 0x3F3851EC, 0x3F147AE1, - 0x00000000, 0x00000000, 0x3F4F5C29, 0x3F666666, 0x3F30A3D7, 0x00000000, - 0x00000000, 0x3F7AE148, 0x3F733333, 0x3F07AE14, 0x3F000000, 0x3F5EB852, - 0x3F333333, 0x00000000, 0x00000000, 0x3F5EB852, 0x3F570A3D, 0x3EA3D70A, - 0x3E8A3D71, 0x3F30A3D7, 0x3F0CCCCD, 0x00000000, 0x3EAE147B, 0x3E8A3D71, - 0x00000000, 0x00000000, 0x3F47AE14, 0x3F35C28F, 0x00000000, 0x00000000, - 0x3F47AE14, 0x3F2E147B, 0x00000000, 0x00000000, 0x3ED70A3D, 0x3F3851EC, - 0x3F5EB852, 0x3F800000, 0x00000000, 0x00000000, 0x3F800000, 0x3F800000, - 0x3F800000, 0x00000000, 0x00000000, 0x3F733333, 0x3F59999A, 0x00000000, - 0x00000000, 0x3F4CCCCD, 0x3F3AE148, 0x00000000, 0x00000000, 0x3F23D70A, - 0x3F07AE14, 0x00000000, 0x00000000, 0x3EE147AE, 0x3EB33333, 0x00000000, - 0x3E8A3D71, 0x3CA3D70A, 0x3E23D70A, 0x3C23D70A, 0x00000000, +static int rumblePoint_23 = 77; +static float rumbleFrame_23[] = { + 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, + 1.2f, 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, + 4.16f, 4.17f, 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, + 5.18f, 5.28f, 5.32f, 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, + 5.68f, 6.35f, 6.36f, 6.57f, 6.68f, 6.85f, 6.88f, 7.11f, 7.18f, + 7.5f, 7.66f, 8.09f, 8.67f, 9.08f, 9.1f, 9.63f, 9.64f, 9.65f, + 9.81f, 9.84f, 9.89f, 9.91f, 10.02f, 10.04f, 10.05f, 10.06f, 10.19f, + 10.21f, 10.22f, 10.23f, 10.35f, 10.38f, 10.43f, 10.45f, 10.51f, 10.57f, + 10.61f, 10.68f, 10.78f, 10.82f, 11.0f, +}; +static float rumblePower_23[] = { + 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, 0.72f, + 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, 0.95f, 0.53f, + 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, 0.27f, 0.69f, 0.55f, + 0.0f, 0.34f, 0.27f, 0.0f, 0.0f, 0.78f, 0.71f, 0.0f, 0.0f, 0.78f, 0.68f, + 0.0f, 0.0f, 0.42f, 0.72f, 0.87f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, + 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, 0.0f, 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, + 0.53f, 0.0f, 0.0f, 0.44f, 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f, }; -static int rumblePoint_24 = 37; -static int rumbleFrame_24[] = { - 0x00000000, 0x3D8F5C29, 0x3E051EB8, 0x3E800000, 0x3E851EB8, 0x3F828F5C, - 0x3F83D70A, 0x3F91EB85, 0x3F91EB85, 0x3F99999A, 0x3F9AE148, 0x3FA51EB8, - 0x3FAA3D71, 0x40700000, 0x4073D70A, 0x407AE148, 0x407C28F6, 0x40800000, - 0x40851EB8, 0x408570A4, 0x408B851F, 0x408CCCCD, 0x408E147B, 0x408E147B, - 0x40928F5C, 0x4096147B, 0x40A51EB8, 0x40A5C28F, 0x40A8F5C3, 0x40AA3D71, - 0x40ACCCCD, 0x40AD1EB8, 0x40B0A3D7, 0x40B1EB85, 0x40B28F5C, 0x40B51EB8, - 0x40B5C28F, -}; -static int rumblePower_24[] = { - 0x3F4CCCCD, 0x3F800000, 0x3F733333, 0x3F4CCCCD, 0x00000000, 0x00000000, - 0x3F733333, 0x3F733333, 0x3ED1EB85, 0x3EE147AE, 0x3F3851EC, 0x3F147AE1, - 0x00000000, 0x00000000, 0x3F4F5C29, 0x3F666666, 0x3F30A3D7, 0x00000000, - 0x00000000, 0x3F7AE148, 0x3F733333, 0x3F07AE14, 0x3F000000, 0x3F5EB852, - 0x3F333333, 0x00000000, 0x00000000, 0x3F5EB852, 0x3F570A3D, 0x3EA3D70A, - 0x3E8A3D71, 0x3F30A3D7, 0x3F0CCCCD, 0x00000000, 0x3EAE147B, 0x3E8A3D71, - 0x00000000, +static int rumblePoint_24 = 37; +static float rumbleFrame_24[] = { + 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, 1.2f, + 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, 4.16f, 4.17f, + 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, 5.18f, 5.28f, 5.32f, + 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, 5.68f, +}; +static float rumblePower_24[] = { + 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, + 0.72f, 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, + 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, + 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f, }; -const int* channelDataTbl[] = { - &rumblePoint_00, rumbleFrame_00, rumblePower_00, &rumblePoint_01, - rumbleFrame_01, rumblePower_01, &rumblePoint_02, rumbleFrame_02, - rumblePower_02, &rumblePoint_03, rumbleFrame_03, rumblePower_03, - &rumblePoint_04, rumbleFrame_04, rumblePower_04, &rumblePoint_05, - rumbleFrame_05, rumblePower_05, &rumblePoint_06, rumbleFrame_06, - rumblePower_06, &rumblePoint_07, rumbleFrame_07, rumblePower_07, - &rumblePoint_08, rumbleFrame_08, rumblePower_08, &rumblePoint_09, - rumbleFrame_09, rumblePower_09, &rumblePoint_10, rumbleFrame_10, - rumblePower_10, &rumblePoint_11, rumbleFrame_11, rumblePower_11, - &rumblePoint_12, rumbleFrame_12, rumblePower_12, &rumblePoint_13, - rumbleFrame_13, rumblePower_13, &rumblePoint_14, rumbleFrame_14, - rumblePower_14, &rumblePoint_15, rumbleFrame_15, rumblePower_15, - &rumblePoint_16, rumbleFrame_16, rumblePower_16, &rumblePoint_17, - rumbleFrame_17, rumblePower_17, &rumblePoint_18, rumbleFrame_18, - rumblePower_18, &rumblePoint_19, rumbleFrame_19, rumblePower_19, - &rumblePoint_20, rumbleFrame_20, rumblePower_20, &rumblePoint_21, - rumbleFrame_21, rumblePower_21, &rumblePoint_22, rumbleFrame_22, - rumblePower_22, &rumblePoint_23, rumbleFrame_23, rumblePower_23, - &rumblePoint_24, rumbleFrame_24, rumblePower_24, -}; +// clang-format off +const RumbleChannelData channelDataTbl[] = { + { &rumblePoint_00, rumbleFrame_00, rumblePower_00, }, + { &rumblePoint_01, rumbleFrame_01, rumblePower_01, }, + { &rumblePoint_02, rumbleFrame_02, rumblePower_02, }, + { &rumblePoint_03, rumbleFrame_03, rumblePower_03, }, + { &rumblePoint_04, rumbleFrame_04, rumblePower_04, }, + { &rumblePoint_05, rumbleFrame_05, rumblePower_05, }, + { &rumblePoint_06, rumbleFrame_06, rumblePower_06, }, + { &rumblePoint_07, rumbleFrame_07, rumblePower_07, }, + { &rumblePoint_08, rumbleFrame_08, rumblePower_08, }, + { &rumblePoint_09, rumbleFrame_09, rumblePower_09, }, + { &rumblePoint_10, rumbleFrame_10, rumblePower_10, }, + { &rumblePoint_11, rumbleFrame_11, rumblePower_11, }, + { &rumblePoint_12, rumbleFrame_12, rumblePower_12, }, + { &rumblePoint_13, rumbleFrame_13, rumblePower_13, }, + { &rumblePoint_14, rumbleFrame_14, rumblePower_14, }, + { &rumblePoint_15, rumbleFrame_15, rumblePower_15, }, + { &rumblePoint_16, rumbleFrame_16, rumblePower_16, }, + { &rumblePoint_17, rumbleFrame_17, rumblePower_17, }, + { &rumblePoint_18, rumbleFrame_18, rumblePower_18, }, + { &rumblePoint_19, rumbleFrame_19, rumblePower_19, }, + { &rumblePoint_20, rumbleFrame_20, rumblePower_20, }, + { &rumblePoint_21, rumbleFrame_21, rumblePower_21, }, + { &rumblePoint_22, rumbleFrame_22, rumblePower_22, }, + { &rumblePoint_23, rumbleFrame_23, rumblePower_23, }, + { &rumblePoint_24, rumbleFrame_24, rumblePower_24, }, +}; +// clang-format on int channelNum = MAX_RUMBLE_ID; From ec321cb36fc5be07e23c4c39a3ed7fde13a35b4d Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Wed, 22 Oct 2025 20:35:01 +0200 Subject: [PATCH 10/24] begin decompiling RumbleMgr --- include/MarioUtil/RumbleMgr.hpp | 55 +++-- src/MarioUtil/RumbleMgr.cpp | 370 ++++++++++++++++++++++++++++++++ 2 files changed, 412 insertions(+), 13 deletions(-) diff --git a/include/MarioUtil/RumbleMgr.hpp b/include/MarioUtil/RumbleMgr.hpp index 0c6a9b1a..ad72dbab 100644 --- a/include/MarioUtil/RumbleMgr.hpp +++ b/include/MarioUtil/RumbleMgr.hpp @@ -22,26 +22,37 @@ extern int channelNum; class RumbleChannelMgr { public: RumbleChannelMgr(); - void init(RumbleChannelDataMgr*); - void reset(); - void repeat(); - void start(int, int, f32*); - void start(int, int, Vec*); - void update(); + f32 update(); + +public: + /* 0x00 */ f32 mElapsedTime; /* inferred */ + /* 0x04 */ f32 mCurrentIntensity; /* inferred */ + /* 0x08 */ s32 mChannelID; /* inferred */ + /* 0x0C */ s32 mLoopCount; /* inferred */ + /* 0x10 */ f32* mExternalDampenPtr; /* inferred */ + /* 0x14 */ Vec* mPositionalSourcePtr; /* inferred */ + /* 0x18 */ const RumbleChannelData* rumbleData; /* inferred */ + /* 0x1C */ void* unk20; /* inferred */ }; class RumbleControllerMgr { public: - RumbleControllerMgr(); - void init(); void reset(); - void start(int, int, f32*); - void start(int, int, Vec*); - void stop(); + void start(int channelId, int loopCount, float* externalDampenPtr); + void start(int channelId, int loopCount, Vec* positionalSourcePtr); void stop(int); void channelMgrIsAllFree(); void updateMotorCount(); void update(); + +public: + f32 currentPower; // 0x00 + RumbleChannelMgr *channels; // 0x04 + RumbleChannelMgr *unk8; // 0x08 + u32 unkC; // 0x0C + u16 motorTime; // 0x10 + bool unk12; // 0x12 + u8 padding_13; // 0x13 }; class RumbleMgr; @@ -69,8 +80,26 @@ class RumbleMgr { void setActive(bool); void startPause(); void finishPause(); - void changePause(); - void changeMode(); + +public: + struct RumbleControllerState { + f32 m_currentIntensityL; // 0x00 + f32 m_currentIntensityR; // 0x04 + s32 m_controllerIndex; // 0x08 + }; + + f32 m_masterIntensityL; // 0x00 + f32 m_masterIntensityR; // 0x04 + bool m_isInitialized; // 0x08 + bool m_flags; // 0x09 + bool unkA; // 0x0A + RumbleControllerState* m_controllerStates[4]; // 0x0C + RumbleControllerMgr* m_controllerManagers[4]; // 0x1C + const int *** m_rumbleOutput; // 0x2C + + static u32 mMotorCountLimit; + static u16 mMotorTimerPeriod; + static f32 mPowerThreshold; }; #endif diff --git a/src/MarioUtil/RumbleMgr.cpp b/src/MarioUtil/RumbleMgr.cpp index e69de29b..08d2dc1c 100644 --- a/src/MarioUtil/RumbleMgr.cpp +++ b/src/MarioUtil/RumbleMgr.cpp @@ -0,0 +1,370 @@ +#include +#include +#include +#include + +RumbleMgr* SMSRumbleMgr; + +u32 RumbleMgr::mMotorCountLimit = 900; +u16 RumbleMgr::mMotorTimerPeriod = 80; +f32 RumbleMgr::mPowerThreshold = 0.5f; + +RumbleChannelMgr::RumbleChannelMgr() +{ + mElapsedTime = 0.0f; + mCurrentIntensity = 0.0f; + mChannelID = -1; + mLoopCount = 0; + mExternalDampenPtr = nullptr; + mPositionalSourcePtr = nullptr; + rumbleData = 0; +} + +f32 RumbleChannelMgr::update() +{ + f32 dampenFactor; + f32* externalDampenSource = this->mExternalDampenPtr; + f32 temp_f31 = 1.0f / SMSGetVSyncTimesPerSec(); + if (externalDampenSource != NULL) { + f32 temp_f1; + temp_f1 = *externalDampenSource; + dampenFactor = temp_f1; + if (temp_f1 < 0.0f) { + dampenFactor = 0.0f; + } else if (dampenFactor > 1.0f) { + dampenFactor = 1.0f; + } + } else { + if (this->mPositionalSourcePtr != NULL) { + f32 temp_f2; + JGeometry::TVec3 temp; + temp.set(SMS_GetMarioPos()); + temp -= *this->mPositionalSourcePtr; + // temp = SMS_GetMarioPos() - *this->mPositionalSourcePtr; + f32 distance = temp.length(); // why are you getting inlined :( + // dampenFactor = clamp(distance, 0, 1); + dampenFactor = distance; + if (distance < 0.0f) { + dampenFactor = 0.0f; + } else if (dampenFactor > 1.0f) { + dampenFactor = 1.0f; + } + } else { + dampenFactor = 1.0f; + } + } + + this->mCurrentIntensity = 0.0; + if (!this->mLoopCount) { + this->mElapsedTime = 0.0; + this->mCurrentIntensity = 0.0; + this->mChannelID = -1; + this->mLoopCount = 0; + this->mExternalDampenPtr = 0; + this->mPositionalSourcePtr = 0; + this->rumbleData = 0; + } + + this->mCurrentIntensity *= dampenFactor; + return this->mCurrentIntensity; +} + +void RumbleControllerMgr::reset() +{ + this->currentPower = 0.0f; + this->unkC = 0; + this->motorTime = 0; + this->unk12 = false; + + for (s32 i = 0; i < MAX_RUMBLE_CHANNELS; i++) { + RumbleChannelMgr* channel = &this->channels[i]; + channel->mElapsedTime = 0.0f; + channel->mCurrentIntensity = 0.0f; + channel->mChannelID = -1; + channel->mLoopCount = 0; + channel->mExternalDampenPtr = 0; + channel->mPositionalSourcePtr = 0; + channel->rumbleData = 0; + } +} + +void RumbleControllerMgr::start(int channelId, int loopCount, + float* externalDampenPtr) +{ + for (s32 i = 0; i < MAX_RUMBLE_CHANNELS; ++i) { + RumbleChannelMgr* channel = &this->channels[i]; + + if (channel->rumbleData == NULL) { + channel->mElapsedTime = 0.0f; + channel->rumbleData = &channelDataTbl[channelId]; + channel->mChannelID = channelId; + channel->mLoopCount = loopCount; + channel->mExternalDampenPtr = externalDampenPtr; + return; // Found a slot and started the rumble, so we exit + } + } +} + +void RumbleControllerMgr::start(int channelId, int loopCount, + Vec* positionalSourcePtr) +{ + for (s32 i = 0; i < MAX_RUMBLE_CHANNELS; ++i) { + RumbleChannelMgr* channel = &this->channels[i]; + + if (channel->rumbleData == NULL) { + channel->mElapsedTime = 0.0f; + channel->rumbleData = &channelDataTbl[channelId]; + channel->mChannelID = channelId; + channel->mLoopCount = loopCount; + channel->mPositionalSourcePtr = positionalSourcePtr; + return; // Found a slot and started the rumble, so we exit + } + } +} + +void RumbleControllerMgr::stop(int arg0) +{ + +#if 0 + s32 temp_r5; + s32 temp_r5_2; + s32 temp_r5_3; + s32 var_ctr; + s32 var_r5; + RumbleControllerMgr* temp_r11; + RumbleControllerMgr* temp_r11_2; + RumbleControllerMgr* temp_r11_3; + RumbleControllerMgr* temp_r11_4; + + var_r5 = 0; + var_ctr = 8; + do { + temp_r11 = (RumbleControllerMgr*)(this->channels + var_r5); + if (((u32)temp_r11->unk18 != 0U) && (arg0 == (s32)temp_r11->unk8)) { + temp_r11->unk0 = 0.0f; + temp_r11->unk4 = 0.0f; + temp_r11->unk8 = -1; + temp_r11->unkC = 0; + temp_r11->unk10 = 0; + temp_r11->unk14 = 0; + temp_r11->unk18 = 0U; + } + temp_r5 = var_r5 + 0x20; + temp_r11_2 = (RumbleControllerMgr*)(this->channels + temp_r5); + if (((u32)temp_r11_2->unk18 != 0U) && (arg0 == (s32)temp_r11_2->unk8)) { + temp_r11_2->unk0 = 0.0f; + temp_r11_2->unk4 = 0.0f; + temp_r11_2->unk8 = -1; + temp_r11_2->unkC = 0; + temp_r11_2->unk10 = 0; + temp_r11_2->unk14 = 0; + temp_r11_2->unk18 = 0U; + } + temp_r5_2 = temp_r5 + 0x20; + temp_r11_3 = (RumbleControllerMgr*)(this->channels + temp_r5_2); + if (((u32)temp_r11_3->unk18 != 0U) && (arg0 == (s32)temp_r11_3->unk8)) { + temp_r11_3->unk0 = 0.0f; + temp_r11_3->unk4 = 0.0f; + temp_r11_3->unk8 = -1; + temp_r11_3->unkC = 0; + temp_r11_3->unk10 = 0; + temp_r11_3->unk14 = 0; + temp_r11_3->unk18 = 0U; + } + temp_r5_3 = temp_r5_2 + 0x20; + temp_r11_4 = (RumbleControllerMgr*)(this->channels + temp_r5_3); + if (((u32)temp_r11_4->unk18 != 0U) && (arg0 == (s32)temp_r11_4->unk8)) { + temp_r11_4->unk0 = 0.0f; + temp_r11_4->unk4 = 0.0f; + temp_r11_4->unk8 = -1; + temp_r11_4->unkC = 0; + temp_r11_4->unk10 = 0; + temp_r11_4->unk14 = 0; + temp_r11_4->unk18 = 0U; + } + var_r5 = temp_r5_3 + 0x20; + var_ctr -= 1; + } while (var_ctr != 0); +#endif +} + +void RumbleControllerMgr::updateMotorCount() +{ + u16 temp_r4_2; + u32 temp_r4; + + if ((s8)unk12 != 0) { + temp_r4 = unkC; + if (temp_r4 != 0U) { + unkC = temp_r4 - 1; + return; + } + unk12 = 0; + motorTime = 0; + return; + } + if (unkC > RumbleMgr::mMotorCountLimit) { + unk12 = 1; + return; + } + temp_r4_2 = motorTime; + if (temp_r4_2 != 0) { + motorTime = temp_r4_2 - 1; + unkC += 1; + return; + } + unkC = 0U; +} + +void RumbleControllerMgr::update() +{ + // RumbleChannelMgr::update(); + RumbleMgr::mPowerThreshold; +} + +RumbleMgr::RumbleMgr(bool bController1Avail, bool bController2Avail, + bool bController3Avail, bool bController4Avail) +{ + bool aControllers[4]; + this->m_masterIntensityL = 0.0f; + this->m_masterIntensityR = 0.0f; + aControllers[0] = bController1Avail; + aControllers[1] = bController2Avail; + aControllers[2] = bController3Avail; + aControllers[3] = bController4Avail; + + for (int i = 0; i < 4; ++i) { + if (aControllers[i]) { + RumbleControllerMgr* pMgr = new RumbleControllerMgr(); + if (pMgr) { + pMgr->currentPower = 0.0f; + pMgr->channels = new RumbleChannelMgr[MAX_RUMBLE_CHANNELS]; + } + this->m_controllerManagers[i] = pMgr; + + RumbleControllerState* pState = new RumbleControllerState(); + if (pState) { + pState->m_currentIntensityL = 0.0f; + pState->m_currentIntensityR = 0.0f; + pState->m_controllerIndex = i; + } + this->m_controllerStates[i] = pState; + } + } + + int* pOutput = new int; + if (pOutput) + *pOutput = 0; + + this->m_rumbleOutput = (const int***)pOutput; + this->m_isInitialized = TRUE; + this->m_flags = 1; +} + +void RumbleMgr::init() { channelDataTbl; } + +void RumbleMgr::reset() { PADControlMotor(0, 0); } + +void RumbleMgr::start(int a2, float* a3) +{ + if (!this->m_flags && this->m_isInitialized) { + if (this->m_controllerManagers[0]) + this->m_controllerManagers[0]->start(a2, 1, a3); + } +} + +void RumbleMgr::start(int a2, Vec* a3) +{ + if (!this->m_flags && this->m_isInitialized) { + if (this->m_controllerManagers[0]) + this->m_controllerManagers[0]->start(a2, 1, a3); + } +} + +void RumbleMgr::start(int arg0, int arg1, f32* arg2) +{ + if (!this->m_flags && this->m_isInitialized) { + if (this->m_controllerManagers[0]) + this->m_controllerManagers[0]->start(arg0, arg1, arg2); + } +} + +void RumbleMgr::start(int a2, int a3, Vec* a4) +{ + if (!this->m_flags && this->m_isInitialized) { + if (this->m_controllerManagers[0]) { + this->m_controllerManagers[0]->start(a2, a3, a4); + } + } +} + +void RumbleMgr::stop() { } + +void RumbleMgr::stop(int arg0) +{ + if ((this->m_flags == false) && (this->m_isInitialized != false) + && this->m_controllerManagers[0] != 0) { + this->m_controllerManagers[0]->stop(arg0); + } +} + +void RumbleMgr::update() +{ + s32 a = mPowerThreshold; + s32 b = mMotorTimerPeriod; + s32 c = a * b; + // unk0 = c; +} + +void RumbleMgr::setActive(bool activeState) +{ + int v3; // r30 + int v4; // r31 + RumbleControllerMgr* v5; // r3 + RumbleControllerState* v6; // r29 + float* v7; // r3 + + this->m_isInitialized = activeState; + if (!this->m_isInitialized) { + v3 = 0; + v4 = 0; + this->m_masterIntensityL = 0.0; + this->m_masterIntensityR = 0.0; + do { + v5 = this->m_controllerManagers[v4]; + if (v5) { + v5->reset(); + v6 = m_controllerStates[v4]; + PADControlMotor(v6->m_controllerIndex, PAD_MOTOR_STOP_HARD); + v6->m_currentIntensityL = 0.0f; + v6->m_currentIntensityR = 0.0f; + } + ++v3; + ++v4; + } while (v3 < 4); + this->m_flags = 0; + } +} + +void RumbleMgr::startPause() +{ + int padIter; // r31 + int i; // r30 + RumbleControllerState* theControllerState; // r3 + + padIter = 0; + for (i = 0; i < 4; ++i) { + theControllerState = this->m_controllerStates[padIter]; + if (theControllerState) + PADControlMotor(theControllerState->m_controllerIndex, + PAD_MOTOR_STOP_HARD); + ++padIter; + } + this->m_flags = 1; +} + +void RumbleMgr::finishPause() +{ + this->m_masterIntensityR = 0.5; + this->m_flags = 0; +} From 3addbdc29dcb16b82b2fd8d65b02ae301e2fd825 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Wed, 22 Oct 2025 20:38:23 +0200 Subject: [PATCH 11/24] oops --- src/MarioUtil/RumbleMgr.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/MarioUtil/RumbleMgr.cpp b/src/MarioUtil/RumbleMgr.cpp index 08d2dc1c..a3d47844 100644 --- a/src/MarioUtil/RumbleMgr.cpp +++ b/src/MarioUtil/RumbleMgr.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -15,8 +16,8 @@ RumbleChannelMgr::RumbleChannelMgr() mCurrentIntensity = 0.0f; mChannelID = -1; mLoopCount = 0; - mExternalDampenPtr = nullptr; - mPositionalSourcePtr = nullptr; + mExternalDampenPtr = 0; + mPositionalSourcePtr = 0; rumbleData = 0; } From 68d1d76abb61f092be76af053f8ed2da6814e1d6 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Wed, 22 Oct 2025 20:40:21 +0200 Subject: [PATCH 12/24] how were u not clang formatted --- include/MarioUtil/RumbleMgr.hpp | 38 ++++++++++++++++----------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/include/MarioUtil/RumbleMgr.hpp b/include/MarioUtil/RumbleMgr.hpp index ad72dbab..55b546bc 100644 --- a/include/MarioUtil/RumbleMgr.hpp +++ b/include/MarioUtil/RumbleMgr.hpp @@ -5,7 +5,7 @@ #include #include -#define MAX_RUMBLE_ID (25) +#define MAX_RUMBLE_ID (25) #define MAX_RUMBLE_CHANNELS (32) struct RumbleChannelData { @@ -25,14 +25,14 @@ class RumbleChannelMgr { f32 update(); public: - /* 0x00 */ f32 mElapsedTime; /* inferred */ - /* 0x04 */ f32 mCurrentIntensity; /* inferred */ - /* 0x08 */ s32 mChannelID; /* inferred */ - /* 0x0C */ s32 mLoopCount; /* inferred */ - /* 0x10 */ f32* mExternalDampenPtr; /* inferred */ - /* 0x14 */ Vec* mPositionalSourcePtr; /* inferred */ - /* 0x18 */ const RumbleChannelData* rumbleData; /* inferred */ - /* 0x1C */ void* unk20; /* inferred */ + /* 0x00 */ f32 mElapsedTime; /* inferred */ + /* 0x04 */ f32 mCurrentIntensity; /* inferred */ + /* 0x08 */ s32 mChannelID; /* inferred */ + /* 0x0C */ s32 mLoopCount; /* inferred */ + /* 0x10 */ f32* mExternalDampenPtr; /* inferred */ + /* 0x14 */ Vec* mPositionalSourcePtr; /* inferred */ + /* 0x18 */ const RumbleChannelData* rumbleData; /* inferred */ + /* 0x1C */ void* unk20; /* inferred */ }; class RumbleControllerMgr { @@ -46,13 +46,13 @@ class RumbleControllerMgr { void update(); public: - f32 currentPower; // 0x00 - RumbleChannelMgr *channels; // 0x04 - RumbleChannelMgr *unk8; // 0x08 - u32 unkC; // 0x0C - u16 motorTime; // 0x10 - bool unk12; // 0x12 - u8 padding_13; // 0x13 + f32 currentPower; // 0x00 + RumbleChannelMgr* channels; // 0x04 + RumbleChannelMgr* unk8; // 0x08 + u32 unkC; // 0x0C + u16 motorTime; // 0x10 + bool unk12; // 0x12 + u8 padding_13; // 0x13 }; class RumbleMgr; @@ -91,11 +91,11 @@ class RumbleMgr { f32 m_masterIntensityL; // 0x00 f32 m_masterIntensityR; // 0x04 bool m_isInitialized; // 0x08 - bool m_flags; // 0x09 - bool unkA; // 0x0A + bool m_flags; // 0x09 + bool unkA; // 0x0A RumbleControllerState* m_controllerStates[4]; // 0x0C RumbleControllerMgr* m_controllerManagers[4]; // 0x1C - const int *** m_rumbleOutput; // 0x2C + const int*** m_rumbleOutput; // 0x2C static u32 mMotorCountLimit; static u16 mMotorTimerPeriod; From 95e52fbc0b40bf4bd5fc5a8f0d8533f00c91c0fa Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Thu, 23 Oct 2025 01:10:18 +0200 Subject: [PATCH 13/24] decompile more --- include/MarioUtil/RumbleMgr.hpp | 5 +- src/MarioUtil/RumbleMgr.cpp | 176 +++++++++++++++++--------------- 2 files changed, 94 insertions(+), 87 deletions(-) diff --git a/include/MarioUtil/RumbleMgr.hpp b/include/MarioUtil/RumbleMgr.hpp index 55b546bc..3e4d6e81 100644 --- a/include/MarioUtil/RumbleMgr.hpp +++ b/include/MarioUtil/RumbleMgr.hpp @@ -40,10 +40,10 @@ class RumbleControllerMgr { void reset(); void start(int channelId, int loopCount, float* externalDampenPtr); void start(int channelId, int loopCount, Vec* positionalSourcePtr); - void stop(int); + void stop(int channelId); void channelMgrIsAllFree(); void updateMotorCount(); - void update(); + f32 update(); public: f32 currentPower; // 0x00 @@ -97,6 +97,7 @@ class RumbleMgr { RumbleControllerMgr* m_controllerManagers[4]; // 0x1C const int*** m_rumbleOutput; // 0x2C +public: static u32 mMotorCountLimit; static u16 mMotorTimerPeriod; static f32 mPowerThreshold; diff --git a/src/MarioUtil/RumbleMgr.cpp b/src/MarioUtil/RumbleMgr.cpp index a3d47844..f35891fd 100644 --- a/src/MarioUtil/RumbleMgr.cpp +++ b/src/MarioUtil/RumbleMgr.cpp @@ -1,3 +1,4 @@ +#include "dolphin/types.h" #include #include #include @@ -72,13 +73,11 @@ f32 RumbleChannelMgr::update() void RumbleControllerMgr::reset() { - this->currentPower = 0.0f; - this->unkC = 0; - this->motorTime = 0; - this->unk12 = false; + currentPower = 0.0f; - for (s32 i = 0; i < MAX_RUMBLE_CHANNELS; i++) { - RumbleChannelMgr* channel = &this->channels[i]; + // @FIXME: registers arent being assigned correctly during the unroll + for (u32 i = 0; i < MAX_RUMBLE_CHANNELS; ++i) { + RumbleChannelMgr* channel = &channels[i]; channel->mElapsedTime = 0.0f; channel->mCurrentIntensity = 0.0f; channel->mChannelID = -1; @@ -87,8 +86,13 @@ void RumbleControllerMgr::reset() channel->mPositionalSourcePtr = 0; channel->rumbleData = 0; } + + unkC = 0; + motorTime = 0; + unk12 = false; } +#pragma dont_inline on void RumbleControllerMgr::start(int channelId, int loopCount, float* externalDampenPtr) { @@ -123,71 +127,22 @@ void RumbleControllerMgr::start(int channelId, int loopCount, } } -void RumbleControllerMgr::stop(int arg0) +void RumbleControllerMgr::stop(int channelId) { - -#if 0 - s32 temp_r5; - s32 temp_r5_2; - s32 temp_r5_3; - s32 var_ctr; - s32 var_r5; - RumbleControllerMgr* temp_r11; - RumbleControllerMgr* temp_r11_2; - RumbleControllerMgr* temp_r11_3; - RumbleControllerMgr* temp_r11_4; - - var_r5 = 0; - var_ctr = 8; - do { - temp_r11 = (RumbleControllerMgr*)(this->channels + var_r5); - if (((u32)temp_r11->unk18 != 0U) && (arg0 == (s32)temp_r11->unk8)) { - temp_r11->unk0 = 0.0f; - temp_r11->unk4 = 0.0f; - temp_r11->unk8 = -1; - temp_r11->unkC = 0; - temp_r11->unk10 = 0; - temp_r11->unk14 = 0; - temp_r11->unk18 = 0U; - } - temp_r5 = var_r5 + 0x20; - temp_r11_2 = (RumbleControllerMgr*)(this->channels + temp_r5); - if (((u32)temp_r11_2->unk18 != 0U) && (arg0 == (s32)temp_r11_2->unk8)) { - temp_r11_2->unk0 = 0.0f; - temp_r11_2->unk4 = 0.0f; - temp_r11_2->unk8 = -1; - temp_r11_2->unkC = 0; - temp_r11_2->unk10 = 0; - temp_r11_2->unk14 = 0; - temp_r11_2->unk18 = 0U; - } - temp_r5_2 = temp_r5 + 0x20; - temp_r11_3 = (RumbleControllerMgr*)(this->channels + temp_r5_2); - if (((u32)temp_r11_3->unk18 != 0U) && (arg0 == (s32)temp_r11_3->unk8)) { - temp_r11_3->unk0 = 0.0f; - temp_r11_3->unk4 = 0.0f; - temp_r11_3->unk8 = -1; - temp_r11_3->unkC = 0; - temp_r11_3->unk10 = 0; - temp_r11_3->unk14 = 0; - temp_r11_3->unk18 = 0U; - } - temp_r5_3 = temp_r5_2 + 0x20; - temp_r11_4 = (RumbleControllerMgr*)(this->channels + temp_r5_3); - if (((u32)temp_r11_4->unk18 != 0U) && (arg0 == (s32)temp_r11_4->unk8)) { - temp_r11_4->unk0 = 0.0f; - temp_r11_4->unk4 = 0.0f; - temp_r11_4->unk8 = -1; - temp_r11_4->unkC = 0; - temp_r11_4->unk10 = 0; - temp_r11_4->unk14 = 0; - temp_r11_4->unk18 = 0U; + for (u32 i = 0; i < MAX_RUMBLE_CHANNELS; ++i) { + RumbleChannelMgr* channel = &channels[i]; + if (channel->rumbleData && channelId == channel->mChannelID) { + channel->mElapsedTime = 0.0f; + channel->mCurrentIntensity = 0.0f; + channel->mChannelID = -1; + channel->mLoopCount = 0; + channel->mExternalDampenPtr = 0; + channel->mPositionalSourcePtr = 0; + channel->rumbleData = 0; } - var_r5 = temp_r5_3 + 0x20; - var_ctr -= 1; - } while (var_ctr != 0); -#endif + } } +#pragma dont_inline off void RumbleControllerMgr::updateMotorCount() { @@ -217,10 +172,46 @@ void RumbleControllerMgr::updateMotorCount() unkC = 0U; } -void RumbleControllerMgr::update() +f32 RumbleControllerMgr::update() { - // RumbleChannelMgr::update(); - RumbleMgr::mPowerThreshold; + RumbleChannelMgr* temp_r3; + f32 temp_f0; + f32 temp_f1; + f32 var_f31; + s32 var_r30; + s32 var_r31; + + var_r31 = 0; + var_r30 = 0; + var_f31 = 0.0f; + do { + temp_r3 = this->channels + var_r31; + if (temp_r3->rumbleData != 0) { + this->currentPower = temp_r3->update(); + temp_f0 = this->currentPower; + if (temp_f0 > var_f31) { + var_f31 = temp_f0; + } + } + var_r30 += 1; + var_r31 += 0x20; + } while (var_r30 < 0x20); + + currentPower = var_f31; + temp_f1 = currentPower; + if (temp_f1 > 1.0f) { + currentPower = 1.0f; + } else if (temp_f1 < 0.0f) { + currentPower = 0.0f; + } + + if (currentPower > RumbleMgr::mPowerThreshold) { + motorTime = RumbleMgr::mPowerThreshold; + } + if (unk12 != false) { + currentPower = 0.0f; + } + return currentPower; } RumbleMgr::RumbleMgr(bool bController1Avail, bool bController2Avail, @@ -268,33 +259,44 @@ void RumbleMgr::reset() { PADControlMotor(0, 0); } void RumbleMgr::start(int a2, float* a3) { + int index = 0; + if (!this->m_flags && this->m_isInitialized) { - if (this->m_controllerManagers[0]) - this->m_controllerManagers[0]->start(a2, 1, a3); + if (this->m_controllerManagers[index]) { + this->m_controllerManagers[index]->start(a2, 1, a3); + } } } void RumbleMgr::start(int a2, Vec* a3) { + int index = 0; + if (!this->m_flags && this->m_isInitialized) { - if (this->m_controllerManagers[0]) - this->m_controllerManagers[0]->start(a2, 1, a3); + if (this->m_controllerManagers[index]) { + this->m_controllerManagers[index]->start(a2, 1, a3); + } } } void RumbleMgr::start(int arg0, int arg1, f32* arg2) { + int index = 0; + if (!this->m_flags && this->m_isInitialized) { - if (this->m_controllerManagers[0]) - this->m_controllerManagers[0]->start(arg0, arg1, arg2); + if (this->m_controllerManagers[index]) { + this->m_controllerManagers[index]->start(arg0, arg1, arg2); + } } } void RumbleMgr::start(int a2, int a3, Vec* a4) { + int index = 0; + if (!this->m_flags && this->m_isInitialized) { - if (this->m_controllerManagers[0]) { - this->m_controllerManagers[0]->start(a2, a3, a4); + if (this->m_controllerManagers[index]) { + this->m_controllerManagers[index]->start(a2, a3, a4); } } } @@ -303,17 +305,21 @@ void RumbleMgr::stop() { } void RumbleMgr::stop(int arg0) { - if ((this->m_flags == false) && (this->m_isInitialized != false) - && this->m_controllerManagers[0] != 0) { - this->m_controllerManagers[0]->stop(arg0); + int index = 0; + + if (!this->m_flags && this->m_isInitialized) { + if (this->m_controllerManagers[index]) { + this->m_controllerManagers[index]->stop(arg0); + } } } void RumbleMgr::update() { - s32 a = mPowerThreshold; - s32 b = mMotorTimerPeriod; - s32 c = a * b; + f32 fuck = SMSGetVSyncTimesPerSec(); + s32 a = fuck * mPowerThreshold; + s32 b = mMotorTimerPeriod; + s32 c = a * b; // unk0 = c; } From 8a3df323f0649b3e7fa1a57a653b746dcc2e2d7b Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Thu, 23 Oct 2025 20:17:53 +0200 Subject: [PATCH 14/24] work some more on MovieRumble --- include/GC2D/MovieRumble.hpp | 18 ++++++++++++++++++ src/GC2D/MovieRumble.cpp | 37 +++++------------------------------- src/MarioUtil/RumbleData.cpp | 2 -- 3 files changed, 23 insertions(+), 34 deletions(-) diff --git a/include/GC2D/MovieRumble.hpp b/include/GC2D/MovieRumble.hpp index e3609449..d328f2cc 100644 --- a/include/GC2D/MovieRumble.hpp +++ b/include/GC2D/MovieRumble.hpp @@ -23,6 +23,24 @@ class TMovieRumble : public JDrama::TViewObj { s32 endFrame; s32 rumbleTypeIndex; bool isRumbleActive; + +private: + inline void updateRumbleState(Koga::ToolData* toolData, s32 entryIndex) + { + const char* rumbleTypeString; + s32 theEntryIndex = entryIndex; + bool isDataValid = (toolData != nullptr) && (theEntryIndex >= 0); + + if (isDataValid && toolData->isIndexValid(theEntryIndex)) { + // get this rumble entry's data, and update this instance + toolData->GetValue(theEntryIndex, "start_frame", startFrame); + toolData->GetValue(theEntryIndex, "end_frame", endFrame); + toolData->GetValue(theEntryIndex, "type", rumbleTypeString); + rumbleTypeIndex = RumbleType::getIndex((char*)rumbleTypeString); + } else { + rumbleTypeIndex = -1; + } + } }; #endif // GC2D_MOVIE_RUMBLE_HPP diff --git a/src/GC2D/MovieRumble.cpp b/src/GC2D/MovieRumble.cpp index 0ea51f49..f1959a3e 100644 --- a/src/GC2D/MovieRumble.cpp +++ b/src/GC2D/MovieRumble.cpp @@ -15,7 +15,7 @@ void TMovieRumble::init(const char* subtitleName) char szSubtitlePath[128]; sprintf(szSubtitlePath, "/subtitle/rnbl/%s", subtitleName); szSubtitlePathExtension = (char*)strrchr(szSubtitlePath, 46); - strcpy(szSubtitlePathExtension, ".bcr"); + char* result = strcpy(szSubtitlePathExtension, ".bcr"); Koga::ToolData* data = new Koga::ToolData; toolData = data; @@ -27,22 +27,10 @@ void TMovieRumble::init(const char* subtitleName) else entryIndex = 0; - const char* rumbleTypeString; + Koga::ToolData* pData = toolData; + s32 nextEntryIndex = entryIndex; - Koga::ToolData* pData = toolData; - s32 nextEntryIndex = entryIndex; - bool dataAndIndexValid = (pData != nullptr) && (nextEntryIndex >= 0); - - // this if statement feels wrong - if (dataAndIndexValid && (nextEntryIndex < pData->mData->mNumEntries)) { - // get this rumble entry's data, and update this instance - pData->GetValue(nextEntryIndex, "start_frame", startFrame); - pData->GetValue(nextEntryIndex, "end_frame", endFrame); - pData->GetValue(nextEntryIndex, "type", rumbleTypeString); - rumbleTypeIndex = RumbleType::getIndex((char*)rumbleTypeString); - } else { - rumbleTypeIndex = -1; - } + updateRumbleState(pData, nextEntryIndex); isRumbleActive = false; } @@ -69,25 +57,10 @@ void TMovieRumble::checkRumbleOff() if (endFrame <= thpRenderer->frameNumber) { SMSRumbleMgr->stop(); entryIndex++; - const char* rumbleTypeString; Koga::ToolData* pData = toolData; s32 nextEntryIndex = entryIndex; - bool dataAndIndexValid - = (pData != nullptr) && (nextEntryIndex >= 0); - - // this if statement feels wrong - if (dataAndIndexValid - && (nextEntryIndex < pData->mData->mNumEntries)) { - // get this rumble entry's data, and update this instance - pData->GetValue(nextEntryIndex, "start_frame", startFrame); - pData->GetValue(nextEntryIndex, "end_frame", endFrame); - pData->GetValue(nextEntryIndex, "type", rumbleTypeString); - rumbleTypeIndex = RumbleType::getIndex((char*)rumbleTypeString); - } else { - rumbleTypeIndex = -1; - } - + updateRumbleState(pData, nextEntryIndex); isRumbleActive = false; } } diff --git a/src/MarioUtil/RumbleData.cpp b/src/MarioUtil/RumbleData.cpp index d22b6043..35954507 100644 --- a/src/MarioUtil/RumbleData.cpp +++ b/src/MarioUtil/RumbleData.cpp @@ -1,7 +1,5 @@ #include -#define MAX_RUMBLE_ID (25) - static int rumblePoint_00 = 11; static float rumbleFrame_00[] = { 0.0f, 0.05f, 0.1f, 0.15f, 0.2f, 0.25f, 0.25f, 0.33f, 0.4f, 0.5f, 0.6f, From dc672d3d56d59bf70acf6e58fccbed4ad743c6f4 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Thu, 23 Oct 2025 20:20:56 +0200 Subject: [PATCH 15/24] forgor this --- include/MarioUtil/ToolData.hpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/include/MarioUtil/ToolData.hpp b/include/MarioUtil/ToolData.hpp index 65068ca8..fdc1c74b 100644 --- a/include/MarioUtil/ToolData.hpp +++ b/include/MarioUtil/ToolData.hpp @@ -24,6 +24,11 @@ class ToolData { inline bool dataExists() const { return !!mData; } + inline bool isIndexValid(s32 entryIndex) + { + return entryIndex < mData->mNumEntries; + } + // JMAP value types, ignored in sunshine #define JMAP_VALUE_TYPE_LONG 0 #define JMAP_VALUE_TYPE_STRING 1 From 894d9fa062e03d6712426a76ef382c7c9d02742b Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Thu, 18 Dec 2025 11:56:20 +0100 Subject: [PATCH 16/24] mostly decompile rumble stuff now, still needs a lot of work though --- include/MarioUtil/RumbleMgr.hpp | 3 +- src/GC2D/MovieRumble.cpp | 15 +- src/MarioUtil/RumbleMgr.cpp | 280 ++++++++++++++++++++++++++++---- src/MarioUtil/RumbleType.cpp | 2 +- 4 files changed, 258 insertions(+), 42 deletions(-) diff --git a/include/MarioUtil/RumbleMgr.hpp b/include/MarioUtil/RumbleMgr.hpp index 3e4d6e81..72365e73 100644 --- a/include/MarioUtil/RumbleMgr.hpp +++ b/include/MarioUtil/RumbleMgr.hpp @@ -93,9 +93,10 @@ class RumbleMgr { bool m_isInitialized; // 0x08 bool m_flags; // 0x09 bool unkA; // 0x0A + bool unkB; // 0x0B RumbleControllerState* m_controllerStates[4]; // 0x0C RumbleControllerMgr* m_controllerManagers[4]; // 0x1C - const int*** m_rumbleOutput; // 0x2C + const RumbleChannelData** m_rumbleOutput; // 0x2C public: static u32 mMotorCountLimit; diff --git a/src/GC2D/MovieRumble.cpp b/src/GC2D/MovieRumble.cpp index f1959a3e..f3c17682 100644 --- a/src/GC2D/MovieRumble.cpp +++ b/src/GC2D/MovieRumble.cpp @@ -11,11 +11,10 @@ TMovieRumble::TMovieRumble(const TTHPRender* thpRender) void TMovieRumble::init(const char* subtitleName) { - char* szSubtitlePathExtension; char szSubtitlePath[128]; sprintf(szSubtitlePath, "/subtitle/rnbl/%s", subtitleName); - szSubtitlePathExtension = (char*)strrchr(szSubtitlePath, 46); - char* result = strcpy(szSubtitlePathExtension, ".bcr"); + char* szSubtitlePathExtension = (char*)strrchr(szSubtitlePath, '.'); + char* result = strcpy(szSubtitlePathExtension, ".bcr"); Koga::ToolData* data = new Koga::ToolData; toolData = data; @@ -41,8 +40,9 @@ void TMovieRumble::perform(u32 flags, JDrama::TGraphics* graphics) if (isRumbleActive) { checkRumbleOff(); } else { - if (rumbleTypeIndex != -1 - && startFrame <= thpRenderer->frameNumber) { + bool rumbleTypeValid = rumbleTypeIndex != -1; + if (rumbleTypeValid + && startFrame <= thpRenderer->getFrameNumber()) { SMSRumbleMgr->start(rumbleTypeIndex, -1, (float*)0); isRumbleActive = true; } @@ -53,8 +53,9 @@ void TMovieRumble::perform(u32 flags, JDrama::TGraphics* graphics) #pragma dont_inline on void TMovieRumble::checkRumbleOff() { - if (rumbleTypeIndex != -1) { - if (endFrame <= thpRenderer->frameNumber) { + bool rumbleTypeValid = rumbleTypeIndex != -1; + if (rumbleTypeValid) { + if (endFrame <= thpRenderer->getFrameNumber()) { SMSRumbleMgr->stop(); entryIndex++; diff --git a/src/MarioUtil/RumbleMgr.cpp b/src/MarioUtil/RumbleMgr.cpp index f35891fd..fdac9e2f 100644 --- a/src/MarioUtil/RumbleMgr.cpp +++ b/src/MarioUtil/RumbleMgr.cpp @@ -1,9 +1,9 @@ #include "dolphin/types.h" -#include #include #include -#include #include +#include +#include RumbleMgr* SMSRumbleMgr; @@ -26,40 +26,37 @@ f32 RumbleChannelMgr::update() { f32 dampenFactor; f32* externalDampenSource = this->mExternalDampenPtr; - f32 temp_f31 = 1.0f / SMSGetVSyncTimesPerSec(); + f32 targetFrameTime = 1.0f / SMSGetVSyncTimesPerSec(); if (externalDampenSource != NULL) { - f32 temp_f1; - temp_f1 = *externalDampenSource; - dampenFactor = temp_f1; - if (temp_f1 < 0.0f) { + dampenFactor = *mExternalDampenPtr; + if (dampenFactor >= 0.0f) { + if (dampenFactor > 1.0f) + dampenFactor = 1.0f; + } else { dampenFactor = 0.0f; - } else if (dampenFactor > 1.0f) { - dampenFactor = 1.0f; } } else { if (this->mPositionalSourcePtr != NULL) { - f32 temp_f2; - JGeometry::TVec3 temp; - temp.set(SMS_GetMarioPos()); - temp -= *this->mPositionalSourcePtr; - // temp = SMS_GetMarioPos() - *this->mPositionalSourcePtr; - f32 distance = temp.length(); // why are you getting inlined :( - // dampenFactor = clamp(distance, 0, 1); + f32 distance + = (SMS_GetMarioPos() - *this->mPositionalSourcePtr).length(); + const f32 kScaleFactor = 1.0f / 3000.0f; + distance = -((kScaleFactor * (distance - 300.0f)) - 1.0f); dampenFactor = distance; - if (distance < 0.0f) { + if (distance >= 0.0f) { + if (distance > 1.0f) + dampenFactor = 1.0f; + } else { dampenFactor = 0.0f; - } else if (dampenFactor > 1.0f) { - dampenFactor = 1.0f; } } else { dampenFactor = 1.0f; } } - this->mCurrentIntensity = 0.0; + this->mCurrentIntensity = 0.0f; if (!this->mLoopCount) { - this->mElapsedTime = 0.0; - this->mCurrentIntensity = 0.0; + this->mElapsedTime = 0.0f; + this->mCurrentIntensity = 0.0f; this->mChannelID = -1; this->mLoopCount = 0; this->mExternalDampenPtr = 0; @@ -67,6 +64,58 @@ f32 RumbleChannelMgr::update() this->rumbleData = 0; } + if (this->rumbleData) { + int totalRumblePoints = 0; + int rumblePointIterator = 0; + int keyframeIndex = 0; + + this->mElapsedTime = this->mElapsedTime + targetFrameTime; + + while (true) { + totalRumblePoints = *this->rumbleData->point; + if (rumblePointIterator >= totalRumblePoints - 1) + break; + float* currentFrame = this->rumbleData->frame; + + if (this->mElapsedTime > this->rumbleData->frame[keyframeIndex]) { + float lerpFactor = 1.0f; + if ((this->rumbleData->frame[keyframeIndex + 1] + - this->rumbleData->frame[keyframeIndex]) + <= 0.0) + lerpFactor = 1.0f; + else + lerpFactor = ((this->mElapsedTime + - this->rumbleData->frame[keyframeIndex]) + / (this->rumbleData->frame[keyframeIndex + 1] + - this->rumbleData->frame[keyframeIndex])); + this->mCurrentIntensity + = ((1.0f - lerpFactor) * rumbleData->power[keyframeIndex]) + + (lerpFactor * rumbleData->power[keyframeIndex + 1]); + } + + ++rumblePointIterator; + ++keyframeIndex; + break; + } + + if (this->mElapsedTime > rumbleData->frame[totalRumblePoints - 1]) { + if (this->mLoopCount <= 1) { + this->mElapsedTime = 0.0f; + if (mLoopCount >= 0) { + this->mCurrentIntensity = 0.0f; + this->mChannelID = -1; + this->mLoopCount = 0; + this->mExternalDampenPtr = 0; + this->mPositionalSourcePtr = 0; + this->rumbleData = 0; + } + } else { + this->mElapsedTime = 0.0f; + --this->mLoopCount; + } + } + } + this->mCurrentIntensity *= dampenFactor; return this->mCurrentIntensity; } @@ -244,18 +293,89 @@ RumbleMgr::RumbleMgr(bool bController1Avail, bool bController2Avail, } } - int* pOutput = new int; - if (pOutput) + const RumbleChannelData** pOutput = (const RumbleChannelData**)new int; + if (pOutput != nullptr) { *pOutput = 0; + } - this->m_rumbleOutput = (const int***)pOutput; + this->m_rumbleOutput = pOutput; this->m_isInitialized = TRUE; this->m_flags = 1; } -void RumbleMgr::init() { channelDataTbl; } +void RumbleMgr::init() +{ + this->m_masterIntensityL = 0.0f; + this->m_masterIntensityR = 0.0f; + + for (int i = 0; i < 4; ++i) { + RumbleControllerMgr* pControllerMgr = this->m_controllerManagers[i]; + + if (pControllerMgr != nullptr) { + pControllerMgr->currentPower = 0.0f; + for (int ch = 0; ch < MAX_RUMBLE_CHANNELS; ++ch) { + void* unk20 = pControllerMgr->unk8; + RumbleChannelMgr& channel = pControllerMgr->channels[ch]; + + channel.mElapsedTime = 0.0f; + channel.mCurrentIntensity = 0.0f; + channel.mChannelID = -1; + channel.mLoopCount = 0; + channel.mExternalDampenPtr = nullptr; + channel.mPositionalSourcePtr = nullptr; + channel.rumbleData = nullptr; + channel.unk20 = unk20; + } + + RumbleControllerState* pState = this->m_controllerStates[i]; + pState->m_currentIntensityL = 0.0f; + pState->m_currentIntensityR = 0.0f; + } + } + + *this->m_rumbleOutput = channelDataTbl; + this->m_isInitialized = true; + + this->m_flags = true; + this->unkA = false; +} + +void RumbleMgr::reset() +{ + this->m_masterIntensityL = 0.0f; + this->m_masterIntensityR = 0.0f; + + for (int i = 0; i < 4; ++i) { + RumbleControllerMgr* pMgr = this->m_controllerManagers[i]; + + if (pMgr != nullptr) { + pMgr->currentPower = 0.0f; + for (int ch = 0; ch < MAX_RUMBLE_CHANNELS; ++ch) { + RumbleChannelMgr& channel = pMgr->channels[ch]; + + channel.mElapsedTime = 0.0f; + channel.mCurrentIntensity = 0.0f; + channel.mChannelID = -1; + channel.mLoopCount = 0; + channel.mExternalDampenPtr = nullptr; + channel.mPositionalSourcePtr = nullptr; + channel.rumbleData = nullptr; + } -void RumbleMgr::reset() { PADControlMotor(0, 0); } + pMgr->unkC = 0; + pMgr->motorTime = 0; + pMgr->unk12 = false; + + RumbleControllerState* pState = this->m_controllerStates[i]; + PADControlMotor(pState->m_controllerIndex, PAD_MOTOR_STOP_HARD); + + pState->m_currentIntensityL = 0.0f; + pState->m_currentIntensityR = 0.0f; + } + } + + this->m_flags = false; +} void RumbleMgr::start(int a2, float* a3) { @@ -301,7 +421,30 @@ void RumbleMgr::start(int a2, int a3, Vec* a4) } } -void RumbleMgr::stop() { } +void RumbleMgr::stop() +{ + for (int controllerPort = 0; controllerPort < 4; controllerPort++) { + RumbleControllerMgr* controllerMgr + = this->m_controllerManagers[controllerPort]; + + if (controllerMgr != nullptr) { + for (int rumbleChannel = 0; rumbleChannel < MAX_RUMBLE_CHANNELS; + rumbleChannel++) { + RumbleChannelMgr& channel + = controllerMgr->channels[rumbleChannel]; + if (channel.rumbleData != nullptr) { + channel.mElapsedTime = 0.0f; + channel.mCurrentIntensity = 0.0f; + channel.mChannelID = -1; + channel.mLoopCount = 0; + channel.mExternalDampenPtr = nullptr; + channel.mPositionalSourcePtr = nullptr; + channel.rumbleData = nullptr; + } + } + } + } +} void RumbleMgr::stop(int arg0) { @@ -316,11 +459,82 @@ void RumbleMgr::stop(int arg0) void RumbleMgr::update() { - f32 fuck = SMSGetVSyncTimesPerSec(); - s32 a = fuck * mPowerThreshold; - s32 b = mMotorTimerPeriod; - s32 c = a * b; - // unk0 = c; + float delta = 1.0f / SMSGetVSyncTimesPerSec(); + + if (!this->m_flags && this->m_isInitialized) { + for (int i = 0; i < 4; ++i) { + RumbleControllerMgr* controller = this->m_controllerManagers[i]; + + if (controller) { + bool isSilent = true; + for (int ch = 0; ch < MAX_RUMBLE_CHANNELS; ch++) { + RumbleChannelMgr& channel = controller->channels[ch]; + if (channel.rumbleData != nullptr + || channel.mElapsedTime != 0.0f) { + isSilent = false; + break; + } + } + + RumbleControllerState* state = this->m_controllerStates[i]; + + if (isSilent) { + PADControlMotor(state->m_controllerIndex, + PAD_MOTOR_STOP_HARD); + state->m_currentIntensityL = 0.0f; + state->m_currentIntensityR = 0.0f; + } else { + this->m_masterIntensityL = controller->update(); + + if (this->m_masterIntensityR > 0.0f) { + this->m_masterIntensityL + = this->m_masterIntensityL + * ((1.0f - this->m_masterIntensityL) + * (this->m_masterIntensityR / 0.5f) + + 1.0f); + } + + if (this->m_masterIntensityL <= 1.0f) { + if (this->m_masterIntensityL < 0.0f) { + this->m_masterIntensityL = 0.0f; + } + } else { + this->m_masterIntensityL = 1.0f; + } + + state->m_currentIntensityL = this->m_masterIntensityL; + state->m_currentIntensityR += state->m_currentIntensityL; + + if (state->m_currentIntensityL > 0.0f) { + if (state->m_currentIntensityR >= 1.0f) { + state->m_currentIntensityR -= 1.0f; + PADControlMotor(state->m_controllerIndex, + PAD_MOTOR_RUMBLE); + } else { + if (this->unkA) + PADControlMotor(state->m_controllerIndex, + PAD_MOTOR_STOP_HARD); + else + PADControlMotor(state->m_controllerIndex, + PAD_MOTOR_STOP); + } + } else { + if (this->unkA) + PADControlMotor(state->m_controllerIndex, + PAD_MOTOR_STOP_HARD); + else + PADControlMotor(state->m_controllerIndex, + PAD_MOTOR_STOP); + } + } + controller->updateMotorCount(); + } + } + + if (this->m_masterIntensityR > 0.0f) { + this->m_masterIntensityR = this->m_masterIntensityR - delta; + } + } } void RumbleMgr::setActive(bool activeState) diff --git a/src/MarioUtil/RumbleType.cpp b/src/MarioUtil/RumbleType.cpp index 8a172521..8a6541c5 100644 --- a/src/MarioUtil/RumbleType.cpp +++ b/src/MarioUtil/RumbleType.cpp @@ -6,7 +6,7 @@ extern int channelNum; struct UnkStruct3B0378 { unsigned int unk0; - char* str; + const char* str; }; // Enum To Str? From babf253fb1cc5c27781a60beb02258df8547bab6 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Thu, 18 Dec 2025 12:05:27 +0100 Subject: [PATCH 17/24] make TTHPRender::getFrameNumber an inline getter --- include/System/THPRender.hpp | 5 ++++- src/System/THPRender.cpp | 2 ++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/include/System/THPRender.hpp b/include/System/THPRender.hpp index 3c5d17a2..43893e90 100644 --- a/include/System/THPRender.hpp +++ b/include/System/THPRender.hpp @@ -10,8 +10,11 @@ class TTHPRender : public JDrama::TViewObj { public: - virtual void perform(u32, JDrama::TGraphics*); /* override */ + void perform(u32, JDrama::TGraphics*); /* override */ TTHPRender(const char* name); + ~TTHPRender(); + + inline s32 getFrameNumber() const { return frameNumber; } /* 0x10 */ u32 x; /* 0x14 */ u32 y; diff --git a/src/System/THPRender.cpp b/src/System/THPRender.cpp index ba804864..6a9de146 100644 --- a/src/System/THPRender.cpp +++ b/src/System/THPRender.cpp @@ -1,5 +1,7 @@ #include +TTHPRender::~TTHPRender() {} + void TTHPRender::perform(u32 flags, JDrama::TGraphics* gfx) { if ((flags & 8)) { From 0d60d6486f4a4df9f4fe67ca7e2e65588421e066 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Thu, 18 Dec 2025 12:10:39 +0100 Subject: [PATCH 18/24] clang format --- src/System/THPRender.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/System/THPRender.cpp b/src/System/THPRender.cpp index 6a9de146..8fad89f4 100644 --- a/src/System/THPRender.cpp +++ b/src/System/THPRender.cpp @@ -1,6 +1,6 @@ #include -TTHPRender::~TTHPRender() {} +TTHPRender::~TTHPRender() { } void TTHPRender::perform(u32 flags, JDrama::TGraphics* gfx) { From dd1eabebda57951a8bc1949138184907dcd9a871 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Sat, 24 Jan 2026 23:49:40 +0100 Subject: [PATCH 19/24] fix: improve RumbleMgr --- src/MarioUtil/RumbleMgr.cpp | 85 ++++++++++++++++++------------------- 1 file changed, 41 insertions(+), 44 deletions(-) diff --git a/src/MarioUtil/RumbleMgr.cpp b/src/MarioUtil/RumbleMgr.cpp index fdac9e2f..60890972 100644 --- a/src/MarioUtil/RumbleMgr.cpp +++ b/src/MarioUtil/RumbleMgr.cpp @@ -220,47 +220,43 @@ void RumbleControllerMgr::updateMotorCount() } unkC = 0U; } +#define CLAMP(val, min, max) \ + ((val) > (max) ? (max) : (val) < (min) ? (min) : (val)) + +inline f32 clamp(f32 val, f32 min, f32 max) { + float value = val; + if (val > max) + return max; + return value; + if (val < min) + value = min; + return value; +} f32 RumbleControllerMgr::update() { - RumbleChannelMgr* temp_r3; - f32 temp_f0; - f32 temp_f1; - f32 var_f31; - s32 var_r30; - s32 var_r31; - - var_r31 = 0; - var_r30 = 0; - var_f31 = 0.0f; - do { - temp_r3 = this->channels + var_r31; - if (temp_r3->rumbleData != 0) { - this->currentPower = temp_r3->update(); - temp_f0 = this->currentPower; - if (temp_f0 > var_f31) { - var_f31 = temp_f0; + float maxCurrentPower = 0.0f; + + for (int channelIdx = 0; channelIdx < MAX_RUMBLE_CHANNELS; ++channelIdx) { + RumbleChannelMgr* currChannelManager = &this->channels[channelIdx]; + + if (currChannelManager->rumbleData) { + this->currentPower = currChannelManager->update(); + + if (this->currentPower > maxCurrentPower) { + maxCurrentPower = this->currentPower; } } - var_r30 += 1; - var_r31 += 0x20; - } while (var_r30 < 0x20); - - currentPower = var_f31; - temp_f1 = currentPower; - if (temp_f1 > 1.0f) { - currentPower = 1.0f; - } else if (temp_f1 < 0.0f) { - currentPower = 0.0f; } - if (currentPower > RumbleMgr::mPowerThreshold) { - motorTime = RumbleMgr::mPowerThreshold; - } - if (unk12 != false) { - currentPower = 0.0f; - } - return currentPower; + // this->currentPower = CLAMP(maxCurrentPower, 0.0f, 1.0f); + this->currentPower = clamp(maxCurrentPower, 0.0f, 1.0f); + + if (this->currentPower > RumbleMgr::mPowerThreshold) + this->motorTime = RumbleMgr::mMotorTimerPeriod; + if (this->unk12) + this->currentPower = 0.0f; + return this->currentPower; } RumbleMgr::RumbleMgr(bool bController1Avail, bool bController2Avail, @@ -377,46 +373,46 @@ void RumbleMgr::reset() this->m_flags = false; } -void RumbleMgr::start(int a2, float* a3) +void RumbleMgr::start(int channelId, float* externalDampenPtr) { int index = 0; if (!this->m_flags && this->m_isInitialized) { if (this->m_controllerManagers[index]) { - this->m_controllerManagers[index]->start(a2, 1, a3); + this->m_controllerManagers[index]->start(channelId, 1, externalDampenPtr); } } } -void RumbleMgr::start(int a2, Vec* a3) +void RumbleMgr::start(int channelId, Vec* positionalSourcePtr) { int index = 0; if (!this->m_flags && this->m_isInitialized) { if (this->m_controllerManagers[index]) { - this->m_controllerManagers[index]->start(a2, 1, a3); + this->m_controllerManagers[index]->start(channelId, 1, positionalSourcePtr); } } } -void RumbleMgr::start(int arg0, int arg1, f32* arg2) +void RumbleMgr::start(int channelId, int loopCount, f32* externalDampenPtr) { int index = 0; if (!this->m_flags && this->m_isInitialized) { if (this->m_controllerManagers[index]) { - this->m_controllerManagers[index]->start(arg0, arg1, arg2); + this->m_controllerManagers[index]->start(channelId, loopCount, externalDampenPtr); } } } -void RumbleMgr::start(int a2, int a3, Vec* a4) +void RumbleMgr::start(int channelId, int loopCount, Vec* positionalSourcePtr) { int index = 0; if (!this->m_flags && this->m_isInitialized) { if (this->m_controllerManagers[index]) { - this->m_controllerManagers[index]->start(a2, a3, a4); + this->m_controllerManagers[index]->start(channelId, loopCount, positionalSourcePtr); } } } @@ -432,6 +428,7 @@ void RumbleMgr::stop() rumbleChannel++) { RumbleChannelMgr& channel = controllerMgr->channels[rumbleChannel]; + if (channel.rumbleData != nullptr) { channel.mElapsedTime = 0.0f; channel.mCurrentIntensity = 0.0f; @@ -446,13 +443,13 @@ void RumbleMgr::stop() } } -void RumbleMgr::stop(int arg0) +void RumbleMgr::stop(int channelId) { int index = 0; if (!this->m_flags && this->m_isInitialized) { if (this->m_controllerManagers[index]) { - this->m_controllerManagers[index]->stop(arg0); + this->m_controllerManagers[index]->stop(channelId); } } } From 797c219c89c1ccb3af0d9d3647157fa612ae16a9 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Sat, 21 Feb 2026 19:49:38 +0100 Subject: [PATCH 20/24] fix: why did the merge request mess these up --- include/MarioUtil/RumbleMgr.hpp | 127 +++-- include/MarioUtil/RumbleType.hpp | 4 +- src/GC2D/MovieRumble.cpp | 110 ++-- src/MarioUtil/RumbleData.cpp | 432 +++++++-------- src/MarioUtil/RumbleMgr.cpp | 914 ++++++++++++++++--------------- src/MarioUtil/RumbleType.cpp | 23 +- 6 files changed, 820 insertions(+), 790 deletions(-) diff --git a/include/MarioUtil/RumbleMgr.hpp b/include/MarioUtil/RumbleMgr.hpp index 72365e73..e009bc5e 100644 --- a/include/MarioUtil/RumbleMgr.hpp +++ b/include/MarioUtil/RumbleMgr.hpp @@ -1,58 +1,88 @@ #ifndef MARIO_UTIL_RUMBLE_MGR_HPP #define MARIO_UTIL_RUMBLE_MGR_HPP +#include #include #include -#include -#define MAX_RUMBLE_ID (25) -#define MAX_RUMBLE_CHANNELS (32) +#define RUMBLE_CHANNELS_PER_CONTROLLER 32 -struct RumbleChannelData { - int* point; - float* frame; - float* power; +struct RumbleChannelDataTbl { + int* mPointData; + float* mFrameData; + float* mPowerData; }; -extern const RumbleChannelData channelDataTbl[]; -extern int channelNum; +extern RumbleChannelDataTbl channelDataTbl[]; -// RumbleMgr +class RumbleBase { +public: + RumbleBase(int chan) + : mPower(0.0f) + , mAccumulator(0.0f) + , mChan(chan) + { + } + void init(); + void stop(); + void update(f32, bool); + + f32 mPower; + f32 mAccumulator; + int mChan; +}; + +class RumbleChannelDataMgr { +public: + RumbleChannelDataMgr() + : mChannelDataTbl(nullptr) + { + } + void init(); + RumbleChannelDataTbl* getChannelDataTbl(int); + + RumbleChannelDataTbl* mChannelDataTbl; +}; class RumbleChannelMgr { public: RumbleChannelMgr(); + void init(RumbleChannelDataMgr*); + void reset(); + void repeat(); + void start(int, int, f32*); + void start(int, int, Vec*); f32 update(); -public: - /* 0x00 */ f32 mElapsedTime; /* inferred */ - /* 0x04 */ f32 mCurrentIntensity; /* inferred */ - /* 0x08 */ s32 mChannelID; /* inferred */ - /* 0x0C */ s32 mLoopCount; /* inferred */ - /* 0x10 */ f32* mExternalDampenPtr; /* inferred */ - /* 0x14 */ Vec* mPositionalSourcePtr; /* inferred */ - /* 0x18 */ const RumbleChannelData* rumbleData; /* inferred */ - /* 0x1C */ void* unk20; /* inferred */ + f32 mElapsedTime; + f32 mPower; + int mChannelDataIdx; + int mRepeatCount; + f32* mMultiplierF; + Vec* mWorldPos; + RumbleChannelDataTbl* mChannelDataTbl; + RumbleChannelDataMgr* mChannelDataMgr; }; class RumbleControllerMgr { public: + RumbleControllerMgr(); + void init(); void reset(); - void start(int channelId, int loopCount, float* externalDampenPtr); - void start(int channelId, int loopCount, Vec* positionalSourcePtr); - void stop(int channelId); - void channelMgrIsAllFree(); + void start(int, int, f32*); + void start(int, int, Vec*); + void stop(); + void stop(int); + bool channelMgrIsAllFree(); void updateMotorCount(); f32 update(); -public: - f32 currentPower; // 0x00 - RumbleChannelMgr* channels; // 0x04 - RumbleChannelMgr* unk8; // 0x08 - u32 unkC; // 0x0C - u16 motorTime; // 0x10 - bool unk12; // 0x12 - u8 padding_13; // 0x13 + f32 mPower; + RumbleChannelMgr* mChannelMgrTbl; + RumbleChannelDataMgr* mChannelDataMgr; + u32 mMotorCounter; + u16 mMotorTimer; + s8 unk12; }; class RumbleMgr; @@ -80,28 +110,21 @@ class RumbleMgr { void setActive(bool); void startPause(); void finishPause(); - -public: - struct RumbleControllerState { - f32 m_currentIntensityL; // 0x00 - f32 m_currentIntensityR; // 0x04 - s32 m_controllerIndex; // 0x08 - }; - - f32 m_masterIntensityL; // 0x00 - f32 m_masterIntensityR; // 0x04 - bool m_isInitialized; // 0x08 - bool m_flags; // 0x09 - bool unkA; // 0x0A - bool unkB; // 0x0B - RumbleControllerState* m_controllerStates[4]; // 0x0C - RumbleControllerMgr* m_controllerManagers[4]; // 0x1C - const RumbleChannelData** m_rumbleOutput; // 0x2C - -public: - static u32 mMotorCountLimit; + void changePause(); + void changeMode(); + + f32 mPower; + f32 mTimer; + bool mActive; + bool mPaused; + bool mStopHard; + RumbleBase* mRumbleBaseTbl[4]; + RumbleControllerMgr* mControllerMgrTbl[4]; + RumbleChannelDataMgr* mChannelDataMgr; + + static int mMotorCountLimit; static u16 mMotorTimerPeriod; static f32 mPowerThreshold; }; -#endif +#endif \ No newline at end of file diff --git a/include/MarioUtil/RumbleType.hpp b/include/MarioUtil/RumbleType.hpp index 7dff1dba..cb91eeac 100644 --- a/include/MarioUtil/RumbleType.hpp +++ b/include/MarioUtil/RumbleType.hpp @@ -3,8 +3,8 @@ class RumbleType { public: - float foo; static int getIndex(char* strIn); + static const char* getName(int index); }; -#endif +#endif \ No newline at end of file diff --git a/src/GC2D/MovieRumble.cpp b/src/GC2D/MovieRumble.cpp index f3c17682..4294d031 100644 --- a/src/GC2D/MovieRumble.cpp +++ b/src/GC2D/MovieRumble.cpp @@ -1,71 +1,91 @@ #include +#include #include +#include +#include +#include #include -#include -#include -TMovieRumble::TMovieRumble(const TTHPRender* thpRender) +// TODO: removeme +static const char* dummyMactorStringValue1 = "\0\0\0\0\0\0\0\0\0\0\0"; +static const char* SMS_NO_MEMORY_MESSAGE = "メモリが足りません\n"; + +TMovieRumble::TMovieRumble(const TTHPRender* param_1) + : unk10(param_1) { - thpRenderer = thpRender; } -void TMovieRumble::init(const char* subtitleName) +void TMovieRumble::init(const char* param_1) { - char szSubtitlePath[128]; - sprintf(szSubtitlePath, "/subtitle/rnbl/%s", subtitleName); - char* szSubtitlePathExtension = (char*)strrchr(szSubtitlePath, '.'); - char* result = strcpy(szSubtitlePathExtension, ".bcr"); - - Koga::ToolData* data = new Koga::ToolData; - toolData = data; - void* glbResource = JKRFileLoader::getGlbResource(szSubtitlePath); - toolData->Attach(glbResource); + char acStack_90[128]; + makeBcrName(acStack_90, 128, param_1); - if (toolData->dataExists() == FALSE) - entryIndex = -1; + unk14 = new Koga::ToolData; + void* bcr = JKRGetResource(acStack_90); + unk14->Attach(bcr); + if (!unk14->GetData()) + unk18 = -1; else - entryIndex = 0; + unk18 = 0; - Koga::ToolData* pData = toolData; - s32 nextEntryIndex = entryIndex; + readCurInfo(); + unk28 = false; +} - updateRumbleState(pData, nextEntryIndex); +void TMovieRumble::perform(u32 param_1, JDrama::TGraphics*) +{ + if (param_1 & 0x1) + movement(); +} - isRumbleActive = false; +void TMovieRumble::movement() +{ + if (unk28) { + checkRumbleOff(); + } else { + checkRumbleOn(); + } } -void TMovieRumble::perform(u32 flags, JDrama::TGraphics* graphics) +void TMovieRumble::checkRumbleOn() { - if ((flags & 1) != 0) { - if (isRumbleActive) { - checkRumbleOff(); - } else { - bool rumbleTypeValid = rumbleTypeIndex != -1; - if (rumbleTypeValid - && startFrame <= thpRenderer->getFrameNumber()) { - SMSRumbleMgr->start(rumbleTypeIndex, -1, (float*)0); - isRumbleActive = true; - } - } + if (unk24 != -1 && unk1C <= unk10->getFrameNumber()) { + SMSRumbleMgr->start(unk24, -1, (f32*)nullptr); + unk28 = true; } } #pragma dont_inline on void TMovieRumble::checkRumbleOff() { - bool rumbleTypeValid = rumbleTypeIndex != -1; - if (rumbleTypeValid) { - if (endFrame <= thpRenderer->getFrameNumber()) { - SMSRumbleMgr->stop(); - entryIndex++; - - Koga::ToolData* pData = toolData; - s32 nextEntryIndex = entryIndex; - updateRumbleState(pData, nextEntryIndex); - isRumbleActive = false; - } + if (unk24 != -1 && unk20 <= unk10->getFrameNumber()) { + SMSRumbleMgr->stop(); + unk18 += 1; + readCurInfo(); + unk28 = false; } } #pragma dont_inline off -TMovieRumble::~TMovieRumble() { } +void TMovieRumble::readCurInfo() +{ + int group = unk18; + + if (isValid() && group < unk14->GetGroupCount()) { + Koga::ToolData* toolData = unk14; + toolData->GetValue(group, "start_frame", unk1C); + toolData->GetValue(group, "end_frame", unk20); + const char* type; + toolData->GetValue(group, "type", type); + unk24 = RumbleType::getIndex((char*)type); + } else { + unk24 = -1; + } +} + +void TMovieRumble::makeBcrName(char* acStack_90, int, const char* param_1) +{ + sprintf(acStack_90, "/subtitle/rnbl/%s", param_1); + char* it = strrchr(acStack_90, '.'); + strcpy(it, ".bcr"); +} \ No newline at end of file diff --git a/src/MarioUtil/RumbleData.cpp b/src/MarioUtil/RumbleData.cpp index 35954507..0472fa58 100644 --- a/src/MarioUtil/RumbleData.cpp +++ b/src/MarioUtil/RumbleData.cpp @@ -1,277 +1,229 @@ +#include #include -static int rumblePoint_00 = 11; -static float rumbleFrame_00[] = { - 0.0f, 0.05f, 0.1f, 0.15f, 0.2f, 0.25f, 0.25f, 0.33f, 0.4f, 0.5f, 0.6f, -}; -static float rumblePower_00[] = { - 1.0f, 1.0f, 1.0f, 0.9f, 0.0f, 0.0f, 0.6f, 0.6f, 0.5f, 0.2f, 0.0f, -}; +static int rumblePoint_00 = 0x0000000B; + +static float rumbleFrame_00[11] + = { 0.0f, 0.05f, 0.1f, 0.15f, 0.2f, 0.25f, 0.25f, 0.33f, 0.4f, 0.5f, 0.6f }; + +static float rumblePower_00[11] + = { 1.0f, 1.0f, 1.0f, 0.9f, 0.0f, 0.0f, 0.6f, 0.6f, 0.5f, 0.2f, 0.0f }; -static int rumblePoint_01 = 24; -static float rumbleFrame_01[] = { +static int rumblePoint_01 = 0x00000018; + +static float rumbleFrame_01[24] = { 0.0f, 0.16f, 0.19f, 0.24f, 0.26f, 0.37f, 0.4f, 0.45f, 0.46f, 0.54f, 0.56f, 0.61f, 0.62f, 0.7f, 0.73f, 0.78f, 0.79f, 0.86f, 0.92f, 0.96f, 1.03f, 1.13f, 1.17f, 1.4f, }; -static float rumblePower_01[] = { + +static float rumblePower_01[24] = { 1.0f, 1.0f, 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, 0.0f, 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, 0.53f, 0.0f, 0.0f, 0.44f, 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f, }; -static int rumblePoint_02 = 2; -static float rumbleFrame_02[] = { - 0.0f, - 0.1f, -}; -static float rumblePower_02[] = { - 0.8f, - 0.6f, -}; +static int rumblePoint_02 = 0x00000002; -static int rumblePoint_03 = 2; -static float rumbleFrame_03[] = { - 0.0f, - 0.1f, -}; -static float rumblePower_03[] = { - 1.0f, - 1.0f, -}; +static float rumbleFrame_02[2] = { 0.0f, 0.1f }; -static int rumblePoint_04 = 7; -static float rumbleFrame_04[] = { - 0.0f, 0.1f, 0.15f, 0.2f, 0.25f, 0.3f, 0.5f, -}; -static float rumblePower_04[] = { - 1.0f, 1.0f, 0.0f, 0.8f, 0.8f, 0.0f, 0.0f, -}; +static float rumblePower_02[2] = { 0.8f, 0.6f }; -static int rumblePoint_05 = 21; -static float rumbleFrame_05[] = { - 0.0f, 0.18f, 0.21f, 0.28f, 0.28f, 0.4f, 0.45f, 0.51f, 0.52f, 0.64f, 0.69f, - 0.75f, 0.83f, 0.89f, 0.99f, 1.03f, 1.12f, 1.19f, 1.25f, 1.3f, 1.4f, -}; -static float rumblePower_05[] = { - 1.0f, 0.92f, 0.0f, 0.0f, 0.79f, 0.63f, 0.0f, 0.02f, 0.45f, 0.31f, 0.02f, - 0.24f, 0.03f, 0.18f, 0.04f, 0.13f, 0.04f, 0.1f, 0.04f, 0.06f, 0.0f, -}; +static int rumblePoint_03 = 0x00000002; -static int rumblePoint_06 = 10; -static float rumbleFrame_06[] = { - 0.0f, 0.09f, 0.09f, 0.1f, 0.17f, 0.17f, 0.18f, 0.26f, 0.26f, 0.5f, -}; -static float rumblePower_06[] = { - 0.85f, 0.85f, 0.1f, 0.45f, 0.45f, 0.05f, 0.25f, 0.25f, 0.01f, 0.0f, -}; +static float rumbleFrame_03[2] = { 0.0f, 0.1f }; -static int rumblePoint_07 = 20; -static float rumbleFrame_07[] = { - 0.0f, 0.11f, 0.12f, 0.13f, 0.2f, 0.21f, 0.29f, 0.31f, 0.33f, 0.41f, - 0.42f, 0.52f, 0.53f, 0.54f, 0.62f, 0.64f, 0.72f, 0.74f, 0.75f, 1.0f, -}; -static float rumblePower_07[] = { - 0.95f, 0.97f, 0.85f, 0.0f, 0.0f, 0.75f, 0.73f, 0.55f, 0.0f, 0.0f, - 0.6f, 0.63f, 0.32f, 0.0f, 0.0f, 0.51f, 0.48f, 0.19f, 0.02f, 0.0f, -}; +static float rumblePower_03[2] = { 1.0f, 1.0f }; -static int rumblePoint_08 = 4; -static float rumbleFrame_08[] = { - 0.0f, 0.3f, 0.5f, 0.7f, 1.0f, -}; -static float rumblePower_08[] = { - 1.0f, 0.5f, 0.35f, 0.5f, 1.0f, -}; +static int rumblePoint_04 = 0x00000007; -static int rumblePoint_09 = 4; -static float rumbleFrame_09[] = { - 0.0f, - 0.3f, - 0.5f, - 0.7f, -}; -static float rumblePower_09[] = { - 0.5f, - 0.24f, - 0.18f, - 0.23f, -}; +static float rumbleFrame_04[7] = { 0.0f, 0.1f, 0.15f, 0.2f, 0.25f, 0.3f, 0.5f }; -static int rumblePoint_10 = 1; -static float rumbleFrame_10[] = { - 0.0f, -}; -static float rumblePower_10[] = { - 0.0f, -}; +static float rumblePower_04[7] = { 1.0f, 1.0f, 0.0f, 0.8f, 0.8f, 0.0f, 0.0f }; -static int rumblePoint_11 = 1; -static float rumbleFrame_11[] = { - 0.0f, -}; -static float rumblePower_11[] = { - 0.0f, -}; +static int rumblePoint_05 = 0x00000015; -static int rumblePoint_12 = 1; -static float rumbleFrame_12[] = { - 0.0f, -}; -static float rumblePower_12[] = { - 0.0f, -}; +static float rumbleFrame_05[21] + = { 0.0f, 0.18f, 0.21f, 0.28f, 0.28f, 0.4f, 0.45f, + 0.51f, 0.52f, 0.64f, 0.69f, 0.75f, 0.83f, 0.89f, + 0.99f, 1.03f, 1.12f, 1.19f, 1.25f, 1.3f, 1.4f }; -static int rumblePoint_13 = 1; -static float rumbleFrame_13[] = { - 0.0f, -}; -static float rumblePower_13[] = { - 0.0f, -}; +static float rumblePower_05[21] + = { 1.0f, 0.92f, 0.0f, 0.0f, 0.79f, 0.63f, 0.0f, + 0.02f, 0.45f, 0.31f, 0.02f, 0.24f, 0.03f, 0.18f, + 0.04f, 0.13f, 0.04f, 0.1f, 0.04f, 0.06f, 0.0f }; -static int rumblePoint_14 = 1; -static float rumbleFrame_14[] = { - 0.0f, -}; -static float rumblePower_14[] = { - 0.0f, -}; +static int rumblePoint_06 = 0x0000000A; -static int rumblePoint_15 = 1; -static float rumbleFrame_15[] = { - 0.0f, -}; -static float rumblePower_15[] = { - 0.0f, -}; +static float rumbleFrame_06[10] + = { 0.0f, 0.09f, 0.09f, 0.1f, 0.17f, 0.17f, 0.18f, 0.26f, 0.26f, 0.5f }; -static int rumblePoint_16 = 1; -static float rumbleFrame_16[] = { - 0.0f, -}; -static float rumblePower_16[] = { - 0.0f, -}; +static float rumblePower_06[10] + = { 0.85f, 0.85f, 0.1f, 0.45f, 0.45f, 0.05f, 0.25f, 0.25f, 0.01f, 0.0f }; -static int rumblePoint_17 = 1; -static float rumbleFrame_17[] = { - 0.0f, -}; -static float rumblePower_17[] = { - 0.0f, -}; +static int rumblePoint_07 = 0x00000014; -static int rumblePoint_18 = 1; -static float rumbleFrame_18[] = { - 0.0f, -}; -static float rumblePower_18[] = { - 0.0f, -}; +static float rumbleFrame_07[20] + = { 0.0f, 0.11f, 0.12f, 0.13f, 0.2f, 0.21f, 0.29f, 0.31f, 0.33f, 0.41f, + 0.42f, 0.52f, 0.53f, 0.54f, 0.62f, 0.64f, 0.72f, 0.74f, 0.75f, 1.0f }; -static int rumblePoint_19 = 5; -static float rumbleFrame_19[] = { - 0.0f, 0.11f, 0.2f, 0.32f, 0.4f, -}; -static float rumblePower_19[] = { - 0.6f, 0.4f, 0.6f, 0.4f, 0.6f, -}; +static float rumblePower_07[20] + = { 0.95f, 0.97f, 0.85f, 0.0f, 0.0f, 0.75f, 0.73f, 0.55f, 0.0f, 0.0f, + 0.6f, 0.63f, 0.32f, 0.0f, 0.0f, 0.51f, 0.48f, 0.19f, 0.02f, 0.0f }; -static int rumblePoint_20 = 2; -static float rumbleFrame_20[] = { - 0.0f, - 0.01666666666f, -}; -static float rumblePower_20[] = { - 0.5f, - 0.5f, -}; +static int rumblePoint_08 = 0x00000004; -static int rumblePoint_21 = 2; -static float rumbleFrame_21[] = { - 0.0f, - 0.01666666666f, -}; -static float rumblePower_21[] = { - 0.75f, - 0.75f, -}; +static float rumbleFrame_08[5] = { 0.0f, 0.3f, 0.5f, 0.7f, 1.0f }; -static int rumblePoint_22 = 2; -static float rumbleFrame_22[] = { - 0.0f, - 2.0f, -}; -static float rumblePower_22[] = { - 0.75f, - 0.75f, -}; +static float rumblePower_08[5] = { 1.0f, 0.5f, 0.35f, 0.5f, 1.0f }; -static int rumblePoint_23 = 77; -static float rumbleFrame_23[] = { - 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, - 1.2f, 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, - 4.16f, 4.17f, 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, - 5.18f, 5.28f, 5.32f, 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, - 5.68f, 6.35f, 6.36f, 6.57f, 6.68f, 6.85f, 6.88f, 7.11f, 7.18f, - 7.5f, 7.66f, 8.09f, 8.67f, 9.08f, 9.1f, 9.63f, 9.64f, 9.65f, - 9.81f, 9.84f, 9.89f, 9.91f, 10.02f, 10.04f, 10.05f, 10.06f, 10.19f, - 10.21f, 10.22f, 10.23f, 10.35f, 10.38f, 10.43f, 10.45f, 10.51f, 10.57f, - 10.61f, 10.68f, 10.78f, 10.82f, 11.0f, -}; -static float rumblePower_23[] = { - 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, 0.72f, - 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, 0.95f, 0.53f, - 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, 0.27f, 0.69f, 0.55f, - 0.0f, 0.34f, 0.27f, 0.0f, 0.0f, 0.78f, 0.71f, 0.0f, 0.0f, 0.78f, 0.68f, - 0.0f, 0.0f, 0.42f, 0.72f, 0.87f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, - 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, 0.0f, 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, - 0.53f, 0.0f, 0.0f, 0.44f, 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f, -}; +static int rumblePoint_09 = 0x00000004; -static int rumblePoint_24 = 37; -static float rumbleFrame_24[] = { - 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, 1.2f, - 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, 4.16f, 4.17f, - 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, 5.18f, 5.28f, 5.32f, - 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, 5.68f, -}; -static float rumblePower_24[] = { - 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, - 0.72f, 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, - 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, - 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f, -}; +static float rumbleFrame_09[4] = { 0.0f, 0.3f, 0.5f, 0.7f }; + +static float rumblePower_09[4] = { 0.5f, 0.24f, 0.18f, 0.23f }; + +static int rumblePoint_10 = 0x00000001; + +static float rumbleFrame_10[1] = { 0.0f }; + +static float rumblePower_10[1] = { 0.0f }; + +static int rumblePoint_11 = 0x00000001; + +static float rumbleFrame_11[1] = { 0.0f }; + +static float rumblePower_11[1] = { 0.0f }; + +static int rumblePoint_12 = 0x00000001; + +static float rumbleFrame_12[1] = { 0.0f }; + +static float rumblePower_12[1] = { 0.0f }; + +static int rumblePoint_13 = 0x00000001; + +static float rumbleFrame_13[1] = { 0.0f }; + +static float rumblePower_13[1] = { 0.0f }; + +static int rumblePoint_14 = 0x00000001; + +static float rumbleFrame_14[1] = { 0.0f }; + +static float rumblePower_14[1] = { 0.0f }; + +static int rumblePoint_15 = 0x00000001; + +static float rumbleFrame_15[1] = { 0.0f }; + +static float rumblePower_15[1] = { 0.0f }; + +static int rumblePoint_16 = 0x00000001; + +static float rumbleFrame_16[1] = { 0.0f }; + +static float rumblePower_16[1] = { 0.0f }; + +static int rumblePoint_17 = 0x00000001; + +static float rumbleFrame_17[1] = { 0.0f }; + +static float rumblePower_17[1] = { 0.0f }; + +static int rumblePoint_18 = 0x00000001; + +static float rumbleFrame_18[1] = { 0.0f }; + +static float rumblePower_18[1] = { 0.0f }; + +static int rumblePoint_19 = 0x00000005; + +static float rumbleFrame_19[5] = { 0.0f, 0.11f, 0.2f, 0.32f, 0.4f }; + +static float rumblePower_19[5] = { 0.6f, 0.4f, 0.6f, 0.4f, 0.6f }; + +static int rumblePoint_20 = 0x00000002; + +static float rumbleFrame_20[2] = { 0.0f, 1.0f / 60.0f }; + +static float rumblePower_20[2] = { 0.5f, 0.5f }; + +static int rumblePoint_21 = 0x00000002; + +static float rumbleFrame_21[2] = { 0.0f, 1.0f / 60.0f }; + +static float rumblePower_21[2] = { 0.75f, 0.75f }; + +static int rumblePoint_22 = 0x00000002; + +static float rumbleFrame_22[2] = { 0.0f, 2.0f }; + +static float rumblePower_22[2] = { 0.75f, 0.75f }; + +static int rumblePoint_23 = 0x0000004D; + +static float rumbleFrame_23[77] + = { 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, + 1.2f, 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, + 4.16f, 4.17f, 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, + 5.18f, 5.28f, 5.32f, 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, + 5.68f, 6.35f, 6.36f, 6.57f, 6.68f, 6.85f, 6.88f, 7.11f, 7.18f, + 7.5f, 7.66f, 8.09f, 8.67f, 9.08f, 9.1f, 9.63f, 9.64f, 9.65f, + 9.81f, 9.84f, 9.89f, 9.91f, 10.02f, 10.04f, 10.05f, 10.06f, 10.19f, + 10.21f, 10.22f, 10.23f, 10.35f, 10.38f, 10.43f, 10.45f, 10.51f, 10.57f, + 10.61f, 10.68f, 10.78f, 10.82f, 11.0f }; + +static float rumblePower_23[77] + = { 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, + 0.72f, 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, + 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, + 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f, 0.0f, 0.78f, 0.71f, + 0.0f, 0.0f, 0.78f, 0.68f, 0.0f, 0.0f, 0.42f, 0.72f, 0.87f, 1.0f, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, + 0.0f, 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, 0.53f, 0.0f, 0.0f, 0.44f, + 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f }; + +static int rumblePoint_24 = 0x00000025; + +static float rumbleFrame_24[37] + = { 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, 1.2f, + 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, 4.16f, 4.17f, + 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, 5.18f, 5.28f, 5.32f, + 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, 5.68f }; + +static float rumblePower_24[37] + = { 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, + 0.72f, 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, + 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, + 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f }; -// clang-format off -const RumbleChannelData channelDataTbl[] = { - { &rumblePoint_00, rumbleFrame_00, rumblePower_00, }, - { &rumblePoint_01, rumbleFrame_01, rumblePower_01, }, - { &rumblePoint_02, rumbleFrame_02, rumblePower_02, }, - { &rumblePoint_03, rumbleFrame_03, rumblePower_03, }, - { &rumblePoint_04, rumbleFrame_04, rumblePower_04, }, - { &rumblePoint_05, rumbleFrame_05, rumblePower_05, }, - { &rumblePoint_06, rumbleFrame_06, rumblePower_06, }, - { &rumblePoint_07, rumbleFrame_07, rumblePower_07, }, - { &rumblePoint_08, rumbleFrame_08, rumblePower_08, }, - { &rumblePoint_09, rumbleFrame_09, rumblePower_09, }, - { &rumblePoint_10, rumbleFrame_10, rumblePower_10, }, - { &rumblePoint_11, rumbleFrame_11, rumblePower_11, }, - { &rumblePoint_12, rumbleFrame_12, rumblePower_12, }, - { &rumblePoint_13, rumbleFrame_13, rumblePower_13, }, - { &rumblePoint_14, rumbleFrame_14, rumblePower_14, }, - { &rumblePoint_15, rumbleFrame_15, rumblePower_15, }, - { &rumblePoint_16, rumbleFrame_16, rumblePower_16, }, - { &rumblePoint_17, rumbleFrame_17, rumblePower_17, }, - { &rumblePoint_18, rumbleFrame_18, rumblePower_18, }, - { &rumblePoint_19, rumbleFrame_19, rumblePower_19, }, - { &rumblePoint_20, rumbleFrame_20, rumblePower_20, }, - { &rumblePoint_21, rumbleFrame_21, rumblePower_21, }, - { &rumblePoint_22, rumbleFrame_22, rumblePower_22, }, - { &rumblePoint_23, rumbleFrame_23, rumblePower_23, }, - { &rumblePoint_24, rumbleFrame_24, rumblePower_24, }, +RumbleChannelDataTbl channelDataTbl[25] = { + { &rumblePoint_00, rumbleFrame_00, rumblePower_00 }, + { &rumblePoint_01, rumbleFrame_01, rumblePower_01 }, + { &rumblePoint_02, rumbleFrame_02, rumblePower_02 }, + { &rumblePoint_03, rumbleFrame_03, rumblePower_03 }, + { &rumblePoint_04, rumbleFrame_04, rumblePower_04 }, + { &rumblePoint_05, rumbleFrame_05, rumblePower_05 }, + { &rumblePoint_06, rumbleFrame_06, rumblePower_06 }, + { &rumblePoint_07, rumbleFrame_07, rumblePower_07 }, + { &rumblePoint_08, rumbleFrame_08, rumblePower_08 }, + { &rumblePoint_09, rumbleFrame_09, rumblePower_09 }, + { &rumblePoint_10, rumbleFrame_10, rumblePower_10 }, + { &rumblePoint_11, rumbleFrame_11, rumblePower_11 }, + { &rumblePoint_12, rumbleFrame_12, rumblePower_12 }, + { &rumblePoint_13, rumbleFrame_13, rumblePower_13 }, + { &rumblePoint_14, rumbleFrame_14, rumblePower_14 }, + { &rumblePoint_15, rumbleFrame_15, rumblePower_15 }, + { &rumblePoint_16, rumbleFrame_16, rumblePower_16 }, + { &rumblePoint_17, rumbleFrame_17, rumblePower_17 }, + { &rumblePoint_18, rumbleFrame_18, rumblePower_18 }, + { &rumblePoint_19, rumbleFrame_19, rumblePower_19 }, + { &rumblePoint_20, rumbleFrame_20, rumblePower_20 }, + { &rumblePoint_21, rumbleFrame_21, rumblePower_21 }, + { &rumblePoint_22, rumbleFrame_22, rumblePower_22 }, + { &rumblePoint_23, rumbleFrame_23, rumblePower_23 }, + { &rumblePoint_24, rumbleFrame_24, rumblePower_24 }, }; -// clang-format on -int channelNum = MAX_RUMBLE_ID; +int channelNum = ARRAY_COUNT(channelDataTbl); \ No newline at end of file diff --git a/src/MarioUtil/RumbleMgr.cpp b/src/MarioUtil/RumbleMgr.cpp index 60890972..f0fa87c1 100644 --- a/src/MarioUtil/RumbleMgr.cpp +++ b/src/MarioUtil/RumbleMgr.cpp @@ -1,588 +1,616 @@ -#include "dolphin/types.h" #include -#include -#include +#include #include -#include - -RumbleMgr* SMSRumbleMgr; +#include -u32 RumbleMgr::mMotorCountLimit = 900; +int RumbleMgr::mMotorCountLimit = 900; u16 RumbleMgr::mMotorTimerPeriod = 80; f32 RumbleMgr::mPowerThreshold = 0.5f; -RumbleChannelMgr::RumbleChannelMgr() +RumbleMgr* SMSRumbleMgr = nullptr; + +// Size needed: 0x10, current: 0x10 +void RumbleBase::init() { - mElapsedTime = 0.0f; - mCurrentIntensity = 0.0f; - mChannelID = -1; - mLoopCount = 0; - mExternalDampenPtr = 0; - mPositionalSourcePtr = 0; - rumbleData = 0; + mPower = 0.0f; + mAccumulator = 0.0f; } -f32 RumbleChannelMgr::update() +// Size needed: 0x28, current: 0x28 +void RumbleBase::stop() { PADControlMotor(mChan, PAD_MOTOR_STOP_HARD); } + +// Size needed: 0xAC, current: 0xA0 +void RumbleBase::update(f32 power, bool stopHard) { - f32 dampenFactor; - f32* externalDampenSource = this->mExternalDampenPtr; - f32 targetFrameTime = 1.0f / SMSGetVSyncTimesPerSec(); - if (externalDampenSource != NULL) { - dampenFactor = *mExternalDampenPtr; - if (dampenFactor >= 0.0f) { - if (dampenFactor > 1.0f) - dampenFactor = 1.0f; + // This function is the likely cause for stack mismatch in + // RumbleMgr::update() as it's the only one whose size mismatches. + mPower = power; + mAccumulator += mPower; + + if (mPower <= 0.0f) { + PADControlMotor(mChan, PAD_MOTOR_STOP_HARD); + } else if (mAccumulator < 1.0f) { + if (stopHard) { + PADControlMotor(mChan, PAD_MOTOR_STOP_HARD); } else { - dampenFactor = 0.0f; + PADControlMotor(mChan, PAD_MOTOR_STOP); } } else { - if (this->mPositionalSourcePtr != NULL) { - f32 distance - = (SMS_GetMarioPos() - *this->mPositionalSourcePtr).length(); - const f32 kScaleFactor = 1.0f / 3000.0f; - distance = -((kScaleFactor * (distance - 300.0f)) - 1.0f); - dampenFactor = distance; - if (distance >= 0.0f) { - if (distance > 1.0f) - dampenFactor = 1.0f; - } else { - dampenFactor = 0.0f; - } - } else { - dampenFactor = 1.0f; - } + // @fake - this doesn't fix our function size but it does match stack in + // RumbleMgr::update() + // f32 accumulator = mAccumulator; + // mAccumulator = accumulator - 1.0f; + mAccumulator -= 1.0f; + PADControlMotor(mChan, PAD_MOTOR_RUMBLE); } +} - this->mCurrentIntensity = 0.0f; - if (!this->mLoopCount) { - this->mElapsedTime = 0.0f; - this->mCurrentIntensity = 0.0f; - this->mChannelID = -1; - this->mLoopCount = 0; - this->mExternalDampenPtr = 0; - this->mPositionalSourcePtr = 0; - this->rumbleData = 0; - } - - if (this->rumbleData) { - int totalRumblePoints = 0; - int rumblePointIterator = 0; - int keyframeIndex = 0; - - this->mElapsedTime = this->mElapsedTime + targetFrameTime; - - while (true) { - totalRumblePoints = *this->rumbleData->point; - if (rumblePointIterator >= totalRumblePoints - 1) - break; - float* currentFrame = this->rumbleData->frame; - - if (this->mElapsedTime > this->rumbleData->frame[keyframeIndex]) { - float lerpFactor = 1.0f; - if ((this->rumbleData->frame[keyframeIndex + 1] - - this->rumbleData->frame[keyframeIndex]) - <= 0.0) - lerpFactor = 1.0f; - else - lerpFactor = ((this->mElapsedTime - - this->rumbleData->frame[keyframeIndex]) - / (this->rumbleData->frame[keyframeIndex + 1] - - this->rumbleData->frame[keyframeIndex])); - this->mCurrentIntensity - = ((1.0f - lerpFactor) * rumbleData->power[keyframeIndex]) - + (lerpFactor * rumbleData->power[keyframeIndex + 1]); - } +// Size needed: 0x10, current: 0x10 +void RumbleChannelDataMgr::init() { mChannelDataTbl = channelDataTbl; } - ++rumblePointIterator; - ++keyframeIndex; - break; +// Size needed: 0x14, current: 0x14 +RumbleChannelDataTbl* RumbleChannelDataMgr::getChannelDataTbl(int index) +{ + // This feels wrong, but I only see direct loads from channelDataTbl. + // Also, it only matches size when doing this. + return &channelDataTbl[index]; +} + +RumbleChannelMgr::RumbleChannelMgr() +{ + mElapsedTime = 0.0f; + mPower = 0.0f; + mChannelDataIdx = -1; + mRepeatCount = 0; + mMultiplierF = nullptr; + mWorldPos = nullptr; + mChannelDataTbl = nullptr; +} + +// Size needed: 0x30, current: 0x2C +void RumbleChannelMgr::init(RumbleChannelDataMgr* dataMgr) +{ + mElapsedTime = 0.0f; + mPower = 0.0f; + mChannelDataIdx = -1; + mRepeatCount = 0; + mMultiplierF = nullptr; + mWorldPos = nullptr; + mChannelDataTbl = nullptr; + mChannelDataMgr = dataMgr; +} + +// Size needed: 0x2C, current: 0x2C +void RumbleChannelMgr::reset() +{ + mElapsedTime = 0.0f; + mPower = 0.0f; + mChannelDataIdx = -1; + mRepeatCount = 0; + mMultiplierF = nullptr; + mWorldPos = nullptr; + mChannelDataTbl = nullptr; +} + +// Size needed: 0x0C, current: 0x0C +void RumbleChannelMgr::repeat() { mElapsedTime = 0.0f; } + +// Size needed: 0x2C, current: 0x2C +void RumbleChannelMgr::start(int channelDataIdx, int repeatCount, + f32* multiplierF) +{ + mElapsedTime = 0.0f; + mChannelDataTbl = mChannelDataMgr->getChannelDataTbl(channelDataIdx); + mChannelDataIdx = channelDataIdx; + mRepeatCount = repeatCount; + mMultiplierF = multiplierF; +} + +// Size needed: 0x2C, current: 0x2C +void RumbleChannelMgr::start(int channelDataIdx, int repeatCount, Vec* worldPos) +{ + mElapsedTime = 0.0f; + mChannelDataTbl = mChannelDataMgr->getChannelDataTbl(channelDataIdx); + mChannelDataIdx = channelDataIdx; + mRepeatCount = repeatCount; + mWorldPos = worldPos; +} + +f32 RumbleChannelMgr::update() +{ + f32 updateRate = 1.0f / SMSGetVSyncTimesPerSec(); + f32 mult; + + if (mMultiplierF != nullptr) { + mult = *mMultiplierF; + if (mult < 0.0f) { + mult = 0.0f; + } else if (mult > 1.0f) { + mult = 1.0f; + } + } else if (mWorldPos != nullptr) { + JGeometry::TVec3& v + = *static_cast*>(mWorldPos); + f32 dist = SMS_DistanceFromMario(v); + mult = -((dist - 300.0f) * (1.0f / 3000.0f) - 1.0f); + if (mult < 0.0f) { + mult = 0.0f; + } else if (mult > 1.0f) { + mult = 1.0f; } + } else { + mult = 1.0f; + } - if (this->mElapsedTime > rumbleData->frame[totalRumblePoints - 1]) { - if (this->mLoopCount <= 1) { - this->mElapsedTime = 0.0f; - if (mLoopCount >= 0) { - this->mCurrentIntensity = 0.0f; - this->mChannelID = -1; - this->mLoopCount = 0; - this->mExternalDampenPtr = 0; - this->mPositionalSourcePtr = 0; - this->rumbleData = 0; + mPower = 0.0f; + if (mRepeatCount == 0) { + reset(); + } + + if (mChannelDataTbl != nullptr) { + mElapsedTime += updateRate; + + for (int i = 0; i < *mChannelDataTbl->mPointData - 1; i++) { + if (mElapsedTime > mChannelDataTbl->mFrameData[i]) { + f32 delta = mChannelDataTbl->mFrameData[i + 1] + - mChannelDataTbl->mFrameData[i]; + f32 frameDelta = mElapsedTime - mChannelDataTbl->mFrameData[i]; + f32 progress; + + if (delta > 0.0f) { + progress = frameDelta / delta; + } else { + progress = 1.0f; } + + mPower = (1.0f - progress) * mChannelDataTbl->mPowerData[i] + + progress * mChannelDataTbl->mPowerData[i + 1]; + } + } + + if (mElapsedTime + > mChannelDataTbl->mFrameData[*mChannelDataTbl->mPointData - 1]) { + if (mRepeatCount > 1) { + repeat(); + mRepeatCount--; + } else if (mRepeatCount < 0) { + repeat(); } else { - this->mElapsedTime = 0.0f; - --this->mLoopCount; + reset(); } } } - this->mCurrentIntensity *= dampenFactor; - return this->mCurrentIntensity; + mPower *= mult; + return mPower; +} + +// Size needed: 0x58, current: 0x58 +RumbleControllerMgr::RumbleControllerMgr() +{ + mPower = 0.0f; + mChannelMgrTbl = new RumbleChannelMgr[RUMBLE_CHANNELS_PER_CONTROLLER]; +} + +// Size needed: 0x1C4, current: 0x19C +void RumbleControllerMgr::init() +{ + mPower = 0.0f; + + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + mChannelMgrTbl[i].init(mChannelDataMgr); + } } void RumbleControllerMgr::reset() { - currentPower = 0.0f; + mPower = 0.0f; - // @FIXME: registers arent being assigned correctly during the unroll - for (u32 i = 0; i < MAX_RUMBLE_CHANNELS; ++i) { - RumbleChannelMgr* channel = &channels[i]; - channel->mElapsedTime = 0.0f; - channel->mCurrentIntensity = 0.0f; - channel->mChannelID = -1; - channel->mLoopCount = 0; - channel->mExternalDampenPtr = 0; - channel->mPositionalSourcePtr = 0; - channel->rumbleData = 0; + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + mChannelMgrTbl[i].reset(); } - unkC = 0; - motorTime = 0; - unk12 = false; + mMotorCounter = 0; + mMotorTimer = 0; + unk12 = 0; } +// Hmm... why does this inline in RumbleMgr::start(int, f32*)? #pragma dont_inline on -void RumbleControllerMgr::start(int channelId, int loopCount, - float* externalDampenPtr) -{ - for (s32 i = 0; i < MAX_RUMBLE_CHANNELS; ++i) { - RumbleChannelMgr* channel = &this->channels[i]; - - if (channel->rumbleData == NULL) { - channel->mElapsedTime = 0.0f; - channel->rumbleData = &channelDataTbl[channelId]; - channel->mChannelID = channelId; - channel->mLoopCount = loopCount; - channel->mExternalDampenPtr = externalDampenPtr; - return; // Found a slot and started the rumble, so we exit +void RumbleControllerMgr::start(int channelDataIdx, int repeatCount, + f32* multiplierF) +{ + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + if (mChannelMgrTbl[i].mChannelDataTbl == nullptr) { + mChannelMgrTbl[i].start(channelDataIdx, repeatCount, multiplierF); + break; } } } +#pragma dont_inline reset -void RumbleControllerMgr::start(int channelId, int loopCount, - Vec* positionalSourcePtr) +// This one also inlines in RumbleMgr::start(int, Vec*)? +#pragma dont_inline on +void RumbleControllerMgr::start(int channelDataIdx, int repeatCount, + Vec* worldPos) { - for (s32 i = 0; i < MAX_RUMBLE_CHANNELS; ++i) { - RumbleChannelMgr* channel = &this->channels[i]; - - if (channel->rumbleData == NULL) { - channel->mElapsedTime = 0.0f; - channel->rumbleData = &channelDataTbl[channelId]; - channel->mChannelID = channelId; - channel->mLoopCount = loopCount; - channel->mPositionalSourcePtr = positionalSourcePtr; - return; // Found a slot and started the rumble, so we exit + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + if (mChannelMgrTbl[i].mChannelDataTbl == nullptr) { + mChannelMgrTbl[i].start(channelDataIdx, repeatCount, worldPos); + break; } } } +#pragma dont_inline reset -void RumbleControllerMgr::stop(int channelId) +// Size needed: 0x10C, current: 0x10C +void RumbleControllerMgr::stop() { - for (u32 i = 0; i < MAX_RUMBLE_CHANNELS; ++i) { - RumbleChannelMgr* channel = &channels[i]; - if (channel->rumbleData && channelId == channel->mChannelID) { - channel->mElapsedTime = 0.0f; - channel->mCurrentIntensity = 0.0f; - channel->mChannelID = -1; - channel->mLoopCount = 0; - channel->mExternalDampenPtr = 0; - channel->mPositionalSourcePtr = 0; - channel->rumbleData = 0; + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + if (mChannelMgrTbl[i].mChannelDataTbl != nullptr) { + mChannelMgrTbl[i].reset(); } } } -#pragma dont_inline off -void RumbleControllerMgr::updateMotorCount() +// This one also inlines in RumbleMgr::stop(int)? +#pragma dont_inline on +void RumbleControllerMgr::stop(int channelDataIdx) { - u16 temp_r4_2; - u32 temp_r4; - - if ((s8)unk12 != 0) { - temp_r4 = unkC; - if (temp_r4 != 0U) { - unkC = temp_r4 - 1; - return; + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + if (mChannelMgrTbl[i].mChannelDataTbl != nullptr + && mChannelMgrTbl[i].mChannelDataIdx == channelDataIdx) { + mChannelMgrTbl[i].reset(); } - unk12 = 0; - motorTime = 0; - return; } - if (unkC > RumbleMgr::mMotorCountLimit) { - unk12 = 1; - return; - } - temp_r4_2 = motorTime; - if (temp_r4_2 != 0) { - motorTime = temp_r4_2 - 1; - unkC += 1; - return; +} +#pragma dont_inline reset + +// Size needed: 0x11C, current: 0x11C +bool RumbleControllerMgr::channelMgrIsAllFree() +{ + bool allFree = true; + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + if (mChannelMgrTbl[i].mChannelDataTbl != nullptr) { + allFree = false; + } } - unkC = 0U; + return allFree; } -#define CLAMP(val, min, max) \ - ((val) > (max) ? (max) : (val) < (min) ? (min) : (val)) -inline f32 clamp(f32 val, f32 min, f32 max) { - float value = val; - if (val > max) - return max; - return value; - if (val < min) - value = min; - return value; +void RumbleControllerMgr::updateMotorCount() +{ + if (unk12) { + if (mMotorCounter > 0) { + mMotorCounter--; + } else { + unk12 = 0; + mMotorTimer = 0; + } + } else if (mMotorCounter > RumbleMgr::mMotorCountLimit) { + unk12 = 1; + } else if (mMotorTimer > 0) { + mMotorTimer--; + mMotorCounter++; + } else { + mMotorCounter = 0; + } } f32 RumbleControllerMgr::update() { - float maxCurrentPower = 0.0f; - - for (int channelIdx = 0; channelIdx < MAX_RUMBLE_CHANNELS; ++channelIdx) { - RumbleChannelMgr* currChannelManager = &this->channels[channelIdx]; - - if (currChannelManager->rumbleData) { - this->currentPower = currChannelManager->update(); - - if (this->currentPower > maxCurrentPower) { - maxCurrentPower = this->currentPower; + f32 maxPower = 0.0f; + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + if (mChannelMgrTbl[i].mChannelDataTbl != nullptr) { + mPower = mChannelMgrTbl[i].update(); + if (mPower > maxPower) { + maxPower = mPower; } } } - // this->currentPower = CLAMP(maxCurrentPower, 0.0f, 1.0f); - this->currentPower = clamp(maxCurrentPower, 0.0f, 1.0f); + mPower = maxPower; + if (mPower > 1.0f) { + mPower = 1.0f; + } else if (mPower < 0.0f) { + mPower = 0.0f; + } + + if (mPower > RumbleMgr::mPowerThreshold) { + mMotorTimer = RumbleMgr::mMotorTimerPeriod; + } - if (this->currentPower > RumbleMgr::mPowerThreshold) - this->motorTime = RumbleMgr::mMotorTimerPeriod; - if (this->unk12) - this->currentPower = 0.0f; - return this->currentPower; + if (unk12) { + mPower = 0.0f; + } + + return mPower; } -RumbleMgr::RumbleMgr(bool bController1Avail, bool bController2Avail, - bool bController3Avail, bool bController4Avail) +RumbleMgr::RumbleMgr(bool controller1, bool controller2, bool controller3, + bool controller4) { - bool aControllers[4]; - this->m_masterIntensityL = 0.0f; - this->m_masterIntensityR = 0.0f; - aControllers[0] = bController1Avail; - aControllers[1] = bController2Avail; - aControllers[2] = bController3Avail; - aControllers[3] = bController4Avail; + bool enable[4]; - for (int i = 0; i < 4; ++i) { - if (aControllers[i]) { - RumbleControllerMgr* pMgr = new RumbleControllerMgr(); - if (pMgr) { - pMgr->currentPower = 0.0f; - pMgr->channels = new RumbleChannelMgr[MAX_RUMBLE_CHANNELS]; - } - this->m_controllerManagers[i] = pMgr; + mPower = 0.0f; + mTimer = 0.0f; - RumbleControllerState* pState = new RumbleControllerState(); - if (pState) { - pState->m_currentIntensityL = 0.0f; - pState->m_currentIntensityR = 0.0f; - pState->m_controllerIndex = i; - } - this->m_controllerStates[i] = pState; - } - } + enable[0] = controller1; + enable[1] = controller2; + enable[2] = controller3; + enable[3] = controller4; - const RumbleChannelData** pOutput = (const RumbleChannelData**)new int; - if (pOutput != nullptr) { - *pOutput = 0; + for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { + mControllerMgrTbl[i] = nullptr; + mRumbleBaseTbl[i] = nullptr; + + if (enable[i]) { + mControllerMgrTbl[i] = new RumbleControllerMgr(); + mRumbleBaseTbl[i] = new RumbleBase(i); + } } - this->m_rumbleOutput = pOutput; - this->m_isInitialized = TRUE; - this->m_flags = 1; + mChannelDataMgr = nullptr; + mChannelDataMgr = new RumbleChannelDataMgr(); + mActive = true; + mPaused = false; + mStopHard = true; } void RumbleMgr::init() { - this->m_masterIntensityL = 0.0f; - this->m_masterIntensityR = 0.0f; - - for (int i = 0; i < 4; ++i) { - RumbleControllerMgr* pControllerMgr = this->m_controllerManagers[i]; - - if (pControllerMgr != nullptr) { - pControllerMgr->currentPower = 0.0f; - for (int ch = 0; ch < MAX_RUMBLE_CHANNELS; ++ch) { - void* unk20 = pControllerMgr->unk8; - RumbleChannelMgr& channel = pControllerMgr->channels[ch]; - - channel.mElapsedTime = 0.0f; - channel.mCurrentIntensity = 0.0f; - channel.mChannelID = -1; - channel.mLoopCount = 0; - channel.mExternalDampenPtr = nullptr; - channel.mPositionalSourcePtr = nullptr; - channel.rumbleData = nullptr; - channel.unk20 = unk20; - } + mPower = 0.0f; + mTimer = 0.0f; - RumbleControllerState* pState = this->m_controllerStates[i]; - pState->m_currentIntensityL = 0.0f; - pState->m_currentIntensityR = 0.0f; + for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { + if (mControllerMgrTbl[i] != nullptr) { + mControllerMgrTbl[i]->init(); + mRumbleBaseTbl[i]->init(); } } - *this->m_rumbleOutput = channelDataTbl; - this->m_isInitialized = true; - - this->m_flags = true; - this->unkA = false; + mChannelDataMgr->init(); + mActive = true; + mPaused = false; + mStopHard = true; } void RumbleMgr::reset() { - this->m_masterIntensityL = 0.0f; - this->m_masterIntensityR = 0.0f; - - for (int i = 0; i < 4; ++i) { - RumbleControllerMgr* pMgr = this->m_controllerManagers[i]; + mPower = 0.0f; + mTimer = 0.0f; + + for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { + if (mControllerMgrTbl[i] != nullptr) { + mControllerMgrTbl[i]->reset(); + mRumbleBaseTbl[i]->stop(); + mRumbleBaseTbl[i]->init(); + } + } - if (pMgr != nullptr) { - pMgr->currentPower = 0.0f; - for (int ch = 0; ch < MAX_RUMBLE_CHANNELS; ++ch) { - RumbleChannelMgr& channel = pMgr->channels[ch]; + mPaused = 0; +} - channel.mElapsedTime = 0.0f; - channel.mCurrentIntensity = 0.0f; - channel.mChannelID = -1; - channel.mLoopCount = 0; - channel.mExternalDampenPtr = nullptr; - channel.mPositionalSourcePtr = nullptr; - channel.rumbleData = nullptr; - } +void RumbleMgr::start(int channelDataIdx, f32* multiplierF) +{ + int controllerIdx = 0; - pMgr->unkC = 0; - pMgr->motorTime = 0; - pMgr->unk12 = false; + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, 1, multiplierF); + } +} - RumbleControllerState* pState = this->m_controllerStates[i]; - PADControlMotor(pState->m_controllerIndex, PAD_MOTOR_STOP_HARD); +void RumbleMgr::start(int channelDataIdx, Vec* worldPos) +{ + int controllerIdx = 0; - pState->m_currentIntensityL = 0.0f; - pState->m_currentIntensityR = 0.0f; - } + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, 1, worldPos); } +} + +// Size needed: 0x74, current: 0x74 +void RumbleMgr::start(int channelDataIdx, MtxPtr mtx) +{ + int controllerIdx = 0; - this->m_flags = false; + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + Vec worldPos; + worldPos.x = mtx[3][0]; + worldPos.y = mtx[3][1]; + worldPos.z = mtx[3][2]; + + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, 1, &worldPos); + } } -void RumbleMgr::start(int channelId, float* externalDampenPtr) +void RumbleMgr::start(int channelDataIdx, int repeatCount, f32* multiplierF) { - int index = 0; + int controllerIdx = 0; - if (!this->m_flags && this->m_isInitialized) { - if (this->m_controllerManagers[index]) { - this->m_controllerManagers[index]->start(channelId, 1, externalDampenPtr); - } + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, + multiplierF); } } -void RumbleMgr::start(int channelId, Vec* positionalSourcePtr) +void RumbleMgr::start(int channelDataIdx, int repeatCount, Vec* worldPos) { - int index = 0; + int controllerIdx = 0; - if (!this->m_flags && this->m_isInitialized) { - if (this->m_controllerManagers[index]) { - this->m_controllerManagers[index]->start(channelId, 1, positionalSourcePtr); - } + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, + worldPos); } } -void RumbleMgr::start(int channelId, int loopCount, f32* externalDampenPtr) +// Size needed: 0x70, current: 0x70 +void RumbleMgr::start(int channelDataIdx, int repeatCount, MtxPtr mtx) { - int index = 0; + int controllerIdx = 0; - if (!this->m_flags && this->m_isInitialized) { - if (this->m_controllerManagers[index]) { - this->m_controllerManagers[index]->start(channelId, loopCount, externalDampenPtr); - } + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + Vec worldPos; + worldPos.x = mtx[3][0]; + worldPos.y = mtx[3][1]; + worldPos.z = mtx[3][2]; + + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, + &worldPos); } } -void RumbleMgr::start(int channelId, int loopCount, Vec* positionalSourcePtr) +// Size needed: 0x94, current: 0x58 +void RumbleMgr::start(int controllerIdx, int channelDataIdx, int repeatCount, + f32* multiplierF) { - int index = 0; + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, + multiplierF); + } +} - if (!this->m_flags && this->m_isInitialized) { - if (this->m_controllerManagers[index]) { - this->m_controllerManagers[index]->start(channelId, loopCount, positionalSourcePtr); - } +// Size needed: 0x94, current: 0x58 +void RumbleMgr::start(int controllerIdx, int channelDataIdx, int repeatCount, + Vec* worldPos) +{ + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, + worldPos); } } +// Size needed: 0x7C, current: 0x74 +void RumbleMgr::start(int controllerIdx, int channelDataIdx, int repeatCount, + MtxPtr mtx) +{ + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + Vec worldPos; + worldPos.x = mtx[3][0]; + worldPos.y = mtx[3][1]; + worldPos.z = mtx[3][2]; + + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, + &worldPos); + } +} + +// @stack void RumbleMgr::stop() { - for (int controllerPort = 0; controllerPort < 4; controllerPort++) { - RumbleControllerMgr* controllerMgr - = this->m_controllerManagers[controllerPort]; - - if (controllerMgr != nullptr) { - for (int rumbleChannel = 0; rumbleChannel < MAX_RUMBLE_CHANNELS; - rumbleChannel++) { - RumbleChannelMgr& channel - = controllerMgr->channels[rumbleChannel]; - - if (channel.rumbleData != nullptr) { - channel.mElapsedTime = 0.0f; - channel.mCurrentIntensity = 0.0f; - channel.mChannelID = -1; - channel.mLoopCount = 0; - channel.mExternalDampenPtr = nullptr; - channel.mPositionalSourcePtr = nullptr; - channel.rumbleData = nullptr; - } - } + // @fake - this fixes our stack mismatch, perhaps a leftover debug print? + int stack[2]; + (void)stack; + + for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { + if (mControllerMgrTbl[i] != nullptr) { + mControllerMgrTbl[i]->stop(); } } } -void RumbleMgr::stop(int channelId) +void RumbleMgr::stop(int channelDataIdx) { - int index = 0; + int controllerIdx = 0; - if (!this->m_flags && this->m_isInitialized) { - if (this->m_controllerManagers[index]) { - this->m_controllerManagers[index]->stop(channelId); - } + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->stop(channelDataIdx); + } +} + +// Size needed: 0x178, current: 0x50 +void RumbleMgr::stop(int controllerIdx, int channelDataIdx) +{ + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->stop(channelDataIdx); } } +// @stack void RumbleMgr::update() { - float delta = 1.0f / SMSGetVSyncTimesPerSec(); - - if (!this->m_flags && this->m_isInitialized) { - for (int i = 0; i < 4; ++i) { - RumbleControllerMgr* controller = this->m_controllerManagers[i]; - - if (controller) { - bool isSilent = true; - for (int ch = 0; ch < MAX_RUMBLE_CHANNELS; ch++) { - RumbleChannelMgr& channel = controller->channels[ch]; - if (channel.rumbleData != nullptr - || channel.mElapsedTime != 0.0f) { - isSilent = false; - break; - } - } + // @fake - this fixes our stack mismatch, perhaps a leftover debug print? + // NOTE: same hack fixes RumbleMgr::stop() + int stack[2]; + (void)stack; - RumbleControllerState* state = this->m_controllerStates[i]; + f32 updateRate = 1.0f / SMSGetVSyncTimesPerSec(); - if (isSilent) { - PADControlMotor(state->m_controllerIndex, - PAD_MOTOR_STOP_HARD); - state->m_currentIntensityL = 0.0f; - state->m_currentIntensityR = 0.0f; - } else { - this->m_masterIntensityL = controller->update(); - - if (this->m_masterIntensityR > 0.0f) { - this->m_masterIntensityL - = this->m_masterIntensityL - * ((1.0f - this->m_masterIntensityL) - * (this->m_masterIntensityR / 0.5f) - + 1.0f); - } - - if (this->m_masterIntensityL <= 1.0f) { - if (this->m_masterIntensityL < 0.0f) { - this->m_masterIntensityL = 0.0f; - } - } else { - this->m_masterIntensityL = 1.0f; - } - - state->m_currentIntensityL = this->m_masterIntensityL; - state->m_currentIntensityR += state->m_currentIntensityL; - - if (state->m_currentIntensityL > 0.0f) { - if (state->m_currentIntensityR >= 1.0f) { - state->m_currentIntensityR -= 1.0f; - PADControlMotor(state->m_controllerIndex, - PAD_MOTOR_RUMBLE); - } else { - if (this->unkA) - PADControlMotor(state->m_controllerIndex, - PAD_MOTOR_STOP_HARD); - else - PADControlMotor(state->m_controllerIndex, - PAD_MOTOR_STOP); - } - } else { - if (this->unkA) - PADControlMotor(state->m_controllerIndex, - PAD_MOTOR_STOP_HARD); - else - PADControlMotor(state->m_controllerIndex, - PAD_MOTOR_STOP); - } + if (mPaused || !mActive) { + return; + } + + for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { + if (mControllerMgrTbl[i] != nullptr) { + if (!mControllerMgrTbl[i]->channelMgrIsAllFree()) { + mPower = mControllerMgrTbl[i]->update(); + + if (mTimer > 0.0f) { + mPower *= ((1.0f - mPower) * (mTimer / 0.5f) + 1.0f); + } + + if (mPower > 1.0f) { + mPower = 1.0f; + } else if (mPower < 0.0f) { + mPower = 0.0f; } - controller->updateMotorCount(); + + mRumbleBaseTbl[i]->update(mPower, mStopHard); + } else { + mRumbleBaseTbl[i]->stop(); + mRumbleBaseTbl[i]->init(); } - } - if (this->m_masterIntensityR > 0.0f) { - this->m_masterIntensityR = this->m_masterIntensityR - delta; + mControllerMgrTbl[i]->updateMotorCount(); } } + + if (mTimer > 0.0f) { + mTimer -= updateRate; + } } -void RumbleMgr::setActive(bool activeState) -{ - int v3; // r30 - int v4; // r31 - RumbleControllerMgr* v5; // r3 - RumbleControllerState* v6; // r29 - float* v7; // r3 - - this->m_isInitialized = activeState; - if (!this->m_isInitialized) { - v3 = 0; - v4 = 0; - this->m_masterIntensityL = 0.0; - this->m_masterIntensityR = 0.0; - do { - v5 = this->m_controllerManagers[v4]; - if (v5) { - v5->reset(); - v6 = m_controllerStates[v4]; - PADControlMotor(v6->m_controllerIndex, PAD_MOTOR_STOP_HARD); - v6->m_currentIntensityL = 0.0f; - v6->m_currentIntensityR = 0.0f; - } - ++v3; - ++v4; - } while (v3 < 4); - this->m_flags = 0; +void RumbleMgr::setActive(bool active) +{ + mActive = active; + if (!mActive) { + reset(); } } void RumbleMgr::startPause() { - int padIter; // r31 - int i; // r30 - RumbleControllerState* theControllerState; // r3 - - padIter = 0; - for (i = 0; i < 4; ++i) { - theControllerState = this->m_controllerStates[padIter]; - if (theControllerState) - PADControlMotor(theControllerState->m_controllerIndex, - PAD_MOTOR_STOP_HARD); - ++padIter; + for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { + if (mRumbleBaseTbl[i] != nullptr) { + mRumbleBaseTbl[i]->stop(); + } } - this->m_flags = 1; + + mPaused = true; } void RumbleMgr::finishPause() { - this->m_masterIntensityR = 0.5; - this->m_flags = 0; + mTimer = 0.5f; + mPaused = false; } + +// Size needed: 0x94, current: 0x94 +void RumbleMgr::changePause() +{ + if (mPaused) { + finishPause(); + } else { + startPause(); + } +} + +// Size needed: 0x24, current: 0x24 +void RumbleMgr::changeMode() +{ + if (mStopHard) { + mStopHard = false; + } else { + mStopHard = true; + } +} \ No newline at end of file diff --git a/src/MarioUtil/RumbleType.cpp b/src/MarioUtil/RumbleType.cpp index 8a6541c5..9c6e1737 100644 --- a/src/MarioUtil/RumbleType.cpp +++ b/src/MarioUtil/RumbleType.cpp @@ -1,16 +1,17 @@ #include #include -#include extern int channelNum; -struct UnkStruct3B0378 { +struct RumbleTypeInfo { unsigned int unk0; - const char* str; + char* str; }; // Enum To Str? -struct UnkStruct3B0378 _info[23] = { +// @BUG - channelNum (number of rumble types) is 25, +// but _info is only 23 elements long. +struct RumbleTypeInfo _info[23] = { { 0, "MARIO_HIPDROP" }, { 1, "MARIO_DAMAGE" }, { 2, "MARIO_LANDING" }, @@ -45,9 +46,15 @@ int RumbleType::getIndex(char* strIn) return _info[i].unk0; } } - ASSERTMSGLINE( - __LINE__, -1, - "Invalid RumbleType"); // this feels more correct but the string is - // getting omitted by the preprocessor return -1; } + +// Size needed: 0x54, current: 0x34 +const char* RumbleType::getName(int index) +{ + if (index < 0 || index >= channelNum) { + return invalidStr; + } + + return _info[index].str; +} \ No newline at end of file From 906f5b5c2903a6b170c17a1e77b875e7bfe7f772 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Sat, 21 Feb 2026 20:02:01 +0100 Subject: [PATCH 21/24] fix: changes to fix build --- include/GC2D/MovieRumble.hpp | 59 ++++++++++++++++------------------ include/Player/MarioAccess.hpp | 19 +++++++++-- src/GC2D/MovieRumble.cpp | 4 +-- 3 files changed, 46 insertions(+), 36 deletions(-) diff --git a/include/GC2D/MovieRumble.hpp b/include/GC2D/MovieRumble.hpp index d328f2cc..5aedfb97 100644 --- a/include/GC2D/MovieRumble.hpp +++ b/include/GC2D/MovieRumble.hpp @@ -1,46 +1,41 @@ #ifndef GC2D_MOVIE_RUMBLE_HPP #define GC2D_MOVIE_RUMBLE_HPP -#include #include -#include +#include #include class TMovieRumble : public JDrama::TViewObj { public: - TMovieRumble(const TTHPRender* thpRender); - virtual ~TMovieRumble(); - void init(const char* subtitleName); - virtual void perform(u32 flags, JDrama::TGraphics* graphics); + TMovieRumble(const TTHPRender*); + + virtual void perform(u32, JDrama::TGraphics*); + + void init(const char*); + void movement(); + void checkRumbleOn(); void checkRumbleOff(); + void readCurInfo(); + void makeBcrName(char*, int, const char*); -public: - const TTHPRender* thpRenderer; - Koga::ToolData* toolData; // this is supposedly the only usage of tooldata - // in the entire game lmao - s32 entryIndex; - s32 startFrame; - s32 endFrame; - s32 rumbleTypeIndex; - bool isRumbleActive; - -private: - inline void updateRumbleState(Koga::ToolData* toolData, s32 entryIndex) + bool isValid() const { - const char* rumbleTypeString; - s32 theEntryIndex = entryIndex; - bool isDataValid = (toolData != nullptr) && (theEntryIndex >= 0); - - if (isDataValid && toolData->isIndexValid(theEntryIndex)) { - // get this rumble entry's data, and update this instance - toolData->GetValue(theEntryIndex, "start_frame", startFrame); - toolData->GetValue(theEntryIndex, "end_frame", endFrame); - toolData->GetValue(theEntryIndex, "type", rumbleTypeString); - rumbleTypeIndex = RumbleType::getIndex((char*)rumbleTypeString); - } else { - rumbleTypeIndex = -1; - } + bool result = false; + if (unk14 && unk18 >= 0) + result = true; + return result; } + + Koga::ToolData* getToolData() const { return unk14; } + +public: + /* 0x10 */ const TTHPRender* unk10; + /* 0x14 */ Koga::ToolData* unk14; + /* 0x18 */ int unk18; + /* 0x1C */ s32 unk1C; + /* 0x20 */ s32 unk20; + /* 0x24 */ int unk24; + /* 0x28 */ bool unk28; }; -#endif // GC2D_MOVIE_RUMBLE_HPP +#endif \ No newline at end of file diff --git a/include/Player/MarioAccess.hpp b/include/Player/MarioAccess.hpp index 4751ee57..6336ca1d 100644 --- a/include/Player/MarioAccess.hpp +++ b/include/Player/MarioAccess.hpp @@ -79,6 +79,18 @@ void SMS_SetMarioAccessParams(); // Real, see bossgesso inline JGeometry::TVec3& SMS_GetMarioPos() { return *gpMarioPos; } +JGeometry::TVec3 SMS_DistanceFromMarioVec(const JGeometry::TVec3& pos) +{ + JGeometry::TVec3 marioPos = SMS_GetMarioPos(); + marioPos.sub(pos); + return marioPos; +} + +f32 SMS_DistanceFromMario(const JGeometry::TVec3& pos) +{ + return SMS_DistanceFromMarioVec(pos).length(); +} + // fabricated and very unlikely to be real // TODO: removeme inline void SMS_GetMarioPosStupid(Vec* result) @@ -96,6 +108,9 @@ inline void SMS_GetMarioPosStupid(Vec* result) } // fabricated -const TBGCheckData* SMS_GetMarioGroundPlane() { return *gpMarioGroundPlane; } +inline const TBGCheckData* SMS_GetMarioGroundPlane() +{ + return *gpMarioGroundPlane; +} -#endif +#endif \ No newline at end of file diff --git a/src/GC2D/MovieRumble.cpp b/src/GC2D/MovieRumble.cpp index 4294d031..9f10ceaa 100644 --- a/src/GC2D/MovieRumble.cpp +++ b/src/GC2D/MovieRumble.cpp @@ -23,7 +23,7 @@ void TMovieRumble::init(const char* param_1) unk14 = new Koga::ToolData; void* bcr = JKRGetResource(acStack_90); unk14->Attach(bcr); - if (!unk14->GetData()) + if (!unk14->dataExists()) unk18 = -1; else unk18 = 0; @@ -71,7 +71,7 @@ void TMovieRumble::readCurInfo() { int group = unk18; - if (isValid() && group < unk14->GetGroupCount()) { + if (isValid() && unk14->isIndexValid(group)) { Koga::ToolData* toolData = unk14; toolData->GetValue(group, "start_frame", unk1C); toolData->GetValue(group, "end_frame", unk20); From 6e32d1acb6810c26c0ba701aaa0f462bb20d8ff5 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Sat, 21 Feb 2026 20:13:13 +0100 Subject: [PATCH 22/24] fix: i fucking hate git why does it handle merges so fucking badly --- include/GC2D/MovieRumble.hpp | 28 -- src/MarioUtil/RumbleData.cpp | 191 ------------- src/MarioUtil/RumbleMgr.cpp | 510 ----------------------------------- src/MarioUtil/RumbleType.cpp | 4 - 4 files changed, 733 deletions(-) diff --git a/include/GC2D/MovieRumble.hpp b/include/GC2D/MovieRumble.hpp index d9dd0693..5aedfb97 100644 --- a/include/GC2D/MovieRumble.hpp +++ b/include/GC2D/MovieRumble.hpp @@ -11,13 +11,6 @@ class TMovieRumble : public JDrama::TViewObj { virtual void perform(u32, JDrama::TGraphics*); - void init(const char*); - void movement(); - void checkRumbleOn(); - TMovieRumble(const TTHPRender*); - - virtual void perform(u32, JDrama::TGraphics*); - void init(const char*); void movement(); void checkRumbleOn(); @@ -35,27 +28,6 @@ class TMovieRumble : public JDrama::TViewObj { Koga::ToolData* getToolData() const { return unk14; } -public: - /* 0x10 */ const TTHPRender* unk10; - /* 0x14 */ Koga::ToolData* unk14; - /* 0x18 */ int unk18; - /* 0x1C */ s32 unk1C; - /* 0x20 */ s32 unk20; - /* 0x24 */ int unk24; - /* 0x28 */ bool unk28; - void readCurInfo(); - void makeBcrName(char*, int, const char*); - - bool isValid() const - { - bool result = false; - if (unk14 && unk18 >= 0) - result = true; - return result; - } - - Koga::ToolData* getToolData() const { return unk14; } - public: /* 0x10 */ const TTHPRender* unk10; /* 0x14 */ Koga::ToolData* unk14; diff --git a/src/MarioUtil/RumbleData.cpp b/src/MarioUtil/RumbleData.cpp index 2be6c0db..0472fa58 100644 --- a/src/MarioUtil/RumbleData.cpp +++ b/src/MarioUtil/RumbleData.cpp @@ -1,5 +1,4 @@ #include -#include #include static int rumblePoint_00 = 0x0000000B; @@ -9,17 +8,7 @@ static float rumbleFrame_00[11] static float rumblePower_00[11] = { 1.0f, 1.0f, 1.0f, 0.9f, 0.0f, 0.0f, 0.6f, 0.6f, 0.5f, 0.2f, 0.0f }; -static int rumblePoint_00 = 0x0000000B; - -static float rumbleFrame_00[11] - = { 0.0f, 0.05f, 0.1f, 0.15f, 0.2f, 0.25f, 0.25f, 0.33f, 0.4f, 0.5f, 0.6f }; - -static float rumblePower_00[11] - = { 1.0f, 1.0f, 1.0f, 0.9f, 0.0f, 0.0f, 0.6f, 0.6f, 0.5f, 0.2f, 0.0f }; - -static int rumblePoint_01 = 0x00000018; -static float rumbleFrame_01[24] = { static int rumblePoint_01 = 0x00000018; static float rumbleFrame_01[24] = { @@ -28,8 +17,6 @@ static float rumbleFrame_01[24] = { 0.79f, 0.86f, 0.92f, 0.96f, 1.03f, 1.13f, 1.17f, 1.4f, }; -static float rumblePower_01[24] = { - static float rumblePower_01[24] = { 1.0f, 1.0f, 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, 0.0f, 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, 0.53f, 0.0f, 0.0f, @@ -40,11 +27,6 @@ static int rumblePoint_02 = 0x00000002; static float rumbleFrame_02[2] = { 0.0f, 0.1f }; -static float rumblePower_02[2] = { 0.8f, 0.6f }; -static int rumblePoint_02 = 0x00000002; - -static float rumbleFrame_02[2] = { 0.0f, 0.1f }; - static float rumblePower_02[2] = { 0.8f, 0.6f }; static int rumblePoint_03 = 0x00000002; @@ -52,17 +34,7 @@ static int rumblePoint_03 = 0x00000002; static float rumbleFrame_03[2] = { 0.0f, 0.1f }; static float rumblePower_03[2] = { 1.0f, 1.0f }; -static int rumblePoint_03 = 0x00000002; - -static float rumbleFrame_03[2] = { 0.0f, 0.1f }; - -static float rumblePower_03[2] = { 1.0f, 1.0f }; - -static int rumblePoint_04 = 0x00000007; - -static float rumbleFrame_04[7] = { 0.0f, 0.1f, 0.15f, 0.2f, 0.25f, 0.3f, 0.5f }; -static float rumblePower_04[7] = { 1.0f, 1.0f, 0.0f, 0.8f, 0.8f, 0.0f, 0.0f }; static int rumblePoint_04 = 0x00000007; static float rumbleFrame_04[7] = { 0.0f, 0.1f, 0.15f, 0.2f, 0.25f, 0.3f, 0.5f }; @@ -80,25 +52,7 @@ static float rumblePower_05[21] = { 1.0f, 0.92f, 0.0f, 0.0f, 0.79f, 0.63f, 0.0f, 0.02f, 0.45f, 0.31f, 0.02f, 0.24f, 0.03f, 0.18f, 0.04f, 0.13f, 0.04f, 0.1f, 0.04f, 0.06f, 0.0f }; -static int rumblePoint_05 = 0x00000015; - -static float rumbleFrame_05[21] - = { 0.0f, 0.18f, 0.21f, 0.28f, 0.28f, 0.4f, 0.45f, - 0.51f, 0.52f, 0.64f, 0.69f, 0.75f, 0.83f, 0.89f, - 0.99f, 1.03f, 1.12f, 1.19f, 1.25f, 1.3f, 1.4f }; - -static float rumblePower_05[21] - = { 1.0f, 0.92f, 0.0f, 0.0f, 0.79f, 0.63f, 0.0f, - 0.02f, 0.45f, 0.31f, 0.02f, 0.24f, 0.03f, 0.18f, - 0.04f, 0.13f, 0.04f, 0.1f, 0.04f, 0.06f, 0.0f }; - -static int rumblePoint_06 = 0x0000000A; - -static float rumbleFrame_06[10] - = { 0.0f, 0.09f, 0.09f, 0.1f, 0.17f, 0.17f, 0.18f, 0.26f, 0.26f, 0.5f }; -static float rumblePower_06[10] - = { 0.85f, 0.85f, 0.1f, 0.45f, 0.45f, 0.05f, 0.25f, 0.25f, 0.01f, 0.0f }; static int rumblePoint_06 = 0x0000000A; static float rumbleFrame_06[10] @@ -116,21 +70,7 @@ static float rumbleFrame_07[20] static float rumblePower_07[20] = { 0.95f, 0.97f, 0.85f, 0.0f, 0.0f, 0.75f, 0.73f, 0.55f, 0.0f, 0.0f, 0.6f, 0.63f, 0.32f, 0.0f, 0.0f, 0.51f, 0.48f, 0.19f, 0.02f, 0.0f }; -static int rumblePoint_07 = 0x00000014; - -static float rumbleFrame_07[20] - = { 0.0f, 0.11f, 0.12f, 0.13f, 0.2f, 0.21f, 0.29f, 0.31f, 0.33f, 0.41f, - 0.42f, 0.52f, 0.53f, 0.54f, 0.62f, 0.64f, 0.72f, 0.74f, 0.75f, 1.0f }; - -static float rumblePower_07[20] - = { 0.95f, 0.97f, 0.85f, 0.0f, 0.0f, 0.75f, 0.73f, 0.55f, 0.0f, 0.0f, - 0.6f, 0.63f, 0.32f, 0.0f, 0.0f, 0.51f, 0.48f, 0.19f, 0.02f, 0.0f }; - -static int rumblePoint_08 = 0x00000004; -static float rumbleFrame_08[5] = { 0.0f, 0.3f, 0.5f, 0.7f, 1.0f }; - -static float rumblePower_08[5] = { 1.0f, 0.5f, 0.35f, 0.5f, 1.0f }; static int rumblePoint_08 = 0x00000004; static float rumbleFrame_08[5] = { 0.0f, 0.3f, 0.5f, 0.7f, 1.0f }; @@ -142,17 +82,7 @@ static int rumblePoint_09 = 0x00000004; static float rumbleFrame_09[4] = { 0.0f, 0.3f, 0.5f, 0.7f }; static float rumblePower_09[4] = { 0.5f, 0.24f, 0.18f, 0.23f }; -static int rumblePoint_09 = 0x00000004; - -static float rumbleFrame_09[4] = { 0.0f, 0.3f, 0.5f, 0.7f }; - -static float rumblePower_09[4] = { 0.5f, 0.24f, 0.18f, 0.23f }; - -static int rumblePoint_10 = 0x00000001; - -static float rumbleFrame_10[1] = { 0.0f }; -static float rumblePower_10[1] = { 0.0f }; static int rumblePoint_10 = 0x00000001; static float rumbleFrame_10[1] = { 0.0f }; @@ -164,17 +94,7 @@ static int rumblePoint_11 = 0x00000001; static float rumbleFrame_11[1] = { 0.0f }; static float rumblePower_11[1] = { 0.0f }; -static int rumblePoint_11 = 0x00000001; - -static float rumbleFrame_11[1] = { 0.0f }; - -static float rumblePower_11[1] = { 0.0f }; - -static int rumblePoint_12 = 0x00000001; - -static float rumbleFrame_12[1] = { 0.0f }; -static float rumblePower_12[1] = { 0.0f }; static int rumblePoint_12 = 0x00000001; static float rumbleFrame_12[1] = { 0.0f }; @@ -186,17 +106,7 @@ static int rumblePoint_13 = 0x00000001; static float rumbleFrame_13[1] = { 0.0f }; static float rumblePower_13[1] = { 0.0f }; -static int rumblePoint_13 = 0x00000001; - -static float rumbleFrame_13[1] = { 0.0f }; - -static float rumblePower_13[1] = { 0.0f }; - -static int rumblePoint_14 = 0x00000001; -static float rumbleFrame_14[1] = { 0.0f }; - -static float rumblePower_14[1] = { 0.0f }; static int rumblePoint_14 = 0x00000001; static float rumbleFrame_14[1] = { 0.0f }; @@ -207,11 +117,6 @@ static int rumblePoint_15 = 0x00000001; static float rumbleFrame_15[1] = { 0.0f }; -static float rumblePower_15[1] = { 0.0f }; -static int rumblePoint_15 = 0x00000001; - -static float rumbleFrame_15[1] = { 0.0f }; - static float rumblePower_15[1] = { 0.0f }; static int rumblePoint_16 = 0x00000001; @@ -219,17 +124,7 @@ static int rumblePoint_16 = 0x00000001; static float rumbleFrame_16[1] = { 0.0f }; static float rumblePower_16[1] = { 0.0f }; -static int rumblePoint_16 = 0x00000001; -static float rumbleFrame_16[1] = { 0.0f }; - -static float rumblePower_16[1] = { 0.0f }; - -static int rumblePoint_17 = 0x00000001; - -static float rumbleFrame_17[1] = { 0.0f }; - -static float rumblePower_17[1] = { 0.0f }; static int rumblePoint_17 = 0x00000001; static float rumbleFrame_17[1] = { 0.0f }; @@ -241,17 +136,7 @@ static int rumblePoint_18 = 0x00000001; static float rumbleFrame_18[1] = { 0.0f }; static float rumblePower_18[1] = { 0.0f }; -static int rumblePoint_18 = 0x00000001; - -static float rumbleFrame_18[1] = { 0.0f }; - -static float rumblePower_18[1] = { 0.0f }; - -static int rumblePoint_19 = 0x00000005; - -static float rumbleFrame_19[5] = { 0.0f, 0.11f, 0.2f, 0.32f, 0.4f }; -static float rumblePower_19[5] = { 0.6f, 0.4f, 0.6f, 0.4f, 0.6f }; static int rumblePoint_19 = 0x00000005; static float rumbleFrame_19[5] = { 0.0f, 0.11f, 0.2f, 0.32f, 0.4f }; @@ -262,11 +147,6 @@ static int rumblePoint_20 = 0x00000002; static float rumbleFrame_20[2] = { 0.0f, 1.0f / 60.0f }; -static float rumblePower_20[2] = { 0.5f, 0.5f }; -static int rumblePoint_20 = 0x00000002; - -static float rumbleFrame_20[2] = { 0.0f, 1.0f / 60.0f }; - static float rumblePower_20[2] = { 0.5f, 0.5f }; static int rumblePoint_21 = 0x00000002; @@ -274,17 +154,7 @@ static int rumblePoint_21 = 0x00000002; static float rumbleFrame_21[2] = { 0.0f, 1.0f / 60.0f }; static float rumblePower_21[2] = { 0.75f, 0.75f }; -static int rumblePoint_21 = 0x00000002; - -static float rumbleFrame_21[2] = { 0.0f, 1.0f / 60.0f }; - -static float rumblePower_21[2] = { 0.75f, 0.75f }; - -static int rumblePoint_22 = 0x00000002; - -static float rumbleFrame_22[2] = { 0.0f, 2.0f }; -static float rumblePower_22[2] = { 0.75f, 0.75f }; static int rumblePoint_22 = 0x00000002; static float rumbleFrame_22[2] = { 0.0f, 2.0f }; @@ -313,42 +183,7 @@ static float rumblePower_23[77] 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, 0.0f, 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, 0.53f, 0.0f, 0.0f, 0.44f, 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f }; -static int rumblePoint_23 = 0x0000004D; - -static float rumbleFrame_23[77] - = { 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, - 1.2f, 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, - 4.16f, 4.17f, 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, - 5.18f, 5.28f, 5.32f, 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, - 5.68f, 6.35f, 6.36f, 6.57f, 6.68f, 6.85f, 6.88f, 7.11f, 7.18f, - 7.5f, 7.66f, 8.09f, 8.67f, 9.08f, 9.1f, 9.63f, 9.64f, 9.65f, - 9.81f, 9.84f, 9.89f, 9.91f, 10.02f, 10.04f, 10.05f, 10.06f, 10.19f, - 10.21f, 10.22f, 10.23f, 10.35f, 10.38f, 10.43f, 10.45f, 10.51f, 10.57f, - 10.61f, 10.68f, 10.78f, 10.82f, 11.0f }; -static float rumblePower_23[77] - = { 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, - 0.72f, 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, - 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, - 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f, 0.0f, 0.78f, 0.71f, - 0.0f, 0.0f, 0.78f, 0.68f, 0.0f, 0.0f, 0.42f, 0.72f, 0.87f, 1.0f, - 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, - 0.0f, 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, 0.53f, 0.0f, 0.0f, 0.44f, - 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f }; - -static int rumblePoint_24 = 0x00000025; - -static float rumbleFrame_24[37] - = { 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, 1.2f, - 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, 4.16f, 4.17f, - 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, 5.18f, 5.28f, 5.32f, - 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, 5.68f }; - -static float rumblePower_24[37] - = { 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, - 0.72f, 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, - 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, - 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f }; static int rumblePoint_24 = 0x00000025; static float rumbleFrame_24[37] @@ -363,32 +198,6 @@ static float rumblePower_24[37] 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f }; -RumbleChannelDataTbl channelDataTbl[25] = { - { &rumblePoint_00, rumbleFrame_00, rumblePower_00 }, - { &rumblePoint_01, rumbleFrame_01, rumblePower_01 }, - { &rumblePoint_02, rumbleFrame_02, rumblePower_02 }, - { &rumblePoint_03, rumbleFrame_03, rumblePower_03 }, - { &rumblePoint_04, rumbleFrame_04, rumblePower_04 }, - { &rumblePoint_05, rumbleFrame_05, rumblePower_05 }, - { &rumblePoint_06, rumbleFrame_06, rumblePower_06 }, - { &rumblePoint_07, rumbleFrame_07, rumblePower_07 }, - { &rumblePoint_08, rumbleFrame_08, rumblePower_08 }, - { &rumblePoint_09, rumbleFrame_09, rumblePower_09 }, - { &rumblePoint_10, rumbleFrame_10, rumblePower_10 }, - { &rumblePoint_11, rumbleFrame_11, rumblePower_11 }, - { &rumblePoint_12, rumbleFrame_12, rumblePower_12 }, - { &rumblePoint_13, rumbleFrame_13, rumblePower_13 }, - { &rumblePoint_14, rumbleFrame_14, rumblePower_14 }, - { &rumblePoint_15, rumbleFrame_15, rumblePower_15 }, - { &rumblePoint_16, rumbleFrame_16, rumblePower_16 }, - { &rumblePoint_17, rumbleFrame_17, rumblePower_17 }, - { &rumblePoint_18, rumbleFrame_18, rumblePower_18 }, - { &rumblePoint_19, rumbleFrame_19, rumblePower_19 }, - { &rumblePoint_20, rumbleFrame_20, rumblePower_20 }, - { &rumblePoint_21, rumbleFrame_21, rumblePower_21 }, - { &rumblePoint_22, rumbleFrame_22, rumblePower_22 }, - { &rumblePoint_23, rumbleFrame_23, rumblePower_23 }, - { &rumblePoint_24, rumbleFrame_24, rumblePower_24 }, RumbleChannelDataTbl channelDataTbl[25] = { { &rumblePoint_00, rumbleFrame_00, rumblePower_00 }, { &rumblePoint_01, rumbleFrame_01, rumblePower_01 }, diff --git a/src/MarioUtil/RumbleMgr.cpp b/src/MarioUtil/RumbleMgr.cpp index 27f1e423..f0fa87c1 100644 --- a/src/MarioUtil/RumbleMgr.cpp +++ b/src/MarioUtil/RumbleMgr.cpp @@ -1,11 +1,8 @@ #include #include #include -#include -#include #include -int RumbleMgr::mMotorCountLimit = 900; int RumbleMgr::mMotorCountLimit = 900; u16 RumbleMgr::mMotorTimerPeriod = 80; f32 RumbleMgr::mPowerThreshold = 0.5f; @@ -59,55 +56,6 @@ RumbleChannelDataTbl* RumbleChannelDataMgr::getChannelDataTbl(int index) return &channelDataTbl[index]; } -RumbleMgr* SMSRumbleMgr = nullptr; - -// Size needed: 0x10, current: 0x10 -void RumbleBase::init() -{ - mPower = 0.0f; - mAccumulator = 0.0f; -} - -// Size needed: 0x28, current: 0x28 -void RumbleBase::stop() { PADControlMotor(mChan, PAD_MOTOR_STOP_HARD); } - -// Size needed: 0xAC, current: 0xA0 -void RumbleBase::update(f32 power, bool stopHard) -{ - // This function is the likely cause for stack mismatch in - // RumbleMgr::update() as it's the only one whose size mismatches. - mPower = power; - mAccumulator += mPower; - - if (mPower <= 0.0f) { - PADControlMotor(mChan, PAD_MOTOR_STOP_HARD); - } else if (mAccumulator < 1.0f) { - if (stopHard) { - PADControlMotor(mChan, PAD_MOTOR_STOP_HARD); - } else { - PADControlMotor(mChan, PAD_MOTOR_STOP); - } - } else { - // @fake - this doesn't fix our function size but it does match stack in - // RumbleMgr::update() - // f32 accumulator = mAccumulator; - // mAccumulator = accumulator - 1.0f; - mAccumulator -= 1.0f; - PADControlMotor(mChan, PAD_MOTOR_RUMBLE); - } -} - -// Size needed: 0x10, current: 0x10 -void RumbleChannelDataMgr::init() { mChannelDataTbl = channelDataTbl; } - -// Size needed: 0x14, current: 0x14 -RumbleChannelDataTbl* RumbleChannelDataMgr::getChannelDataTbl(int index) -{ - // This feels wrong, but I only see direct loads from channelDataTbl. - // Also, it only matches size when doing this. - return &channelDataTbl[index]; -} - RumbleChannelMgr::RumbleChannelMgr() { mElapsedTime = 0.0f; @@ -158,62 +106,6 @@ void RumbleChannelMgr::start(int channelDataIdx, int repeatCount, mMultiplierF = multiplierF; } -// Size needed: 0x2C, current: 0x2C -void RumbleChannelMgr::start(int channelDataIdx, int repeatCount, Vec* worldPos) -{ - mElapsedTime = 0.0f; - mChannelDataTbl = mChannelDataMgr->getChannelDataTbl(channelDataIdx); - mChannelDataIdx = channelDataIdx; - mRepeatCount = repeatCount; - mWorldPos = worldPos; - mElapsedTime = 0.0f; - mPower = 0.0f; - mChannelDataIdx = -1; - mRepeatCount = 0; - mMultiplierF = nullptr; - mWorldPos = nullptr; - mChannelDataTbl = nullptr; -} - -// Size needed: 0x30, current: 0x2C -void RumbleChannelMgr::init(RumbleChannelDataMgr* dataMgr) -{ - mElapsedTime = 0.0f; - mPower = 0.0f; - mChannelDataIdx = -1; - mRepeatCount = 0; - mMultiplierF = nullptr; - mWorldPos = nullptr; - mChannelDataTbl = nullptr; - mChannelDataMgr = dataMgr; -} - -// Size needed: 0x2C, current: 0x2C -void RumbleChannelMgr::reset() -{ - mElapsedTime = 0.0f; - mPower = 0.0f; - mChannelDataIdx = -1; - mRepeatCount = 0; - mMultiplierF = nullptr; - mWorldPos = nullptr; - mChannelDataTbl = nullptr; -} - -// Size needed: 0x0C, current: 0x0C -void RumbleChannelMgr::repeat() { mElapsedTime = 0.0f; } - -// Size needed: 0x2C, current: 0x2C -void RumbleChannelMgr::start(int channelDataIdx, int repeatCount, - f32* multiplierF) -{ - mElapsedTime = 0.0f; - mChannelDataTbl = mChannelDataMgr->getChannelDataTbl(channelDataIdx); - mChannelDataIdx = channelDataIdx; - mRepeatCount = repeatCount; - mMultiplierF = multiplierF; -} - // Size needed: 0x2C, current: 0x2C void RumbleChannelMgr::start(int channelDataIdx, int repeatCount, Vec* worldPos) { @@ -229,25 +121,6 @@ f32 RumbleChannelMgr::update() f32 updateRate = 1.0f / SMSGetVSyncTimesPerSec(); f32 mult; - if (mMultiplierF != nullptr) { - mult = *mMultiplierF; - if (mult < 0.0f) { - mult = 0.0f; - } else if (mult > 1.0f) { - mult = 1.0f; - } - } else if (mWorldPos != nullptr) { - JGeometry::TVec3& v - = *static_cast*>(mWorldPos); - f32 dist = SMS_DistanceFromMario(v); - mult = -((dist - 300.0f) * (1.0f / 3000.0f) - 1.0f); - if (mult < 0.0f) { - mult = 0.0f; - } else if (mult > 1.0f) { - mult = 1.0f; - f32 updateRate = 1.0f / SMSGetVSyncTimesPerSec(); - f32 mult; - if (mMultiplierF != nullptr) { mult = *mMultiplierF; if (mult < 0.0f) { @@ -274,32 +147,6 @@ f32 RumbleChannelMgr::update() reset(); } - if (mChannelDataTbl != nullptr) { - mElapsedTime += updateRate; - - for (int i = 0; i < *mChannelDataTbl->mPointData - 1; i++) { - if (mElapsedTime > mChannelDataTbl->mFrameData[i]) { - f32 delta = mChannelDataTbl->mFrameData[i + 1] - - mChannelDataTbl->mFrameData[i]; - f32 frameDelta = mElapsedTime - mChannelDataTbl->mFrameData[i]; - f32 progress; - - if (delta > 0.0f) { - progress = frameDelta / delta; - } else { - progress = 1.0f; - } - - mPower = (1.0f - progress) * mChannelDataTbl->mPowerData[i] - + progress * mChannelDataTbl->mPowerData[i + 1]; - mult = 1.0f; - } - - mPower = 0.0f; - if (mRepeatCount == 0) { - reset(); - } - if (mChannelDataTbl != nullptr) { mElapsedTime += updateRate; @@ -321,13 +168,6 @@ f32 RumbleChannelMgr::update() } } - if (mElapsedTime - > mChannelDataTbl->mFrameData[*mChannelDataTbl->mPointData - 1]) { - if (mRepeatCount > 1) { - repeat(); - mRepeatCount--; - } else if (mRepeatCount < 0) { - repeat(); if (mElapsedTime > mChannelDataTbl->mFrameData[*mChannelDataTbl->mPointData - 1]) { if (mRepeatCount > 1) { @@ -337,7 +177,6 @@ f32 RumbleChannelMgr::update() repeat(); } else { reset(); - reset(); } } } @@ -353,25 +192,6 @@ RumbleControllerMgr::RumbleControllerMgr() mChannelMgrTbl = new RumbleChannelMgr[RUMBLE_CHANNELS_PER_CONTROLLER]; } -// Size needed: 0x1C4, current: 0x19C -void RumbleControllerMgr::init() -{ - mPower = 0.0f; - - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - mChannelMgrTbl[i].init(mChannelDataMgr); - } - mPower *= mult; - return mPower; -} - -// Size needed: 0x58, current: 0x58 -RumbleControllerMgr::RumbleControllerMgr() -{ - mPower = 0.0f; - mChannelMgrTbl = new RumbleChannelMgr[RUMBLE_CHANNELS_PER_CONTROLLER]; -} - // Size needed: 0x1C4, current: 0x19C void RumbleControllerMgr::init() { @@ -395,22 +215,8 @@ void RumbleControllerMgr::reset() unk12 = 0; } -// Hmm... why does this inline in RumbleMgr::start(int, f32*)? - mPower = 0.0f; - - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - mChannelMgrTbl[i].reset(); - } - - mMotorCounter = 0; - mMotorTimer = 0; - unk12 = 0; -} - // Hmm... why does this inline in RumbleMgr::start(int, f32*)? #pragma dont_inline on -void RumbleControllerMgr::start(int channelDataIdx, int repeatCount, - f32* multiplierF) void RumbleControllerMgr::start(int channelDataIdx, int repeatCount, f32* multiplierF) { @@ -423,19 +229,6 @@ void RumbleControllerMgr::start(int channelDataIdx, int repeatCount, } #pragma dont_inline reset -// This one also inlines in RumbleMgr::start(int, Vec*)? -#pragma dont_inline on -void RumbleControllerMgr::start(int channelDataIdx, int repeatCount, - Vec* worldPos) - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - if (mChannelMgrTbl[i].mChannelDataTbl == nullptr) { - mChannelMgrTbl[i].start(channelDataIdx, repeatCount, multiplierF); - break; - } - } -} -#pragma dont_inline reset - // This one also inlines in RumbleMgr::start(int, Vec*)? #pragma dont_inline on void RumbleControllerMgr::start(int channelDataIdx, int repeatCount, @@ -460,28 +253,6 @@ void RumbleControllerMgr::stop() } } -// This one also inlines in RumbleMgr::stop(int)? -#pragma dont_inline on -void RumbleControllerMgr::stop(int channelDataIdx) - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - if (mChannelMgrTbl[i].mChannelDataTbl == nullptr) { - mChannelMgrTbl[i].start(channelDataIdx, repeatCount, worldPos); - break; - } - } -} -#pragma dont_inline reset - -// Size needed: 0x10C, current: 0x10C -void RumbleControllerMgr::stop() -{ - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - if (mChannelMgrTbl[i].mChannelDataTbl != nullptr) { - mChannelMgrTbl[i].reset(); - } - } -} - // This one also inlines in RumbleMgr::stop(int)? #pragma dont_inline on void RumbleControllerMgr::stop(int channelDataIdx) @@ -502,39 +273,13 @@ bool RumbleControllerMgr::channelMgrIsAllFree() for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { if (mChannelMgrTbl[i].mChannelDataTbl != nullptr) { allFree = false; - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - if (mChannelMgrTbl[i].mChannelDataTbl != nullptr - && mChannelMgrTbl[i].mChannelDataIdx == channelDataIdx) { - mChannelMgrTbl[i].reset(); } } -} -#pragma dont_inline reset - -// Size needed: 0x11C, current: 0x11C -bool RumbleControllerMgr::channelMgrIsAllFree() -{ - bool allFree = true; - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - if (mChannelMgrTbl[i].mChannelDataTbl != nullptr) { - allFree = false; - } - } - return allFree; -} return allFree; } void RumbleControllerMgr::updateMotorCount() { - if (unk12) { - if (mMotorCounter > 0) { - mMotorCounter--; - } else { - unk12 = 0; - mMotorTimer = 0; - } - } else if (mMotorCounter > RumbleMgr::mMotorCountLimit) { if (unk12) { if (mMotorCounter > 0) { mMotorCounter--; @@ -550,23 +295,11 @@ void RumbleControllerMgr::updateMotorCount() } else { mMotorCounter = 0; } - } else if (mMotorTimer > 0) { - mMotorTimer--; - mMotorCounter++; - } else { - mMotorCounter = 0; - } } f32 RumbleControllerMgr::update() { f32 maxPower = 0.0f; - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - if (mChannelMgrTbl[i].mChannelDataTbl != nullptr) { - mPower = mChannelMgrTbl[i].update(); - if (mPower > maxPower) { - maxPower = mPower; - f32 maxPower = 0.0f; for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { if (mChannelMgrTbl[i].mChannelDataTbl != nullptr) { mPower = mChannelMgrTbl[i].update(); @@ -582,22 +315,7 @@ f32 RumbleControllerMgr::update() } else if (mPower < 0.0f) { mPower = 0.0f; } - mPower = maxPower; - if (mPower > 1.0f) { - mPower = 1.0f; - } else if (mPower < 0.0f) { - mPower = 0.0f; - } - - if (mPower > RumbleMgr::mPowerThreshold) { - mMotorTimer = RumbleMgr::mMotorTimerPeriod; - } - - if (unk12) { - mPower = 0.0f; - } - return mPower; if (mPower > RumbleMgr::mPowerThreshold) { mMotorTimer = RumbleMgr::mMotorTimerPeriod; } @@ -609,8 +327,6 @@ f32 RumbleControllerMgr::update() return mPower; } -RumbleMgr::RumbleMgr(bool controller1, bool controller2, bool controller3, - bool controller4) RumbleMgr::RumbleMgr(bool controller1, bool controller2, bool controller3, bool controller4) { @@ -623,31 +339,7 @@ RumbleMgr::RumbleMgr(bool controller1, bool controller2, bool controller3, enable[1] = controller2; enable[2] = controller3; enable[3] = controller4; - bool enable[4]; - - mPower = 0.0f; - mTimer = 0.0f; - - enable[0] = controller1; - enable[1] = controller2; - enable[2] = controller3; - enable[3] = controller4; - - for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { - mControllerMgrTbl[i] = nullptr; - mRumbleBaseTbl[i] = nullptr; - - if (enable[i]) { - mControllerMgrTbl[i] = new RumbleControllerMgr(); - mRumbleBaseTbl[i] = new RumbleBase(i); - } - } - mChannelDataMgr = nullptr; - mChannelDataMgr = new RumbleChannelDataMgr(); - mActive = true; - mPaused = false; - mStopHard = true; for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { mControllerMgrTbl[i] = nullptr; mRumbleBaseTbl[i] = nullptr; @@ -669,20 +361,7 @@ void RumbleMgr::init() { mPower = 0.0f; mTimer = 0.0f; - mPower = 0.0f; - mTimer = 0.0f; - - for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { - if (mControllerMgrTbl[i] != nullptr) { - mControllerMgrTbl[i]->init(); - mRumbleBaseTbl[i]->init(); - } - } - mChannelDataMgr->init(); - mActive = true; - mPaused = false; - mStopHard = true; for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { if (mControllerMgrTbl[i] != nullptr) { mControllerMgrTbl[i]->init(); @@ -700,61 +379,7 @@ void RumbleMgr::reset() { mPower = 0.0f; mTimer = 0.0f; - mPower = 0.0f; - mTimer = 0.0f; - - for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { - if (mControllerMgrTbl[i] != nullptr) { - mControllerMgrTbl[i]->reset(); - mRumbleBaseTbl[i]->stop(); - mRumbleBaseTbl[i]->init(); - } - } - - mPaused = 0; -} - -void RumbleMgr::start(int channelDataIdx, f32* multiplierF) -{ - int controllerIdx = 0; - - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, 1, multiplierF); - } -} - -void RumbleMgr::start(int channelDataIdx, Vec* worldPos) -{ - int controllerIdx = 0; - - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, 1, worldPos); - } -} - -// Size needed: 0x74, current: 0x74 -void RumbleMgr::start(int channelDataIdx, MtxPtr mtx) -{ - int controllerIdx = 0; - - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - Vec worldPos; - worldPos.x = mtx[3][0]; - worldPos.y = mtx[3][1]; - worldPos.z = mtx[3][2]; - - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, 1, &worldPos); - } -} -void RumbleMgr::start(int channelDataIdx, int repeatCount, f32* multiplierF) -{ - int controllerIdx = 0; - - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, - multiplierF); - } for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { if (mControllerMgrTbl[i] != nullptr) { mControllerMgrTbl[i]->reset(); @@ -809,11 +434,9 @@ void RumbleMgr::start(int channelDataIdx, int repeatCount, f32* multiplierF) } } -void RumbleMgr::start(int channelDataIdx, int repeatCount, Vec* worldPos) void RumbleMgr::start(int channelDataIdx, int repeatCount, Vec* worldPos) { int controllerIdx = 0; - int controllerIdx = 0; if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, @@ -821,34 +444,11 @@ void RumbleMgr::start(int channelDataIdx, int repeatCount, Vec* worldPos) } } -// Size needed: 0x70, current: 0x70 -void RumbleMgr::start(int channelDataIdx, int repeatCount, MtxPtr mtx) - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, - worldPos); - } -} - // Size needed: 0x70, current: 0x70 void RumbleMgr::start(int channelDataIdx, int repeatCount, MtxPtr mtx) { int controllerIdx = 0; - int controllerIdx = 0; - - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - Vec worldPos; - worldPos.x = mtx[3][0]; - worldPos.y = mtx[3][1]; - worldPos.z = mtx[3][2]; - - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, - &worldPos); - } -} -// Size needed: 0x94, current: 0x58 -void RumbleMgr::start(int controllerIdx, int channelDataIdx, int repeatCount, - f32* multiplierF) if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { Vec worldPos; worldPos.x = mtx[3][0]; @@ -895,38 +495,6 @@ void RumbleMgr::start(int controllerIdx, int channelDataIdx, int repeatCount, } } -// @stack - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, - multiplierF); - } -} - -// Size needed: 0x94, current: 0x58 -void RumbleMgr::start(int controllerIdx, int channelDataIdx, int repeatCount, - Vec* worldPos) -{ - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, - worldPos); - } -} - -// Size needed: 0x7C, current: 0x74 -void RumbleMgr::start(int controllerIdx, int channelDataIdx, int repeatCount, - MtxPtr mtx) -{ - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - Vec worldPos; - worldPos.x = mtx[3][0]; - worldPos.y = mtx[3][1]; - worldPos.z = mtx[3][2]; - - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, - &worldPos); - } -} - // @stack void RumbleMgr::stop() { @@ -958,35 +526,6 @@ void RumbleMgr::stop(int controllerIdx, int channelDataIdx) } } -// @stack - // @fake - this fixes our stack mismatch, perhaps a leftover debug print? - int stack[2]; - (void)stack; - - for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { - if (mControllerMgrTbl[i] != nullptr) { - mControllerMgrTbl[i]->stop(); - } - } -} - -void RumbleMgr::stop(int channelDataIdx) -{ - int controllerIdx = 0; - - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->stop(channelDataIdx); - } -} - -// Size needed: 0x178, current: 0x50 -void RumbleMgr::stop(int controllerIdx, int channelDataIdx) -{ - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->stop(channelDataIdx); - } -} - // @stack void RumbleMgr::update() { @@ -1025,57 +564,15 @@ void RumbleMgr::update() mControllerMgrTbl[i]->updateMotorCount(); } } - // @fake - this fixes our stack mismatch, perhaps a leftover debug print? - // NOTE: same hack fixes RumbleMgr::stop() - int stack[2]; - (void)stack; - - f32 updateRate = 1.0f / SMSGetVSyncTimesPerSec(); - - if (mPaused || !mActive) { - return; - } - for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { - if (mControllerMgrTbl[i] != nullptr) { - if (!mControllerMgrTbl[i]->channelMgrIsAllFree()) { - mPower = mControllerMgrTbl[i]->update(); - - if (mTimer > 0.0f) { - mPower *= ((1.0f - mPower) * (mTimer / 0.5f) + 1.0f); - } - - if (mPower > 1.0f) { - mPower = 1.0f; - } else if (mPower < 0.0f) { - mPower = 0.0f; - } - - mRumbleBaseTbl[i]->update(mPower, mStopHard); - } else { - mRumbleBaseTbl[i]->stop(); - mRumbleBaseTbl[i]->init(); - } - - mControllerMgrTbl[i]->updateMotorCount(); - } - } - - if (mTimer > 0.0f) { - mTimer -= updateRate; - } if (mTimer > 0.0f) { mTimer -= updateRate; } } -void RumbleMgr::setActive(bool active) void RumbleMgr::setActive(bool active) { mActive = active; - if (!mActive) { - reset(); - mActive = active; if (!mActive) { reset(); } @@ -1089,13 +586,6 @@ void RumbleMgr::startPause() } } - mPaused = true; - for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { - if (mRumbleBaseTbl[i] != nullptr) { - mRumbleBaseTbl[i]->stop(); - } - } - mPaused = true; } diff --git a/src/MarioUtil/RumbleType.cpp b/src/MarioUtil/RumbleType.cpp index 87aa9644..9c6e1737 100644 --- a/src/MarioUtil/RumbleType.cpp +++ b/src/MarioUtil/RumbleType.cpp @@ -3,7 +3,6 @@ extern int channelNum; -struct RumbleTypeInfo { struct RumbleTypeInfo { unsigned int unk0; char* str; @@ -12,9 +11,6 @@ struct RumbleTypeInfo { // Enum To Str? // @BUG - channelNum (number of rumble types) is 25, // but _info is only 23 elements long. -struct RumbleTypeInfo _info[23] = { -// @BUG - channelNum (number of rumble types) is 25, -// but _info is only 23 elements long. struct RumbleTypeInfo _info[23] = { { 0, "MARIO_HIPDROP" }, { 1, "MARIO_DAMAGE" }, From ebcc6bf166fd774cc3b150718d908289c9504657 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Sat, 21 Feb 2026 22:14:53 +0100 Subject: [PATCH 23/24] chore: lint --- include/GC2D/MovieRumble.hpp | 61 +- include/MarioUtil/RumbleMgr.hpp | 189 +++--- include/MarioUtil/RumbleType.hpp | 6 +- src/GC2D/MovieRumble.cpp | 120 ++-- src/MarioUtil/RumbleData.cpp | 251 ++++---- src/MarioUtil/RumbleMgr.cpp | 946 +++++++++++++++---------------- src/MarioUtil/RumbleType.cpp | 80 ++- 7 files changed, 805 insertions(+), 848 deletions(-) diff --git a/include/GC2D/MovieRumble.hpp b/include/GC2D/MovieRumble.hpp index 5aedfb97..99853505 100644 --- a/include/GC2D/MovieRumble.hpp +++ b/include/GC2D/MovieRumble.hpp @@ -1,41 +1,40 @@ #ifndef GC2D_MOVIE_RUMBLE_HPP #define GC2D_MOVIE_RUMBLE_HPP -#include #include #include +#include class TMovieRumble : public JDrama::TViewObj { -public: - TMovieRumble(const TTHPRender*); - - virtual void perform(u32, JDrama::TGraphics*); - - void init(const char*); - void movement(); - void checkRumbleOn(); - void checkRumbleOff(); - void readCurInfo(); - void makeBcrName(char*, int, const char*); - - bool isValid() const - { - bool result = false; - if (unk14 && unk18 >= 0) - result = true; - return result; - } - - Koga::ToolData* getToolData() const { return unk14; } - -public: - /* 0x10 */ const TTHPRender* unk10; - /* 0x14 */ Koga::ToolData* unk14; - /* 0x18 */ int unk18; - /* 0x1C */ s32 unk1C; - /* 0x20 */ s32 unk20; - /* 0x24 */ int unk24; - /* 0x28 */ bool unk28; + public: + TMovieRumble( const TTHPRender * ); + + virtual void perform( u32, JDrama::TGraphics * ); + + void init( const char * ); + void movement(); + void checkRumbleOn(); + void checkRumbleOff(); + void readCurInfo(); + void makeBcrName( char *, int, const char * ); + + bool isValid() const { + bool result = false; + if ( unk14 && unk18 >= 0 ) + result = true; + return result; + } + + Koga::ToolData *getToolData() const { return unk14; } + + public: + /* 0x10 */ const TTHPRender *unk10; + /* 0x14 */ Koga::ToolData *unk14; + /* 0x18 */ int unk18; + /* 0x1C */ s32 unk1C; + /* 0x20 */ s32 unk20; + /* 0x24 */ int unk24; + /* 0x28 */ bool unk28; }; #endif \ No newline at end of file diff --git a/include/MarioUtil/RumbleMgr.hpp b/include/MarioUtil/RumbleMgr.hpp index e009bc5e..7d92184c 100644 --- a/include/MarioUtil/RumbleMgr.hpp +++ b/include/MarioUtil/RumbleMgr.hpp @@ -1,130 +1,123 @@ #ifndef MARIO_UTIL_RUMBLE_MGR_HPP #define MARIO_UTIL_RUMBLE_MGR_HPP -#include #include #include +#include #define RUMBLE_CHANNELS_PER_CONTROLLER 32 struct RumbleChannelDataTbl { - int* mPointData; - float* mFrameData; - float* mPowerData; + int *mPointData; + float *mFrameData; + float *mPowerData; }; extern RumbleChannelDataTbl channelDataTbl[]; class RumbleBase { -public: - RumbleBase(int chan) - : mPower(0.0f) - , mAccumulator(0.0f) - , mChan(chan) - { - } - void init(); - void stop(); - void update(f32, bool); - - f32 mPower; - f32 mAccumulator; - int mChan; + public: + RumbleBase( int chan ) + : mPower( 0.0f ), mAccumulator( 0.0f ), mChan( chan ) {} + void init(); + void stop(); + void update( f32, bool ); + + f32 mPower; + f32 mAccumulator; + int mChan; }; class RumbleChannelDataMgr { -public: - RumbleChannelDataMgr() - : mChannelDataTbl(nullptr) - { - } - void init(); - RumbleChannelDataTbl* getChannelDataTbl(int); - - RumbleChannelDataTbl* mChannelDataTbl; + public: + RumbleChannelDataMgr() : mChannelDataTbl( nullptr ) {} + void init(); + RumbleChannelDataTbl *getChannelDataTbl( int ); + + RumbleChannelDataTbl *mChannelDataTbl; }; class RumbleChannelMgr { -public: - RumbleChannelMgr(); - void init(RumbleChannelDataMgr*); - void reset(); - void repeat(); - void start(int, int, f32*); - void start(int, int, Vec*); - f32 update(); - - f32 mElapsedTime; - f32 mPower; - int mChannelDataIdx; - int mRepeatCount; - f32* mMultiplierF; - Vec* mWorldPos; - RumbleChannelDataTbl* mChannelDataTbl; - RumbleChannelDataMgr* mChannelDataMgr; + public: + RumbleChannelMgr(); + void init( RumbleChannelDataMgr * ); + void reset(); + void repeat(); + void start( int, int, f32 * ); + void start( int, int, Vec * ); + f32 update(); + + f32 mElapsedTime; + f32 mPower; + int mChannelDataIdx; + int mRepeatCount; + f32 *mMultiplierF; + Vec *mWorldPos; + RumbleChannelDataTbl *mChannelDataTbl; + RumbleChannelDataMgr *mChannelDataMgr; }; class RumbleControllerMgr { -public: - RumbleControllerMgr(); - void init(); - void reset(); - void start(int, int, f32*); - void start(int, int, Vec*); - void stop(); - void stop(int); - bool channelMgrIsAllFree(); - void updateMotorCount(); - f32 update(); - - f32 mPower; - RumbleChannelMgr* mChannelMgrTbl; - RumbleChannelDataMgr* mChannelDataMgr; - u32 mMotorCounter; - u16 mMotorTimer; - s8 unk12; + public: + RumbleControllerMgr(); + void init(); + void reset(); + void start( int, int, f32 * ); + void start( int, int, Vec * ); + void stop(); + void stop( int ); + bool channelMgrIsAllFree(); + void updateMotorCount(); + f32 update(); + + f32 mPower; + RumbleChannelMgr *mChannelMgrTbl; + RumbleChannelDataMgr *mChannelDataMgr; + u32 mMotorCounter; + u16 mMotorTimer; + s8 unk12; }; class RumbleMgr; -extern RumbleMgr* SMSRumbleMgr; +extern RumbleMgr *SMSRumbleMgr; class RumbleMgr { -public: - RumbleMgr(bool, bool, bool, bool); - void init(); - void reset(); - void start(int, f32*); - void start(int, Vec*); - void start(int, MtxPtr); - void start(int, int, f32*); - void start(int, int, Vec*); - void start(int, int, MtxPtr); - void start(int, int, int, f32*); - void start(int, int, int, Vec*); - void start(int, int, int, MtxPtr); - void stop(); - void stop(int); - void stop(int, int); - void update(); - void setActive(bool); - void startPause(); - void finishPause(); - void changePause(); - void changeMode(); - - f32 mPower; - f32 mTimer; - bool mActive; - bool mPaused; - bool mStopHard; - RumbleBase* mRumbleBaseTbl[4]; - RumbleControllerMgr* mControllerMgrTbl[4]; - RumbleChannelDataMgr* mChannelDataMgr; - - static int mMotorCountLimit; - static u16 mMotorTimerPeriod; - static f32 mPowerThreshold; + public: + RumbleMgr( bool, bool, bool, bool ); + void init(); + void reset(); + void start( int, f32 * ); + void start( int, Vec * ); + void start( int, MtxPtr ); + void start( int, int, f32 * ); + void start( int, int, Vec * ); + void start( int, int, MtxPtr ); + void start( int, int, int, f32 * ); + void start( int, int, int, Vec * ); + void start( int, int, int, MtxPtr ); + void stop(); + void stop( int ); + void stop( int, int ); + void update(); + void setActive( bool ); + void startPause(); + void finishPause(); + void changePause(); + void changeMode(); + + f32 mPower; + f32 mTimer; + bool mActive; + bool mPaused; + bool mStopHard; + RumbleBase *mRumbleBaseTbl[ 4 ]; + RumbleControllerMgr *mControllerMgrTbl[ 4 ]; + RumbleChannelDataMgr *mChannelDataMgr; + + static int mMotorCountLimit; + static u16 mMotorTimerPeriod; + static f32 mPowerThreshold; }; #endif \ No newline at end of file diff --git a/include/MarioUtil/RumbleType.hpp b/include/MarioUtil/RumbleType.hpp index cb91eeac..c0504ad4 100644 --- a/include/MarioUtil/RumbleType.hpp +++ b/include/MarioUtil/RumbleType.hpp @@ -2,9 +2,9 @@ #define MARIO_UTIL_RUMBLE_TYPE_HPP class RumbleType { -public: - static int getIndex(char* strIn); - static const char* getName(int index); + public: + static int getIndex( char *strIn ); + static const char *getName( int index ); }; #endif \ No newline at end of file diff --git a/src/GC2D/MovieRumble.cpp b/src/GC2D/MovieRumble.cpp index 9f10ceaa..d7215686 100644 --- a/src/GC2D/MovieRumble.cpp +++ b/src/GC2D/MovieRumble.cpp @@ -1,91 +1,81 @@ #include -#include #include -#include +#include #include #include -#include +#include +#include // TODO: removeme -static const char* dummyMactorStringValue1 = "\0\0\0\0\0\0\0\0\0\0\0"; -static const char* SMS_NO_MEMORY_MESSAGE = "メモリが足りません\n"; +static const char *dummyMactorStringValue1 = "\0\0\0\0\0\0\0\0\0\0\0"; +static const char *SMS_NO_MEMORY_MESSAGE = "メモリが足りません\n"; -TMovieRumble::TMovieRumble(const TTHPRender* param_1) - : unk10(param_1) -{ -} +TMovieRumble::TMovieRumble( const TTHPRender *param_1 ) : unk10( param_1 ) {} -void TMovieRumble::init(const char* param_1) -{ - char acStack_90[128]; - makeBcrName(acStack_90, 128, param_1); +void TMovieRumble::init( const char *param_1 ) { + char acStack_90[ 128 ]; + makeBcrName( acStack_90, 128, param_1 ); - unk14 = new Koga::ToolData; - void* bcr = JKRGetResource(acStack_90); - unk14->Attach(bcr); - if (!unk14->dataExists()) - unk18 = -1; - else - unk18 = 0; + unk14 = new Koga::ToolData; + void *bcr = JKRGetResource( acStack_90 ); + unk14->Attach( bcr ); + if ( !unk14->dataExists() ) + unk18 = -1; + else + unk18 = 0; - readCurInfo(); - unk28 = false; + readCurInfo(); + unk28 = false; } -void TMovieRumble::perform(u32 param_1, JDrama::TGraphics*) -{ - if (param_1 & 0x1) - movement(); +void TMovieRumble::perform( u32 param_1, JDrama::TGraphics * ) { + if ( param_1 & 0x1 ) + movement(); } -void TMovieRumble::movement() -{ - if (unk28) { - checkRumbleOff(); - } else { - checkRumbleOn(); - } +void TMovieRumble::movement() { + if ( unk28 ) { + checkRumbleOff(); + } else { + checkRumbleOn(); + } } -void TMovieRumble::checkRumbleOn() -{ - if (unk24 != -1 && unk1C <= unk10->getFrameNumber()) { - SMSRumbleMgr->start(unk24, -1, (f32*)nullptr); - unk28 = true; - } +void TMovieRumble::checkRumbleOn() { + if ( unk24 != -1 && unk1C <= unk10->getFrameNumber() ) { + SMSRumbleMgr->start( unk24, -1, ( f32 * )nullptr ); + unk28 = true; + } } #pragma dont_inline on -void TMovieRumble::checkRumbleOff() -{ - if (unk24 != -1 && unk20 <= unk10->getFrameNumber()) { - SMSRumbleMgr->stop(); - unk18 += 1; - readCurInfo(); - unk28 = false; - } +void TMovieRumble::checkRumbleOff() { + if ( unk24 != -1 && unk20 <= unk10->getFrameNumber() ) { + SMSRumbleMgr->stop(); + unk18 += 1; + readCurInfo(); + unk28 = false; + } } #pragma dont_inline off -void TMovieRumble::readCurInfo() -{ - int group = unk18; +void TMovieRumble::readCurInfo() { + int group = unk18; - if (isValid() && unk14->isIndexValid(group)) { - Koga::ToolData* toolData = unk14; - toolData->GetValue(group, "start_frame", unk1C); - toolData->GetValue(group, "end_frame", unk20); - const char* type; - toolData->GetValue(group, "type", type); - unk24 = RumbleType::getIndex((char*)type); - } else { - unk24 = -1; - } + if ( isValid() && unk14->isIndexValid( group ) ) { + Koga::ToolData *toolData = unk14; + toolData->GetValue( group, "start_frame", unk1C ); + toolData->GetValue( group, "end_frame", unk20 ); + const char *type; + toolData->GetValue( group, "type", type ); + unk24 = RumbleType::getIndex( ( char * )type ); + } else { + unk24 = -1; + } } -void TMovieRumble::makeBcrName(char* acStack_90, int, const char* param_1) -{ - sprintf(acStack_90, "/subtitle/rnbl/%s", param_1); - char* it = strrchr(acStack_90, '.'); - strcpy(it, ".bcr"); +void TMovieRumble::makeBcrName( char *acStack_90, int, const char *param_1 ) { + sprintf( acStack_90, "/subtitle/rnbl/%s", param_1 ); + char *it = strrchr( acStack_90, '.' ); + strcpy( it, ".bcr" ); } \ No newline at end of file diff --git a/src/MarioUtil/RumbleData.cpp b/src/MarioUtil/RumbleData.cpp index 0472fa58..6f342338 100644 --- a/src/MarioUtil/RumbleData.cpp +++ b/src/MarioUtil/RumbleData.cpp @@ -1,229 +1,228 @@ -#include #include +#include static int rumblePoint_00 = 0x0000000B; -static float rumbleFrame_00[11] - = { 0.0f, 0.05f, 0.1f, 0.15f, 0.2f, 0.25f, 0.25f, 0.33f, 0.4f, 0.5f, 0.6f }; +static float rumbleFrame_00[ 11 ] = { 0.0f, 0.05f, 0.1f, 0.15f, 0.2f, 0.25f, + 0.25f, 0.33f, 0.4f, 0.5f, 0.6f }; -static float rumblePower_00[11] - = { 1.0f, 1.0f, 1.0f, 0.9f, 0.0f, 0.0f, 0.6f, 0.6f, 0.5f, 0.2f, 0.0f }; +static float rumblePower_00[ 11 ] = { 1.0f, 1.0f, 1.0f, 0.9f, 0.0f, 0.0f, + 0.6f, 0.6f, 0.5f, 0.2f, 0.0f }; static int rumblePoint_01 = 0x00000018; -static float rumbleFrame_01[24] = { - 0.0f, 0.16f, 0.19f, 0.24f, 0.26f, 0.37f, 0.4f, 0.45f, - 0.46f, 0.54f, 0.56f, 0.61f, 0.62f, 0.7f, 0.73f, 0.78f, - 0.79f, 0.86f, 0.92f, 0.96f, 1.03f, 1.13f, 1.17f, 1.4f, +static float rumbleFrame_01[ 24 ] = { + 0.0f, 0.16f, 0.19f, 0.24f, 0.26f, 0.37f, 0.4f, 0.45f, + 0.46f, 0.54f, 0.56f, 0.61f, 0.62f, 0.7f, 0.73f, 0.78f, + 0.79f, 0.86f, 0.92f, 0.96f, 1.03f, 1.13f, 1.17f, 1.4f, }; -static float rumblePower_01[24] = { - 1.0f, 1.0f, 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, 0.0f, - 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, 0.53f, 0.0f, 0.0f, - 0.44f, 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f, +static float rumblePower_01[ 24 ] = { + 1.0f, 1.0f, 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, 0.0f, + 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, 0.53f, 0.0f, 0.0f, + 0.44f, 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f, }; static int rumblePoint_02 = 0x00000002; -static float rumbleFrame_02[2] = { 0.0f, 0.1f }; +static float rumbleFrame_02[ 2 ] = { 0.0f, 0.1f }; -static float rumblePower_02[2] = { 0.8f, 0.6f }; +static float rumblePower_02[ 2 ] = { 0.8f, 0.6f }; static int rumblePoint_03 = 0x00000002; -static float rumbleFrame_03[2] = { 0.0f, 0.1f }; +static float rumbleFrame_03[ 2 ] = { 0.0f, 0.1f }; -static float rumblePower_03[2] = { 1.0f, 1.0f }; +static float rumblePower_03[ 2 ] = { 1.0f, 1.0f }; static int rumblePoint_04 = 0x00000007; -static float rumbleFrame_04[7] = { 0.0f, 0.1f, 0.15f, 0.2f, 0.25f, 0.3f, 0.5f }; +static float rumbleFrame_04[ 7 ] = { 0.0f, 0.1f, 0.15f, 0.2f, + 0.25f, 0.3f, 0.5f }; -static float rumblePower_04[7] = { 1.0f, 1.0f, 0.0f, 0.8f, 0.8f, 0.0f, 0.0f }; +static float rumblePower_04[ 7 ] = { 1.0f, 1.0f, 0.0f, 0.8f, 0.8f, 0.0f, 0.0f }; static int rumblePoint_05 = 0x00000015; -static float rumbleFrame_05[21] - = { 0.0f, 0.18f, 0.21f, 0.28f, 0.28f, 0.4f, 0.45f, - 0.51f, 0.52f, 0.64f, 0.69f, 0.75f, 0.83f, 0.89f, - 0.99f, 1.03f, 1.12f, 1.19f, 1.25f, 1.3f, 1.4f }; +static float rumbleFrame_05[ 21 ] = { + 0.0f, 0.18f, 0.21f, 0.28f, 0.28f, 0.4f, 0.45f, 0.51f, 0.52f, 0.64f, 0.69f, + 0.75f, 0.83f, 0.89f, 0.99f, 1.03f, 1.12f, 1.19f, 1.25f, 1.3f, 1.4f }; -static float rumblePower_05[21] - = { 1.0f, 0.92f, 0.0f, 0.0f, 0.79f, 0.63f, 0.0f, - 0.02f, 0.45f, 0.31f, 0.02f, 0.24f, 0.03f, 0.18f, - 0.04f, 0.13f, 0.04f, 0.1f, 0.04f, 0.06f, 0.0f }; +static float rumblePower_05[ 21 ] = { + 1.0f, 0.92f, 0.0f, 0.0f, 0.79f, 0.63f, 0.0f, 0.02f, 0.45f, 0.31f, 0.02f, + 0.24f, 0.03f, 0.18f, 0.04f, 0.13f, 0.04f, 0.1f, 0.04f, 0.06f, 0.0f }; static int rumblePoint_06 = 0x0000000A; -static float rumbleFrame_06[10] - = { 0.0f, 0.09f, 0.09f, 0.1f, 0.17f, 0.17f, 0.18f, 0.26f, 0.26f, 0.5f }; +static float rumbleFrame_06[ 10 ] = { 0.0f, 0.09f, 0.09f, 0.1f, 0.17f, + 0.17f, 0.18f, 0.26f, 0.26f, 0.5f }; -static float rumblePower_06[10] - = { 0.85f, 0.85f, 0.1f, 0.45f, 0.45f, 0.05f, 0.25f, 0.25f, 0.01f, 0.0f }; +static float rumblePower_06[ 10 ] = { 0.85f, 0.85f, 0.1f, 0.45f, 0.45f, + 0.05f, 0.25f, 0.25f, 0.01f, 0.0f }; static int rumblePoint_07 = 0x00000014; -static float rumbleFrame_07[20] - = { 0.0f, 0.11f, 0.12f, 0.13f, 0.2f, 0.21f, 0.29f, 0.31f, 0.33f, 0.41f, - 0.42f, 0.52f, 0.53f, 0.54f, 0.62f, 0.64f, 0.72f, 0.74f, 0.75f, 1.0f }; +static float rumbleFrame_07[ 20 ] = { + 0.0f, 0.11f, 0.12f, 0.13f, 0.2f, 0.21f, 0.29f, 0.31f, 0.33f, 0.41f, + 0.42f, 0.52f, 0.53f, 0.54f, 0.62f, 0.64f, 0.72f, 0.74f, 0.75f, 1.0f }; -static float rumblePower_07[20] - = { 0.95f, 0.97f, 0.85f, 0.0f, 0.0f, 0.75f, 0.73f, 0.55f, 0.0f, 0.0f, - 0.6f, 0.63f, 0.32f, 0.0f, 0.0f, 0.51f, 0.48f, 0.19f, 0.02f, 0.0f }; +static float rumblePower_07[ 20 ] = { + 0.95f, 0.97f, 0.85f, 0.0f, 0.0f, 0.75f, 0.73f, 0.55f, 0.0f, 0.0f, + 0.6f, 0.63f, 0.32f, 0.0f, 0.0f, 0.51f, 0.48f, 0.19f, 0.02f, 0.0f }; static int rumblePoint_08 = 0x00000004; -static float rumbleFrame_08[5] = { 0.0f, 0.3f, 0.5f, 0.7f, 1.0f }; +static float rumbleFrame_08[ 5 ] = { 0.0f, 0.3f, 0.5f, 0.7f, 1.0f }; -static float rumblePower_08[5] = { 1.0f, 0.5f, 0.35f, 0.5f, 1.0f }; +static float rumblePower_08[ 5 ] = { 1.0f, 0.5f, 0.35f, 0.5f, 1.0f }; static int rumblePoint_09 = 0x00000004; -static float rumbleFrame_09[4] = { 0.0f, 0.3f, 0.5f, 0.7f }; +static float rumbleFrame_09[ 4 ] = { 0.0f, 0.3f, 0.5f, 0.7f }; -static float rumblePower_09[4] = { 0.5f, 0.24f, 0.18f, 0.23f }; +static float rumblePower_09[ 4 ] = { 0.5f, 0.24f, 0.18f, 0.23f }; static int rumblePoint_10 = 0x00000001; -static float rumbleFrame_10[1] = { 0.0f }; +static float rumbleFrame_10[ 1 ] = { 0.0f }; -static float rumblePower_10[1] = { 0.0f }; +static float rumblePower_10[ 1 ] = { 0.0f }; static int rumblePoint_11 = 0x00000001; -static float rumbleFrame_11[1] = { 0.0f }; +static float rumbleFrame_11[ 1 ] = { 0.0f }; -static float rumblePower_11[1] = { 0.0f }; +static float rumblePower_11[ 1 ] = { 0.0f }; static int rumblePoint_12 = 0x00000001; -static float rumbleFrame_12[1] = { 0.0f }; +static float rumbleFrame_12[ 1 ] = { 0.0f }; -static float rumblePower_12[1] = { 0.0f }; +static float rumblePower_12[ 1 ] = { 0.0f }; static int rumblePoint_13 = 0x00000001; -static float rumbleFrame_13[1] = { 0.0f }; +static float rumbleFrame_13[ 1 ] = { 0.0f }; -static float rumblePower_13[1] = { 0.0f }; +static float rumblePower_13[ 1 ] = { 0.0f }; static int rumblePoint_14 = 0x00000001; -static float rumbleFrame_14[1] = { 0.0f }; +static float rumbleFrame_14[ 1 ] = { 0.0f }; -static float rumblePower_14[1] = { 0.0f }; +static float rumblePower_14[ 1 ] = { 0.0f }; static int rumblePoint_15 = 0x00000001; -static float rumbleFrame_15[1] = { 0.0f }; +static float rumbleFrame_15[ 1 ] = { 0.0f }; -static float rumblePower_15[1] = { 0.0f }; +static float rumblePower_15[ 1 ] = { 0.0f }; static int rumblePoint_16 = 0x00000001; -static float rumbleFrame_16[1] = { 0.0f }; +static float rumbleFrame_16[ 1 ] = { 0.0f }; -static float rumblePower_16[1] = { 0.0f }; +static float rumblePower_16[ 1 ] = { 0.0f }; static int rumblePoint_17 = 0x00000001; -static float rumbleFrame_17[1] = { 0.0f }; +static float rumbleFrame_17[ 1 ] = { 0.0f }; -static float rumblePower_17[1] = { 0.0f }; +static float rumblePower_17[ 1 ] = { 0.0f }; static int rumblePoint_18 = 0x00000001; -static float rumbleFrame_18[1] = { 0.0f }; +static float rumbleFrame_18[ 1 ] = { 0.0f }; -static float rumblePower_18[1] = { 0.0f }; +static float rumblePower_18[ 1 ] = { 0.0f }; static int rumblePoint_19 = 0x00000005; -static float rumbleFrame_19[5] = { 0.0f, 0.11f, 0.2f, 0.32f, 0.4f }; +static float rumbleFrame_19[ 5 ] = { 0.0f, 0.11f, 0.2f, 0.32f, 0.4f }; -static float rumblePower_19[5] = { 0.6f, 0.4f, 0.6f, 0.4f, 0.6f }; +static float rumblePower_19[ 5 ] = { 0.6f, 0.4f, 0.6f, 0.4f, 0.6f }; static int rumblePoint_20 = 0x00000002; -static float rumbleFrame_20[2] = { 0.0f, 1.0f / 60.0f }; +static float rumbleFrame_20[ 2 ] = { 0.0f, 1.0f / 60.0f }; -static float rumblePower_20[2] = { 0.5f, 0.5f }; +static float rumblePower_20[ 2 ] = { 0.5f, 0.5f }; static int rumblePoint_21 = 0x00000002; -static float rumbleFrame_21[2] = { 0.0f, 1.0f / 60.0f }; +static float rumbleFrame_21[ 2 ] = { 0.0f, 1.0f / 60.0f }; -static float rumblePower_21[2] = { 0.75f, 0.75f }; +static float rumblePower_21[ 2 ] = { 0.75f, 0.75f }; static int rumblePoint_22 = 0x00000002; -static float rumbleFrame_22[2] = { 0.0f, 2.0f }; +static float rumbleFrame_22[ 2 ] = { 0.0f, 2.0f }; -static float rumblePower_22[2] = { 0.75f, 0.75f }; +static float rumblePower_22[ 2 ] = { 0.75f, 0.75f }; static int rumblePoint_23 = 0x0000004D; -static float rumbleFrame_23[77] - = { 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, - 1.2f, 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, - 4.16f, 4.17f, 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, - 5.18f, 5.28f, 5.32f, 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, - 5.68f, 6.35f, 6.36f, 6.57f, 6.68f, 6.85f, 6.88f, 7.11f, 7.18f, - 7.5f, 7.66f, 8.09f, 8.67f, 9.08f, 9.1f, 9.63f, 9.64f, 9.65f, - 9.81f, 9.84f, 9.89f, 9.91f, 10.02f, 10.04f, 10.05f, 10.06f, 10.19f, - 10.21f, 10.22f, 10.23f, 10.35f, 10.38f, 10.43f, 10.45f, 10.51f, 10.57f, - 10.61f, 10.68f, 10.78f, 10.82f, 11.0f }; - -static float rumblePower_23[77] - = { 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, - 0.72f, 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, - 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, - 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f, 0.0f, 0.78f, 0.71f, - 0.0f, 0.0f, 0.78f, 0.68f, 0.0f, 0.0f, 0.42f, 0.72f, 0.87f, 1.0f, - 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, - 0.0f, 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, 0.53f, 0.0f, 0.0f, 0.44f, - 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f }; +static float rumbleFrame_23[ 77 ] = { + 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, + 1.2f, 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, + 4.16f, 4.17f, 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, + 5.18f, 5.28f, 5.32f, 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, + 5.68f, 6.35f, 6.36f, 6.57f, 6.68f, 6.85f, 6.88f, 7.11f, 7.18f, + 7.5f, 7.66f, 8.09f, 8.67f, 9.08f, 9.1f, 9.63f, 9.64f, 9.65f, + 9.81f, 9.84f, 9.89f, 9.91f, 10.02f, 10.04f, 10.05f, 10.06f, 10.19f, + 10.21f, 10.22f, 10.23f, 10.35f, 10.38f, 10.43f, 10.45f, 10.51f, 10.57f, + 10.61f, 10.68f, 10.78f, 10.82f, 11.0f }; + +static float rumblePower_23[ 77 ] = { + 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, + 0.72f, 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, + 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, + 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f, 0.0f, 0.78f, 0.71f, + 0.0f, 0.0f, 0.78f, 0.68f, 0.0f, 0.0f, 0.42f, 0.72f, 0.87f, 1.0f, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, + 0.0f, 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, 0.53f, 0.0f, 0.0f, 0.44f, + 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f }; static int rumblePoint_24 = 0x00000025; -static float rumbleFrame_24[37] - = { 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, 1.2f, - 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, 4.16f, 4.17f, - 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, 5.18f, 5.28f, 5.32f, - 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, 5.68f }; - -static float rumblePower_24[37] - = { 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, - 0.72f, 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, - 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, - 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f }; - -RumbleChannelDataTbl channelDataTbl[25] = { - { &rumblePoint_00, rumbleFrame_00, rumblePower_00 }, - { &rumblePoint_01, rumbleFrame_01, rumblePower_01 }, - { &rumblePoint_02, rumbleFrame_02, rumblePower_02 }, - { &rumblePoint_03, rumbleFrame_03, rumblePower_03 }, - { &rumblePoint_04, rumbleFrame_04, rumblePower_04 }, - { &rumblePoint_05, rumbleFrame_05, rumblePower_05 }, - { &rumblePoint_06, rumbleFrame_06, rumblePower_06 }, - { &rumblePoint_07, rumbleFrame_07, rumblePower_07 }, - { &rumblePoint_08, rumbleFrame_08, rumblePower_08 }, - { &rumblePoint_09, rumbleFrame_09, rumblePower_09 }, - { &rumblePoint_10, rumbleFrame_10, rumblePower_10 }, - { &rumblePoint_11, rumbleFrame_11, rumblePower_11 }, - { &rumblePoint_12, rumbleFrame_12, rumblePower_12 }, - { &rumblePoint_13, rumbleFrame_13, rumblePower_13 }, - { &rumblePoint_14, rumbleFrame_14, rumblePower_14 }, - { &rumblePoint_15, rumbleFrame_15, rumblePower_15 }, - { &rumblePoint_16, rumbleFrame_16, rumblePower_16 }, - { &rumblePoint_17, rumbleFrame_17, rumblePower_17 }, - { &rumblePoint_18, rumbleFrame_18, rumblePower_18 }, - { &rumblePoint_19, rumbleFrame_19, rumblePower_19 }, - { &rumblePoint_20, rumbleFrame_20, rumblePower_20 }, - { &rumblePoint_21, rumbleFrame_21, rumblePower_21 }, - { &rumblePoint_22, rumbleFrame_22, rumblePower_22 }, - { &rumblePoint_23, rumbleFrame_23, rumblePower_23 }, - { &rumblePoint_24, rumbleFrame_24, rumblePower_24 }, +static float rumbleFrame_24[ 37 ] = { + 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, 1.2f, + 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, 4.16f, 4.17f, + 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, 5.18f, 5.28f, 5.32f, + 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, 5.68f }; + +static float rumblePower_24[ 37 ] = { + 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, + 0.72f, 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, + 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, + 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f }; + +RumbleChannelDataTbl channelDataTbl[ 25 ] = { + { &rumblePoint_00, rumbleFrame_00, rumblePower_00 }, + { &rumblePoint_01, rumbleFrame_01, rumblePower_01 }, + { &rumblePoint_02, rumbleFrame_02, rumblePower_02 }, + { &rumblePoint_03, rumbleFrame_03, rumblePower_03 }, + { &rumblePoint_04, rumbleFrame_04, rumblePower_04 }, + { &rumblePoint_05, rumbleFrame_05, rumblePower_05 }, + { &rumblePoint_06, rumbleFrame_06, rumblePower_06 }, + { &rumblePoint_07, rumbleFrame_07, rumblePower_07 }, + { &rumblePoint_08, rumbleFrame_08, rumblePower_08 }, + { &rumblePoint_09, rumbleFrame_09, rumblePower_09 }, + { &rumblePoint_10, rumbleFrame_10, rumblePower_10 }, + { &rumblePoint_11, rumbleFrame_11, rumblePower_11 }, + { &rumblePoint_12, rumbleFrame_12, rumblePower_12 }, + { &rumblePoint_13, rumbleFrame_13, rumblePower_13 }, + { &rumblePoint_14, rumbleFrame_14, rumblePower_14 }, + { &rumblePoint_15, rumbleFrame_15, rumblePower_15 }, + { &rumblePoint_16, rumbleFrame_16, rumblePower_16 }, + { &rumblePoint_17, rumbleFrame_17, rumblePower_17 }, + { &rumblePoint_18, rumbleFrame_18, rumblePower_18 }, + { &rumblePoint_19, rumbleFrame_19, rumblePower_19 }, + { &rumblePoint_20, rumbleFrame_20, rumblePower_20 }, + { &rumblePoint_21, rumbleFrame_21, rumblePower_21 }, + { &rumblePoint_22, rumbleFrame_22, rumblePower_22 }, + { &rumblePoint_23, rumbleFrame_23, rumblePower_23 }, + { &rumblePoint_24, rumbleFrame_24, rumblePower_24 }, }; -int channelNum = ARRAY_COUNT(channelDataTbl); \ No newline at end of file +int channelNum = ARRAY_COUNT( channelDataTbl ); \ No newline at end of file diff --git a/src/MarioUtil/RumbleMgr.cpp b/src/MarioUtil/RumbleMgr.cpp index f0fa87c1..f17494fe 100644 --- a/src/MarioUtil/RumbleMgr.cpp +++ b/src/MarioUtil/RumbleMgr.cpp @@ -1,616 +1,594 @@ -#include #include -#include +#include #include +#include -int RumbleMgr::mMotorCountLimit = 900; +int RumbleMgr::mMotorCountLimit = 900; u16 RumbleMgr::mMotorTimerPeriod = 80; -f32 RumbleMgr::mPowerThreshold = 0.5f; +f32 RumbleMgr::mPowerThreshold = 0.5f; -RumbleMgr* SMSRumbleMgr = nullptr; +RumbleMgr *SMSRumbleMgr = nullptr; // Size needed: 0x10, current: 0x10 -void RumbleBase::init() -{ - mPower = 0.0f; - mAccumulator = 0.0f; +void RumbleBase::init() { + mPower = 0.0f; + mAccumulator = 0.0f; } // Size needed: 0x28, current: 0x28 -void RumbleBase::stop() { PADControlMotor(mChan, PAD_MOTOR_STOP_HARD); } +void RumbleBase::stop() { PADControlMotor( mChan, PAD_MOTOR_STOP_HARD ); } // Size needed: 0xAC, current: 0xA0 -void RumbleBase::update(f32 power, bool stopHard) -{ - // This function is the likely cause for stack mismatch in - // RumbleMgr::update() as it's the only one whose size mismatches. - mPower = power; - mAccumulator += mPower; - - if (mPower <= 0.0f) { - PADControlMotor(mChan, PAD_MOTOR_STOP_HARD); - } else if (mAccumulator < 1.0f) { - if (stopHard) { - PADControlMotor(mChan, PAD_MOTOR_STOP_HARD); - } else { - PADControlMotor(mChan, PAD_MOTOR_STOP); - } - } else { - // @fake - this doesn't fix our function size but it does match stack in - // RumbleMgr::update() - // f32 accumulator = mAccumulator; - // mAccumulator = accumulator - 1.0f; - mAccumulator -= 1.0f; - PADControlMotor(mChan, PAD_MOTOR_RUMBLE); - } +void RumbleBase::update( f32 power, bool stopHard ) { + // This function is the likely cause for stack mismatch in + // RumbleMgr::update() as it's the only one whose size mismatches. + mPower = power; + mAccumulator += mPower; + + if ( mPower <= 0.0f ) { + PADControlMotor( mChan, PAD_MOTOR_STOP_HARD ); + } else if ( mAccumulator < 1.0f ) { + if ( stopHard ) { + PADControlMotor( mChan, PAD_MOTOR_STOP_HARD ); + } else { + PADControlMotor( mChan, PAD_MOTOR_STOP ); + } + } else { + // @fake - this doesn't fix our function size but it does match stack in + // RumbleMgr::update() + // f32 accumulator = mAccumulator; + // mAccumulator = accumulator - 1.0f; + mAccumulator -= 1.0f; + PADControlMotor( mChan, PAD_MOTOR_RUMBLE ); + } } // Size needed: 0x10, current: 0x10 void RumbleChannelDataMgr::init() { mChannelDataTbl = channelDataTbl; } // Size needed: 0x14, current: 0x14 -RumbleChannelDataTbl* RumbleChannelDataMgr::getChannelDataTbl(int index) -{ - // This feels wrong, but I only see direct loads from channelDataTbl. - // Also, it only matches size when doing this. - return &channelDataTbl[index]; +RumbleChannelDataTbl *RumbleChannelDataMgr::getChannelDataTbl( int index ) { + // This feels wrong, but I only see direct loads from channelDataTbl. + // Also, it only matches size when doing this. + return &channelDataTbl[ index ]; } -RumbleChannelMgr::RumbleChannelMgr() -{ - mElapsedTime = 0.0f; - mPower = 0.0f; - mChannelDataIdx = -1; - mRepeatCount = 0; - mMultiplierF = nullptr; - mWorldPos = nullptr; - mChannelDataTbl = nullptr; +RumbleChannelMgr::RumbleChannelMgr() { + mElapsedTime = 0.0f; + mPower = 0.0f; + mChannelDataIdx = -1; + mRepeatCount = 0; + mMultiplierF = nullptr; + mWorldPos = nullptr; + mChannelDataTbl = nullptr; } // Size needed: 0x30, current: 0x2C -void RumbleChannelMgr::init(RumbleChannelDataMgr* dataMgr) -{ - mElapsedTime = 0.0f; - mPower = 0.0f; - mChannelDataIdx = -1; - mRepeatCount = 0; - mMultiplierF = nullptr; - mWorldPos = nullptr; - mChannelDataTbl = nullptr; - mChannelDataMgr = dataMgr; +void RumbleChannelMgr::init( RumbleChannelDataMgr *dataMgr ) { + mElapsedTime = 0.0f; + mPower = 0.0f; + mChannelDataIdx = -1; + mRepeatCount = 0; + mMultiplierF = nullptr; + mWorldPos = nullptr; + mChannelDataTbl = nullptr; + mChannelDataMgr = dataMgr; } // Size needed: 0x2C, current: 0x2C -void RumbleChannelMgr::reset() -{ - mElapsedTime = 0.0f; - mPower = 0.0f; - mChannelDataIdx = -1; - mRepeatCount = 0; - mMultiplierF = nullptr; - mWorldPos = nullptr; - mChannelDataTbl = nullptr; +void RumbleChannelMgr::reset() { + mElapsedTime = 0.0f; + mPower = 0.0f; + mChannelDataIdx = -1; + mRepeatCount = 0; + mMultiplierF = nullptr; + mWorldPos = nullptr; + mChannelDataTbl = nullptr; } // Size needed: 0x0C, current: 0x0C void RumbleChannelMgr::repeat() { mElapsedTime = 0.0f; } // Size needed: 0x2C, current: 0x2C -void RumbleChannelMgr::start(int channelDataIdx, int repeatCount, - f32* multiplierF) -{ - mElapsedTime = 0.0f; - mChannelDataTbl = mChannelDataMgr->getChannelDataTbl(channelDataIdx); - mChannelDataIdx = channelDataIdx; - mRepeatCount = repeatCount; - mMultiplierF = multiplierF; +void RumbleChannelMgr::start( int channelDataIdx, int repeatCount, + f32 *multiplierF ) { + mElapsedTime = 0.0f; + mChannelDataTbl = mChannelDataMgr->getChannelDataTbl( channelDataIdx ); + mChannelDataIdx = channelDataIdx; + mRepeatCount = repeatCount; + mMultiplierF = multiplierF; } // Size needed: 0x2C, current: 0x2C -void RumbleChannelMgr::start(int channelDataIdx, int repeatCount, Vec* worldPos) -{ - mElapsedTime = 0.0f; - mChannelDataTbl = mChannelDataMgr->getChannelDataTbl(channelDataIdx); - mChannelDataIdx = channelDataIdx; - mRepeatCount = repeatCount; - mWorldPos = worldPos; -} - -f32 RumbleChannelMgr::update() -{ - f32 updateRate = 1.0f / SMSGetVSyncTimesPerSec(); - f32 mult; - - if (mMultiplierF != nullptr) { - mult = *mMultiplierF; - if (mult < 0.0f) { - mult = 0.0f; - } else if (mult > 1.0f) { - mult = 1.0f; - } - } else if (mWorldPos != nullptr) { - JGeometry::TVec3& v - = *static_cast*>(mWorldPos); - f32 dist = SMS_DistanceFromMario(v); - mult = -((dist - 300.0f) * (1.0f / 3000.0f) - 1.0f); - if (mult < 0.0f) { - mult = 0.0f; - } else if (mult > 1.0f) { - mult = 1.0f; - } - } else { - mult = 1.0f; - } - - mPower = 0.0f; - if (mRepeatCount == 0) { - reset(); - } - - if (mChannelDataTbl != nullptr) { - mElapsedTime += updateRate; - - for (int i = 0; i < *mChannelDataTbl->mPointData - 1; i++) { - if (mElapsedTime > mChannelDataTbl->mFrameData[i]) { - f32 delta = mChannelDataTbl->mFrameData[i + 1] - - mChannelDataTbl->mFrameData[i]; - f32 frameDelta = mElapsedTime - mChannelDataTbl->mFrameData[i]; - f32 progress; - - if (delta > 0.0f) { - progress = frameDelta / delta; - } else { - progress = 1.0f; - } - - mPower = (1.0f - progress) * mChannelDataTbl->mPowerData[i] - + progress * mChannelDataTbl->mPowerData[i + 1]; - } - } - - if (mElapsedTime - > mChannelDataTbl->mFrameData[*mChannelDataTbl->mPointData - 1]) { - if (mRepeatCount > 1) { - repeat(); - mRepeatCount--; - } else if (mRepeatCount < 0) { - repeat(); - } else { - reset(); - } - } - } - - mPower *= mult; - return mPower; +void RumbleChannelMgr::start( int channelDataIdx, int repeatCount, + Vec *worldPos ) { + mElapsedTime = 0.0f; + mChannelDataTbl = mChannelDataMgr->getChannelDataTbl( channelDataIdx ); + mChannelDataIdx = channelDataIdx; + mRepeatCount = repeatCount; + mWorldPos = worldPos; +} + +f32 RumbleChannelMgr::update() { + f32 updateRate = 1.0f / SMSGetVSyncTimesPerSec(); + f32 mult; + + if ( mMultiplierF != nullptr ) { + mult = *mMultiplierF; + if ( mult < 0.0f ) { + mult = 0.0f; + } else if ( mult > 1.0f ) { + mult = 1.0f; + } + } else if ( mWorldPos != nullptr ) { + JGeometry::TVec3< f32 > &v = + *static_cast< JGeometry::TVec3< f32 > * >( mWorldPos ); + f32 dist = SMS_DistanceFromMario( v ); + mult = -( ( dist - 300.0f ) * ( 1.0f / 3000.0f ) - 1.0f ); + if ( mult < 0.0f ) { + mult = 0.0f; + } else if ( mult > 1.0f ) { + mult = 1.0f; + } + } else { + mult = 1.0f; + } + + mPower = 0.0f; + if ( mRepeatCount == 0 ) { + reset(); + } + + if ( mChannelDataTbl != nullptr ) { + mElapsedTime += updateRate; + + for ( int i = 0; i < *mChannelDataTbl->mPointData - 1; i++ ) { + if ( mElapsedTime > mChannelDataTbl->mFrameData[ i ] ) { + f32 delta = mChannelDataTbl->mFrameData[ i + 1 ] - + mChannelDataTbl->mFrameData[ i ]; + f32 frameDelta = + mElapsedTime - mChannelDataTbl->mFrameData[ i ]; + f32 progress; + + if ( delta > 0.0f ) { + progress = frameDelta / delta; + } else { + progress = 1.0f; + } + + mPower = + ( 1.0f - progress ) * mChannelDataTbl->mPowerData[ i ] + + progress * mChannelDataTbl->mPowerData[ i + 1 ]; + } + } + + if ( mElapsedTime > + mChannelDataTbl->mFrameData[ *mChannelDataTbl->mPointData - 1 ] ) { + if ( mRepeatCount > 1 ) { + repeat(); + mRepeatCount--; + } else if ( mRepeatCount < 0 ) { + repeat(); + } else { + reset(); + } + } + } + + mPower *= mult; + return mPower; } // Size needed: 0x58, current: 0x58 -RumbleControllerMgr::RumbleControllerMgr() -{ - mPower = 0.0f; - mChannelMgrTbl = new RumbleChannelMgr[RUMBLE_CHANNELS_PER_CONTROLLER]; +RumbleControllerMgr::RumbleControllerMgr() { + mPower = 0.0f; + mChannelMgrTbl = new RumbleChannelMgr[ RUMBLE_CHANNELS_PER_CONTROLLER ]; } // Size needed: 0x1C4, current: 0x19C -void RumbleControllerMgr::init() -{ - mPower = 0.0f; +void RumbleControllerMgr::init() { + mPower = 0.0f; - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - mChannelMgrTbl[i].init(mChannelDataMgr); - } + for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { + mChannelMgrTbl[ i ].init( mChannelDataMgr ); + } } -void RumbleControllerMgr::reset() -{ - mPower = 0.0f; +void RumbleControllerMgr::reset() { + mPower = 0.0f; - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - mChannelMgrTbl[i].reset(); - } + for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { + mChannelMgrTbl[ i ].reset(); + } - mMotorCounter = 0; - mMotorTimer = 0; - unk12 = 0; + mMotorCounter = 0; + mMotorTimer = 0; + unk12 = 0; } // Hmm... why does this inline in RumbleMgr::start(int, f32*)? #pragma dont_inline on -void RumbleControllerMgr::start(int channelDataIdx, int repeatCount, - f32* multiplierF) -{ - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - if (mChannelMgrTbl[i].mChannelDataTbl == nullptr) { - mChannelMgrTbl[i].start(channelDataIdx, repeatCount, multiplierF); - break; - } - } +void RumbleControllerMgr::start( int channelDataIdx, int repeatCount, + f32 *multiplierF ) { + for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { + if ( mChannelMgrTbl[ i ].mChannelDataTbl == nullptr ) { + mChannelMgrTbl[ i ].start( channelDataIdx, repeatCount, + multiplierF ); + break; + } + } } #pragma dont_inline reset // This one also inlines in RumbleMgr::start(int, Vec*)? #pragma dont_inline on -void RumbleControllerMgr::start(int channelDataIdx, int repeatCount, - Vec* worldPos) -{ - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - if (mChannelMgrTbl[i].mChannelDataTbl == nullptr) { - mChannelMgrTbl[i].start(channelDataIdx, repeatCount, worldPos); - break; - } - } +void RumbleControllerMgr::start( int channelDataIdx, int repeatCount, + Vec *worldPos ) { + for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { + if ( mChannelMgrTbl[ i ].mChannelDataTbl == nullptr ) { + mChannelMgrTbl[ i ].start( channelDataIdx, repeatCount, worldPos ); + break; + } + } } #pragma dont_inline reset // Size needed: 0x10C, current: 0x10C -void RumbleControllerMgr::stop() -{ - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - if (mChannelMgrTbl[i].mChannelDataTbl != nullptr) { - mChannelMgrTbl[i].reset(); - } - } +void RumbleControllerMgr::stop() { + for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { + if ( mChannelMgrTbl[ i ].mChannelDataTbl != nullptr ) { + mChannelMgrTbl[ i ].reset(); + } + } } // This one also inlines in RumbleMgr::stop(int)? #pragma dont_inline on -void RumbleControllerMgr::stop(int channelDataIdx) -{ - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - if (mChannelMgrTbl[i].mChannelDataTbl != nullptr - && mChannelMgrTbl[i].mChannelDataIdx == channelDataIdx) { - mChannelMgrTbl[i].reset(); - } - } +void RumbleControllerMgr::stop( int channelDataIdx ) { + for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { + if ( mChannelMgrTbl[ i ].mChannelDataTbl != nullptr && + mChannelMgrTbl[ i ].mChannelDataIdx == channelDataIdx ) { + mChannelMgrTbl[ i ].reset(); + } + } } #pragma dont_inline reset // Size needed: 0x11C, current: 0x11C -bool RumbleControllerMgr::channelMgrIsAllFree() -{ - bool allFree = true; - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - if (mChannelMgrTbl[i].mChannelDataTbl != nullptr) { - allFree = false; - } - } - return allFree; -} - -void RumbleControllerMgr::updateMotorCount() -{ - if (unk12) { - if (mMotorCounter > 0) { - mMotorCounter--; - } else { - unk12 = 0; - mMotorTimer = 0; - } - } else if (mMotorCounter > RumbleMgr::mMotorCountLimit) { - unk12 = 1; - } else if (mMotorTimer > 0) { - mMotorTimer--; - mMotorCounter++; - } else { - mMotorCounter = 0; - } -} - -f32 RumbleControllerMgr::update() -{ - f32 maxPower = 0.0f; - for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { - if (mChannelMgrTbl[i].mChannelDataTbl != nullptr) { - mPower = mChannelMgrTbl[i].update(); - if (mPower > maxPower) { - maxPower = mPower; - } - } - } - - mPower = maxPower; - if (mPower > 1.0f) { - mPower = 1.0f; - } else if (mPower < 0.0f) { - mPower = 0.0f; - } - - if (mPower > RumbleMgr::mPowerThreshold) { - mMotorTimer = RumbleMgr::mMotorTimerPeriod; - } - - if (unk12) { - mPower = 0.0f; - } - - return mPower; -} - -RumbleMgr::RumbleMgr(bool controller1, bool controller2, bool controller3, - bool controller4) -{ - bool enable[4]; - - mPower = 0.0f; - mTimer = 0.0f; - - enable[0] = controller1; - enable[1] = controller2; - enable[2] = controller3; - enable[3] = controller4; - - for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { - mControllerMgrTbl[i] = nullptr; - mRumbleBaseTbl[i] = nullptr; - - if (enable[i]) { - mControllerMgrTbl[i] = new RumbleControllerMgr(); - mRumbleBaseTbl[i] = new RumbleBase(i); - } - } - - mChannelDataMgr = nullptr; - mChannelDataMgr = new RumbleChannelDataMgr(); - mActive = true; - mPaused = false; - mStopHard = true; -} - -void RumbleMgr::init() -{ - mPower = 0.0f; - mTimer = 0.0f; - - for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { - if (mControllerMgrTbl[i] != nullptr) { - mControllerMgrTbl[i]->init(); - mRumbleBaseTbl[i]->init(); - } - } - - mChannelDataMgr->init(); - mActive = true; - mPaused = false; - mStopHard = true; -} - -void RumbleMgr::reset() -{ - mPower = 0.0f; - mTimer = 0.0f; - - for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { - if (mControllerMgrTbl[i] != nullptr) { - mControllerMgrTbl[i]->reset(); - mRumbleBaseTbl[i]->stop(); - mRumbleBaseTbl[i]->init(); - } - } - - mPaused = 0; -} - -void RumbleMgr::start(int channelDataIdx, f32* multiplierF) -{ - int controllerIdx = 0; +bool RumbleControllerMgr::channelMgrIsAllFree() { + bool allFree = true; + for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { + if ( mChannelMgrTbl[ i ].mChannelDataTbl != nullptr ) { + allFree = false; + } + } + return allFree; +} + +void RumbleControllerMgr::updateMotorCount() { + if ( unk12 ) { + if ( mMotorCounter > 0 ) { + mMotorCounter--; + } else { + unk12 = 0; + mMotorTimer = 0; + } + } else if ( mMotorCounter > RumbleMgr::mMotorCountLimit ) { + unk12 = 1; + } else if ( mMotorTimer > 0 ) { + mMotorTimer--; + mMotorCounter++; + } else { + mMotorCounter = 0; + } +} + +f32 RumbleControllerMgr::update() { + f32 maxPower = 0.0f; + for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { + if ( mChannelMgrTbl[ i ].mChannelDataTbl != nullptr ) { + mPower = mChannelMgrTbl[ i ].update(); + if ( mPower > maxPower ) { + maxPower = mPower; + } + } + } + + mPower = maxPower; + if ( mPower > 1.0f ) { + mPower = 1.0f; + } else if ( mPower < 0.0f ) { + mPower = 0.0f; + } + + if ( mPower > RumbleMgr::mPowerThreshold ) { + mMotorTimer = RumbleMgr::mMotorTimerPeriod; + } + + if ( unk12 ) { + mPower = 0.0f; + } + + return mPower; +} + +RumbleMgr::RumbleMgr( bool controller1, bool controller2, bool controller3, + bool controller4 ) { + bool enable[ 4 ]; + + mPower = 0.0f; + mTimer = 0.0f; + + enable[ 0 ] = controller1; + enable[ 1 ] = controller2; + enable[ 2 ] = controller3; + enable[ 3 ] = controller4; + + for ( int i = 0; i < PAD_MAX_CONTROLLERS; i++ ) { + mControllerMgrTbl[ i ] = nullptr; + mRumbleBaseTbl[ i ] = nullptr; + + if ( enable[ i ] ) { + mControllerMgrTbl[ i ] = new RumbleControllerMgr(); + mRumbleBaseTbl[ i ] = new RumbleBase( i ); + } + } + + mChannelDataMgr = nullptr; + mChannelDataMgr = new RumbleChannelDataMgr(); + mActive = true; + mPaused = false; + mStopHard = true; +} + +void RumbleMgr::init() { + mPower = 0.0f; + mTimer = 0.0f; + + for ( int i = 0; i < PAD_MAX_CONTROLLERS; i++ ) { + if ( mControllerMgrTbl[ i ] != nullptr ) { + mControllerMgrTbl[ i ]->init(); + mRumbleBaseTbl[ i ]->init(); + } + } + + mChannelDataMgr->init(); + mActive = true; + mPaused = false; + mStopHard = true; +} + +void RumbleMgr::reset() { + mPower = 0.0f; + mTimer = 0.0f; + + for ( int i = 0; i < PAD_MAX_CONTROLLERS; i++ ) { + if ( mControllerMgrTbl[ i ] != nullptr ) { + mControllerMgrTbl[ i ]->reset(); + mRumbleBaseTbl[ i ]->stop(); + mRumbleBaseTbl[ i ]->init(); + } + } + + mPaused = 0; +} + +void RumbleMgr::start( int channelDataIdx, f32 *multiplierF ) { + int controllerIdx = 0; - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, 1, multiplierF); - } + if ( !mPaused && mActive && + mControllerMgrTbl[ controllerIdx ] != nullptr ) { + mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, 1, + multiplierF ); + } } -void RumbleMgr::start(int channelDataIdx, Vec* worldPos) -{ - int controllerIdx = 0; +void RumbleMgr::start( int channelDataIdx, Vec *worldPos ) { + int controllerIdx = 0; - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, 1, worldPos); - } + if ( !mPaused && mActive && + mControllerMgrTbl[ controllerIdx ] != nullptr ) { + mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, 1, + worldPos ); + } } // Size needed: 0x74, current: 0x74 -void RumbleMgr::start(int channelDataIdx, MtxPtr mtx) -{ - int controllerIdx = 0; +void RumbleMgr::start( int channelDataIdx, MtxPtr mtx ) { + int controllerIdx = 0; - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - Vec worldPos; - worldPos.x = mtx[3][0]; - worldPos.y = mtx[3][1]; - worldPos.z = mtx[3][2]; + if ( !mPaused && mActive && + mControllerMgrTbl[ controllerIdx ] != nullptr ) { + Vec worldPos; + worldPos.x = mtx[ 3 ][ 0 ]; + worldPos.y = mtx[ 3 ][ 1 ]; + worldPos.z = mtx[ 3 ][ 2 ]; - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, 1, &worldPos); - } + mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, 1, + &worldPos ); + } } -void RumbleMgr::start(int channelDataIdx, int repeatCount, f32* multiplierF) -{ - int controllerIdx = 0; +void RumbleMgr::start( int channelDataIdx, int repeatCount, f32 *multiplierF ) { + int controllerIdx = 0; - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, - multiplierF); - } + if ( !mPaused && mActive && + mControllerMgrTbl[ controllerIdx ] != nullptr ) { + mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, repeatCount, + multiplierF ); + } } -void RumbleMgr::start(int channelDataIdx, int repeatCount, Vec* worldPos) -{ - int controllerIdx = 0; +void RumbleMgr::start( int channelDataIdx, int repeatCount, Vec *worldPos ) { + int controllerIdx = 0; - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, - worldPos); - } + if ( !mPaused && mActive && + mControllerMgrTbl[ controllerIdx ] != nullptr ) { + mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, repeatCount, + worldPos ); + } } // Size needed: 0x70, current: 0x70 -void RumbleMgr::start(int channelDataIdx, int repeatCount, MtxPtr mtx) -{ - int controllerIdx = 0; +void RumbleMgr::start( int channelDataIdx, int repeatCount, MtxPtr mtx ) { + int controllerIdx = 0; - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - Vec worldPos; - worldPos.x = mtx[3][0]; - worldPos.y = mtx[3][1]; - worldPos.z = mtx[3][2]; + if ( !mPaused && mActive && + mControllerMgrTbl[ controllerIdx ] != nullptr ) { + Vec worldPos; + worldPos.x = mtx[ 3 ][ 0 ]; + worldPos.y = mtx[ 3 ][ 1 ]; + worldPos.z = mtx[ 3 ][ 2 ]; - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, - &worldPos); - } + mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, repeatCount, + &worldPos ); + } } // Size needed: 0x94, current: 0x58 -void RumbleMgr::start(int controllerIdx, int channelDataIdx, int repeatCount, - f32* multiplierF) -{ - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, - multiplierF); - } +void RumbleMgr::start( int controllerIdx, int channelDataIdx, int repeatCount, + f32 *multiplierF ) { + if ( !mPaused && mActive && + mControllerMgrTbl[ controllerIdx ] != nullptr ) { + mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, repeatCount, + multiplierF ); + } } // Size needed: 0x94, current: 0x58 -void RumbleMgr::start(int controllerIdx, int channelDataIdx, int repeatCount, - Vec* worldPos) -{ - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, - worldPos); - } +void RumbleMgr::start( int controllerIdx, int channelDataIdx, int repeatCount, + Vec *worldPos ) { + if ( !mPaused && mActive && + mControllerMgrTbl[ controllerIdx ] != nullptr ) { + mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, repeatCount, + worldPos ); + } } // Size needed: 0x7C, current: 0x74 -void RumbleMgr::start(int controllerIdx, int channelDataIdx, int repeatCount, - MtxPtr mtx) -{ - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - Vec worldPos; - worldPos.x = mtx[3][0]; - worldPos.y = mtx[3][1]; - worldPos.z = mtx[3][2]; +void RumbleMgr::start( int controllerIdx, int channelDataIdx, int repeatCount, + MtxPtr mtx ) { + if ( !mPaused && mActive && + mControllerMgrTbl[ controllerIdx ] != nullptr ) { + Vec worldPos; + worldPos.x = mtx[ 3 ][ 0 ]; + worldPos.y = mtx[ 3 ][ 1 ]; + worldPos.z = mtx[ 3 ][ 2 ]; - mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, - &worldPos); - } + mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, repeatCount, + &worldPos ); + } } // @stack -void RumbleMgr::stop() -{ - // @fake - this fixes our stack mismatch, perhaps a leftover debug print? - int stack[2]; - (void)stack; +void RumbleMgr::stop() { + // @fake - this fixes our stack mismatch, perhaps a leftover debug print? + int stack[ 2 ]; + ( void )stack; - for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { - if (mControllerMgrTbl[i] != nullptr) { - mControllerMgrTbl[i]->stop(); - } - } + for ( int i = 0; i < PAD_MAX_CONTROLLERS; i++ ) { + if ( mControllerMgrTbl[ i ] != nullptr ) { + mControllerMgrTbl[ i ]->stop(); + } + } } -void RumbleMgr::stop(int channelDataIdx) -{ - int controllerIdx = 0; +void RumbleMgr::stop( int channelDataIdx ) { + int controllerIdx = 0; - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->stop(channelDataIdx); - } + if ( !mPaused && mActive && + mControllerMgrTbl[ controllerIdx ] != nullptr ) { + mControllerMgrTbl[ controllerIdx ]->stop( channelDataIdx ); + } } // Size needed: 0x178, current: 0x50 -void RumbleMgr::stop(int controllerIdx, int channelDataIdx) -{ - if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { - mControllerMgrTbl[controllerIdx]->stop(channelDataIdx); - } +void RumbleMgr::stop( int controllerIdx, int channelDataIdx ) { + if ( !mPaused && mActive && + mControllerMgrTbl[ controllerIdx ] != nullptr ) { + mControllerMgrTbl[ controllerIdx ]->stop( channelDataIdx ); + } } // @stack -void RumbleMgr::update() -{ - // @fake - this fixes our stack mismatch, perhaps a leftover debug print? - // NOTE: same hack fixes RumbleMgr::stop() - int stack[2]; - (void)stack; +void RumbleMgr::update() { + // @fake - this fixes our stack mismatch, perhaps a leftover debug print? + // NOTE: same hack fixes RumbleMgr::stop() + int stack[ 2 ]; + ( void )stack; - f32 updateRate = 1.0f / SMSGetVSyncTimesPerSec(); + f32 updateRate = 1.0f / SMSGetVSyncTimesPerSec(); - if (mPaused || !mActive) { - return; - } + if ( mPaused || !mActive ) { + return; + } - for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { - if (mControllerMgrTbl[i] != nullptr) { - if (!mControllerMgrTbl[i]->channelMgrIsAllFree()) { - mPower = mControllerMgrTbl[i]->update(); + for ( int i = 0; i < PAD_MAX_CONTROLLERS; i++ ) { + if ( mControllerMgrTbl[ i ] != nullptr ) { + if ( !mControllerMgrTbl[ i ]->channelMgrIsAllFree() ) { + mPower = mControllerMgrTbl[ i ]->update(); - if (mTimer > 0.0f) { - mPower *= ((1.0f - mPower) * (mTimer / 0.5f) + 1.0f); - } + if ( mTimer > 0.0f ) { + mPower *= ( ( 1.0f - mPower ) * ( mTimer / 0.5f ) + 1.0f ); + } - if (mPower > 1.0f) { - mPower = 1.0f; - } else if (mPower < 0.0f) { - mPower = 0.0f; - } + if ( mPower > 1.0f ) { + mPower = 1.0f; + } else if ( mPower < 0.0f ) { + mPower = 0.0f; + } - mRumbleBaseTbl[i]->update(mPower, mStopHard); - } else { - mRumbleBaseTbl[i]->stop(); - mRumbleBaseTbl[i]->init(); - } + mRumbleBaseTbl[ i ]->update( mPower, mStopHard ); + } else { + mRumbleBaseTbl[ i ]->stop(); + mRumbleBaseTbl[ i ]->init(); + } - mControllerMgrTbl[i]->updateMotorCount(); - } - } + mControllerMgrTbl[ i ]->updateMotorCount(); + } + } - if (mTimer > 0.0f) { - mTimer -= updateRate; - } + if ( mTimer > 0.0f ) { + mTimer -= updateRate; + } } -void RumbleMgr::setActive(bool active) -{ - mActive = active; - if (!mActive) { - reset(); - } +void RumbleMgr::setActive( bool active ) { + mActive = active; + if ( !mActive ) { + reset(); + } } -void RumbleMgr::startPause() -{ - for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { - if (mRumbleBaseTbl[i] != nullptr) { - mRumbleBaseTbl[i]->stop(); - } - } +void RumbleMgr::startPause() { + for ( int i = 0; i < PAD_MAX_CONTROLLERS; i++ ) { + if ( mRumbleBaseTbl[ i ] != nullptr ) { + mRumbleBaseTbl[ i ]->stop(); + } + } - mPaused = true; + mPaused = true; } -void RumbleMgr::finishPause() -{ - mTimer = 0.5f; - mPaused = false; +void RumbleMgr::finishPause() { + mTimer = 0.5f; + mPaused = false; } // Size needed: 0x94, current: 0x94 -void RumbleMgr::changePause() -{ - if (mPaused) { - finishPause(); - } else { - startPause(); - } +void RumbleMgr::changePause() { + if ( mPaused ) { + finishPause(); + } else { + startPause(); + } } // Size needed: 0x24, current: 0x24 -void RumbleMgr::changeMode() -{ - if (mStopHard) { - mStopHard = false; - } else { - mStopHard = true; - } +void RumbleMgr::changeMode() { + if ( mStopHard ) { + mStopHard = false; + } else { + mStopHard = true; + } } \ No newline at end of file diff --git a/src/MarioUtil/RumbleType.cpp b/src/MarioUtil/RumbleType.cpp index 9c6e1737..2cd83e78 100644 --- a/src/MarioUtil/RumbleType.cpp +++ b/src/MarioUtil/RumbleType.cpp @@ -4,57 +4,55 @@ extern int channelNum; struct RumbleTypeInfo { - unsigned int unk0; - char* str; + unsigned int unk0; + char *str; }; // Enum To Str? // @BUG - channelNum (number of rumble types) is 25, // but _info is only 23 elements long. -struct RumbleTypeInfo _info[23] = { - { 0, "MARIO_HIPDROP" }, - { 1, "MARIO_DAMAGE" }, - { 2, "MARIO_LANDING" }, - { 3, "MARIO_0_1SEC_FULL" }, - { 4, "MARIO_HIP_ATTACK2" }, - { 5, "MARIO_DAMAGE2" }, - { 6, "MARIO_RUMBLE_06" }, - { 7, "MARIO_RUMBLE_07" }, - { 8, "MARIO_1SEC_SIN" }, - { 9, "MARIO_1SEC_SIN_HALF" }, - { 10, "MARIO_RUMBLE_10" }, - { 11, "MARIO_RUMBLE_11" }, - { 12, "MARIO_RUMBLE_12" }, - { 13, "MARIO_RUMBLE_13" }, - { 14, "MARIO_RUMBLE_14" }, - { 15, "MARIO_RUMBLE_15" }, - { 16, "MARIO_RUMBLE_16" }, - { 17, "MARIO_RUMBLE_17" }, - { 18, "MARIO_RUMBLE_18" }, - { 19, "MAPOBJ_APPEAR" }, - { 20, "MARIO_WEAK" }, - { 21, "MARIO_HARD" }, - { 22, "MARIO_ELECTRIC_DAMAGE" }, +struct RumbleTypeInfo _info[ 23 ] = { + { 0, "MARIO_HIPDROP" }, + { 1, "MARIO_DAMAGE" }, + { 2, "MARIO_LANDING" }, + { 3, "MARIO_0_1SEC_FULL" }, + { 4, "MARIO_HIP_ATTACK2" }, + { 5, "MARIO_DAMAGE2" }, + { 6, "MARIO_RUMBLE_06" }, + { 7, "MARIO_RUMBLE_07" }, + { 8, "MARIO_1SEC_SIN" }, + { 9, "MARIO_1SEC_SIN_HALF" }, + { 10, "MARIO_RUMBLE_10" }, + { 11, "MARIO_RUMBLE_11" }, + { 12, "MARIO_RUMBLE_12" }, + { 13, "MARIO_RUMBLE_13" }, + { 14, "MARIO_RUMBLE_14" }, + { 15, "MARIO_RUMBLE_15" }, + { 16, "MARIO_RUMBLE_16" }, + { 17, "MARIO_RUMBLE_17" }, + { 18, "MARIO_RUMBLE_18" }, + { 19, "MAPOBJ_APPEAR" }, + { 20, "MARIO_WEAK" }, + { 21, "MARIO_HARD" }, + { 22, "MARIO_ELECTRIC_DAMAGE" }, }; -const char* invalidStr = "Invalid RumbleType"; +const char *invalidStr = "Invalid RumbleType"; -int RumbleType::getIndex(char* strIn) -{ - for (int i = 0; i < channelNum; i++) { - if (!strcmp(strIn, _info[i].str)) { - return _info[i].unk0; - } - } - return -1; +int RumbleType::getIndex( char *strIn ) { + for ( int i = 0; i < channelNum; i++ ) { + if ( !strcmp( strIn, _info[ i ].str ) ) { + return _info[ i ].unk0; + } + } + return -1; } // Size needed: 0x54, current: 0x34 -const char* RumbleType::getName(int index) -{ - if (index < 0 || index >= channelNum) { - return invalidStr; - } +const char *RumbleType::getName( int index ) { + if ( index < 0 || index >= channelNum ) { + return invalidStr; + } - return _info[index].str; + return _info[ index ].str; } \ No newline at end of file From e6a039c97ecea97f1604075051b5bab6ebb067f9 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Sat, 21 Feb 2026 22:30:27 +0100 Subject: [PATCH 24/24] chore: lint again --- include/GC2D/MovieRumble.hpp | 61 +- include/MarioUtil/RumbleMgr.hpp | 189 ++++--- include/MarioUtil/RumbleType.hpp | 8 +- include/Player/MarioAccess.hpp | 2 +- src/GC2D/MovieRumble.cpp | 116 ++-- src/MarioUtil/RumbleData.cpp | 249 ++++---- src/MarioUtil/RumbleMgr.cpp | 944 ++++++++++++++++--------------- src/MarioUtil/RumbleType.cpp | 82 +-- 8 files changed, 847 insertions(+), 804 deletions(-) diff --git a/include/GC2D/MovieRumble.hpp b/include/GC2D/MovieRumble.hpp index 99853505..47b0e7cb 100644 --- a/include/GC2D/MovieRumble.hpp +++ b/include/GC2D/MovieRumble.hpp @@ -6,35 +6,36 @@ #include class TMovieRumble : public JDrama::TViewObj { - public: - TMovieRumble( const TTHPRender * ); - - virtual void perform( u32, JDrama::TGraphics * ); - - void init( const char * ); - void movement(); - void checkRumbleOn(); - void checkRumbleOff(); - void readCurInfo(); - void makeBcrName( char *, int, const char * ); - - bool isValid() const { - bool result = false; - if ( unk14 && unk18 >= 0 ) - result = true; - return result; - } - - Koga::ToolData *getToolData() const { return unk14; } - - public: - /* 0x10 */ const TTHPRender *unk10; - /* 0x14 */ Koga::ToolData *unk14; - /* 0x18 */ int unk18; - /* 0x1C */ s32 unk1C; - /* 0x20 */ s32 unk20; - /* 0x24 */ int unk24; - /* 0x28 */ bool unk28; +public: + TMovieRumble(const TTHPRender*); + + virtual void perform(u32, JDrama::TGraphics*); + + void init(const char*); + void movement(); + void checkRumbleOn(); + void checkRumbleOff(); + void readCurInfo(); + void makeBcrName(char*, int, const char*); + + bool isValid() const + { + bool result = false; + if (unk14 && unk18 >= 0) + result = true; + return result; + } + + Koga::ToolData* getToolData() const { return unk14; } + +public: + /* 0x10 */ const TTHPRender* unk10; + /* 0x14 */ Koga::ToolData* unk14; + /* 0x18 */ int unk18; + /* 0x1C */ s32 unk1C; + /* 0x20 */ s32 unk20; + /* 0x24 */ int unk24; + /* 0x28 */ bool unk28; }; -#endif \ No newline at end of file +#endif diff --git a/include/MarioUtil/RumbleMgr.hpp b/include/MarioUtil/RumbleMgr.hpp index 7d92184c..edaab773 100644 --- a/include/MarioUtil/RumbleMgr.hpp +++ b/include/MarioUtil/RumbleMgr.hpp @@ -8,116 +8,123 @@ #define RUMBLE_CHANNELS_PER_CONTROLLER 32 struct RumbleChannelDataTbl { - int *mPointData; - float *mFrameData; - float *mPowerData; + int* mPointData; + float* mFrameData; + float* mPowerData; }; extern RumbleChannelDataTbl channelDataTbl[]; class RumbleBase { - public: - RumbleBase( int chan ) - : mPower( 0.0f ), mAccumulator( 0.0f ), mChan( chan ) {} - void init(); - void stop(); - void update( f32, bool ); - - f32 mPower; - f32 mAccumulator; - int mChan; +public: + RumbleBase(int chan) + : mPower(0.0f) + , mAccumulator(0.0f) + , mChan(chan) + { + } + void init(); + void stop(); + void update(f32, bool); + + f32 mPower; + f32 mAccumulator; + int mChan; }; class RumbleChannelDataMgr { - public: - RumbleChannelDataMgr() : mChannelDataTbl( nullptr ) {} - void init(); - RumbleChannelDataTbl *getChannelDataTbl( int ); - - RumbleChannelDataTbl *mChannelDataTbl; +public: + RumbleChannelDataMgr() + : mChannelDataTbl(nullptr) + { + } + void init(); + RumbleChannelDataTbl* getChannelDataTbl(int); + + RumbleChannelDataTbl* mChannelDataTbl; }; class RumbleChannelMgr { - public: - RumbleChannelMgr(); - void init( RumbleChannelDataMgr * ); - void reset(); - void repeat(); - void start( int, int, f32 * ); - void start( int, int, Vec * ); - f32 update(); - - f32 mElapsedTime; - f32 mPower; - int mChannelDataIdx; - int mRepeatCount; - f32 *mMultiplierF; - Vec *mWorldPos; - RumbleChannelDataTbl *mChannelDataTbl; - RumbleChannelDataMgr *mChannelDataMgr; +public: + RumbleChannelMgr(); + void init(RumbleChannelDataMgr*); + void reset(); + void repeat(); + void start(int, int, f32*); + void start(int, int, Vec*); + f32 update(); + + f32 mElapsedTime; + f32 mPower; + int mChannelDataIdx; + int mRepeatCount; + f32* mMultiplierF; + Vec* mWorldPos; + RumbleChannelDataTbl* mChannelDataTbl; + RumbleChannelDataMgr* mChannelDataMgr; }; class RumbleControllerMgr { - public: - RumbleControllerMgr(); - void init(); - void reset(); - void start( int, int, f32 * ); - void start( int, int, Vec * ); - void stop(); - void stop( int ); - bool channelMgrIsAllFree(); - void updateMotorCount(); - f32 update(); - - f32 mPower; - RumbleChannelMgr *mChannelMgrTbl; - RumbleChannelDataMgr *mChannelDataMgr; - u32 mMotorCounter; - u16 mMotorTimer; - s8 unk12; +public: + RumbleControllerMgr(); + void init(); + void reset(); + void start(int, int, f32*); + void start(int, int, Vec*); + void stop(); + void stop(int); + bool channelMgrIsAllFree(); + void updateMotorCount(); + f32 update(); + + f32 mPower; + RumbleChannelMgr* mChannelMgrTbl; + RumbleChannelDataMgr* mChannelDataMgr; + u32 mMotorCounter; + u16 mMotorTimer; + s8 unk12; }; class RumbleMgr; -extern RumbleMgr *SMSRumbleMgr; +extern RumbleMgr* SMSRumbleMgr; class RumbleMgr { - public: - RumbleMgr( bool, bool, bool, bool ); - void init(); - void reset(); - void start( int, f32 * ); - void start( int, Vec * ); - void start( int, MtxPtr ); - void start( int, int, f32 * ); - void start( int, int, Vec * ); - void start( int, int, MtxPtr ); - void start( int, int, int, f32 * ); - void start( int, int, int, Vec * ); - void start( int, int, int, MtxPtr ); - void stop(); - void stop( int ); - void stop( int, int ); - void update(); - void setActive( bool ); - void startPause(); - void finishPause(); - void changePause(); - void changeMode(); - - f32 mPower; - f32 mTimer; - bool mActive; - bool mPaused; - bool mStopHard; - RumbleBase *mRumbleBaseTbl[ 4 ]; - RumbleControllerMgr *mControllerMgrTbl[ 4 ]; - RumbleChannelDataMgr *mChannelDataMgr; - - static int mMotorCountLimit; - static u16 mMotorTimerPeriod; - static f32 mPowerThreshold; +public: + RumbleMgr(bool, bool, bool, bool); + void init(); + void reset(); + void start(int, f32*); + void start(int, Vec*); + void start(int, MtxPtr); + void start(int, int, f32*); + void start(int, int, Vec*); + void start(int, int, MtxPtr); + void start(int, int, int, f32*); + void start(int, int, int, Vec*); + void start(int, int, int, MtxPtr); + void stop(); + void stop(int); + void stop(int, int); + void update(); + void setActive(bool); + void startPause(); + void finishPause(); + void changePause(); + void changeMode(); + + f32 mPower; + f32 mTimer; + bool mActive; + bool mPaused; + bool mStopHard; + RumbleBase* mRumbleBaseTbl[4]; + RumbleControllerMgr* mControllerMgrTbl[4]; + RumbleChannelDataMgr* mChannelDataMgr; + + static int mMotorCountLimit; + static u16 mMotorTimerPeriod; + static f32 mPowerThreshold; }; -#endif \ No newline at end of file +#endif diff --git a/include/MarioUtil/RumbleType.hpp b/include/MarioUtil/RumbleType.hpp index c0504ad4..766c8f5d 100644 --- a/include/MarioUtil/RumbleType.hpp +++ b/include/MarioUtil/RumbleType.hpp @@ -2,9 +2,9 @@ #define MARIO_UTIL_RUMBLE_TYPE_HPP class RumbleType { - public: - static int getIndex( char *strIn ); - static const char *getName( int index ); +public: + static int getIndex(char* strIn); + static const char* getName(int index); }; -#endif \ No newline at end of file +#endif diff --git a/include/Player/MarioAccess.hpp b/include/Player/MarioAccess.hpp index 6336ca1d..1c4847e3 100644 --- a/include/Player/MarioAccess.hpp +++ b/include/Player/MarioAccess.hpp @@ -113,4 +113,4 @@ inline const TBGCheckData* SMS_GetMarioGroundPlane() return *gpMarioGroundPlane; } -#endif \ No newline at end of file +#endif diff --git a/src/GC2D/MovieRumble.cpp b/src/GC2D/MovieRumble.cpp index d7215686..106643d6 100644 --- a/src/GC2D/MovieRumble.cpp +++ b/src/GC2D/MovieRumble.cpp @@ -7,75 +7,85 @@ #include // TODO: removeme -static const char *dummyMactorStringValue1 = "\0\0\0\0\0\0\0\0\0\0\0"; -static const char *SMS_NO_MEMORY_MESSAGE = "メモリが足りません\n"; +static const char* dummyMactorStringValue1 = "\0\0\0\0\0\0\0\0\0\0\0"; +static const char* SMS_NO_MEMORY_MESSAGE = "メモリが足りません\n"; -TMovieRumble::TMovieRumble( const TTHPRender *param_1 ) : unk10( param_1 ) {} +TMovieRumble::TMovieRumble(const TTHPRender* param_1) + : unk10(param_1) +{ +} -void TMovieRumble::init( const char *param_1 ) { - char acStack_90[ 128 ]; - makeBcrName( acStack_90, 128, param_1 ); +void TMovieRumble::init(const char* param_1) +{ + char acStack_90[128]; + makeBcrName(acStack_90, 128, param_1); - unk14 = new Koga::ToolData; - void *bcr = JKRGetResource( acStack_90 ); - unk14->Attach( bcr ); - if ( !unk14->dataExists() ) - unk18 = -1; - else - unk18 = 0; + unk14 = new Koga::ToolData; + void* bcr = JKRGetResource(acStack_90); + unk14->Attach(bcr); + if (!unk14->dataExists()) + unk18 = -1; + else + unk18 = 0; - readCurInfo(); - unk28 = false; + readCurInfo(); + unk28 = false; } -void TMovieRumble::perform( u32 param_1, JDrama::TGraphics * ) { - if ( param_1 & 0x1 ) - movement(); +void TMovieRumble::perform(u32 param_1, JDrama::TGraphics*) +{ + if (param_1 & 0x1) + movement(); } -void TMovieRumble::movement() { - if ( unk28 ) { - checkRumbleOff(); - } else { - checkRumbleOn(); - } +void TMovieRumble::movement() +{ + if (unk28) { + checkRumbleOff(); + } else { + checkRumbleOn(); + } } -void TMovieRumble::checkRumbleOn() { - if ( unk24 != -1 && unk1C <= unk10->getFrameNumber() ) { - SMSRumbleMgr->start( unk24, -1, ( f32 * )nullptr ); - unk28 = true; - } +void TMovieRumble::checkRumbleOn() +{ + if (unk24 != -1 && unk1C <= unk10->getFrameNumber()) { + SMSRumbleMgr->start(unk24, -1, (f32*)nullptr); + unk28 = true; + } } #pragma dont_inline on -void TMovieRumble::checkRumbleOff() { - if ( unk24 != -1 && unk20 <= unk10->getFrameNumber() ) { - SMSRumbleMgr->stop(); - unk18 += 1; - readCurInfo(); - unk28 = false; - } +void TMovieRumble::checkRumbleOff() +{ + if (unk24 != -1 && unk20 <= unk10->getFrameNumber()) { + SMSRumbleMgr->stop(); + unk18 += 1; + readCurInfo(); + unk28 = false; + } } #pragma dont_inline off -void TMovieRumble::readCurInfo() { - int group = unk18; +void TMovieRumble::readCurInfo() +{ + int group = unk18; - if ( isValid() && unk14->isIndexValid( group ) ) { - Koga::ToolData *toolData = unk14; - toolData->GetValue( group, "start_frame", unk1C ); - toolData->GetValue( group, "end_frame", unk20 ); - const char *type; - toolData->GetValue( group, "type", type ); - unk24 = RumbleType::getIndex( ( char * )type ); - } else { - unk24 = -1; - } + if (isValid() && unk14->isIndexValid(group)) { + Koga::ToolData* toolData = unk14; + toolData->GetValue(group, "start_frame", unk1C); + toolData->GetValue(group, "end_frame", unk20); + const char* type; + toolData->GetValue(group, "type", type); + unk24 = RumbleType::getIndex((char*)type); + } else { + unk24 = -1; + } } -void TMovieRumble::makeBcrName( char *acStack_90, int, const char *param_1 ) { - sprintf( acStack_90, "/subtitle/rnbl/%s", param_1 ); - char *it = strrchr( acStack_90, '.' ); - strcpy( it, ".bcr" ); -} \ No newline at end of file +void TMovieRumble::makeBcrName(char* acStack_90, int, const char* param_1) +{ + sprintf(acStack_90, "/subtitle/rnbl/%s", param_1); + char* it = strrchr(acStack_90, '.'); + strcpy(it, ".bcr"); +} diff --git a/src/MarioUtil/RumbleData.cpp b/src/MarioUtil/RumbleData.cpp index 6f342338..8a9466db 100644 --- a/src/MarioUtil/RumbleData.cpp +++ b/src/MarioUtil/RumbleData.cpp @@ -3,226 +3,227 @@ static int rumblePoint_00 = 0x0000000B; -static float rumbleFrame_00[ 11 ] = { 0.0f, 0.05f, 0.1f, 0.15f, 0.2f, 0.25f, - 0.25f, 0.33f, 0.4f, 0.5f, 0.6f }; +static float rumbleFrame_00[11] + = { 0.0f, 0.05f, 0.1f, 0.15f, 0.2f, 0.25f, 0.25f, 0.33f, 0.4f, 0.5f, 0.6f }; -static float rumblePower_00[ 11 ] = { 1.0f, 1.0f, 1.0f, 0.9f, 0.0f, 0.0f, - 0.6f, 0.6f, 0.5f, 0.2f, 0.0f }; +static float rumblePower_00[11] + = { 1.0f, 1.0f, 1.0f, 0.9f, 0.0f, 0.0f, 0.6f, 0.6f, 0.5f, 0.2f, 0.0f }; static int rumblePoint_01 = 0x00000018; -static float rumbleFrame_01[ 24 ] = { - 0.0f, 0.16f, 0.19f, 0.24f, 0.26f, 0.37f, 0.4f, 0.45f, - 0.46f, 0.54f, 0.56f, 0.61f, 0.62f, 0.7f, 0.73f, 0.78f, - 0.79f, 0.86f, 0.92f, 0.96f, 1.03f, 1.13f, 1.17f, 1.4f, +static float rumbleFrame_01[24] = { + 0.0f, 0.16f, 0.19f, 0.24f, 0.26f, 0.37f, 0.4f, 0.45f, + 0.46f, 0.54f, 0.56f, 0.61f, 0.62f, 0.7f, 0.73f, 0.78f, + 0.79f, 0.86f, 0.92f, 0.96f, 1.03f, 1.13f, 1.17f, 1.4f, }; -static float rumblePower_01[ 24 ] = { - 1.0f, 1.0f, 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, 0.0f, - 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, 0.53f, 0.0f, 0.0f, - 0.44f, 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f, +static float rumblePower_01[24] = { + 1.0f, 1.0f, 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, 0.0f, + 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, 0.53f, 0.0f, 0.0f, + 0.44f, 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f, }; static int rumblePoint_02 = 0x00000002; -static float rumbleFrame_02[ 2 ] = { 0.0f, 0.1f }; +static float rumbleFrame_02[2] = { 0.0f, 0.1f }; -static float rumblePower_02[ 2 ] = { 0.8f, 0.6f }; +static float rumblePower_02[2] = { 0.8f, 0.6f }; static int rumblePoint_03 = 0x00000002; -static float rumbleFrame_03[ 2 ] = { 0.0f, 0.1f }; +static float rumbleFrame_03[2] = { 0.0f, 0.1f }; -static float rumblePower_03[ 2 ] = { 1.0f, 1.0f }; +static float rumblePower_03[2] = { 1.0f, 1.0f }; static int rumblePoint_04 = 0x00000007; -static float rumbleFrame_04[ 7 ] = { 0.0f, 0.1f, 0.15f, 0.2f, - 0.25f, 0.3f, 0.5f }; +static float rumbleFrame_04[7] = { 0.0f, 0.1f, 0.15f, 0.2f, 0.25f, 0.3f, 0.5f }; -static float rumblePower_04[ 7 ] = { 1.0f, 1.0f, 0.0f, 0.8f, 0.8f, 0.0f, 0.0f }; +static float rumblePower_04[7] = { 1.0f, 1.0f, 0.0f, 0.8f, 0.8f, 0.0f, 0.0f }; static int rumblePoint_05 = 0x00000015; -static float rumbleFrame_05[ 21 ] = { - 0.0f, 0.18f, 0.21f, 0.28f, 0.28f, 0.4f, 0.45f, 0.51f, 0.52f, 0.64f, 0.69f, - 0.75f, 0.83f, 0.89f, 0.99f, 1.03f, 1.12f, 1.19f, 1.25f, 1.3f, 1.4f }; +static float rumbleFrame_05[21] + = { 0.0f, 0.18f, 0.21f, 0.28f, 0.28f, 0.4f, 0.45f, + 0.51f, 0.52f, 0.64f, 0.69f, 0.75f, 0.83f, 0.89f, + 0.99f, 1.03f, 1.12f, 1.19f, 1.25f, 1.3f, 1.4f }; -static float rumblePower_05[ 21 ] = { - 1.0f, 0.92f, 0.0f, 0.0f, 0.79f, 0.63f, 0.0f, 0.02f, 0.45f, 0.31f, 0.02f, - 0.24f, 0.03f, 0.18f, 0.04f, 0.13f, 0.04f, 0.1f, 0.04f, 0.06f, 0.0f }; +static float rumblePower_05[21] + = { 1.0f, 0.92f, 0.0f, 0.0f, 0.79f, 0.63f, 0.0f, + 0.02f, 0.45f, 0.31f, 0.02f, 0.24f, 0.03f, 0.18f, + 0.04f, 0.13f, 0.04f, 0.1f, 0.04f, 0.06f, 0.0f }; static int rumblePoint_06 = 0x0000000A; -static float rumbleFrame_06[ 10 ] = { 0.0f, 0.09f, 0.09f, 0.1f, 0.17f, - 0.17f, 0.18f, 0.26f, 0.26f, 0.5f }; +static float rumbleFrame_06[10] + = { 0.0f, 0.09f, 0.09f, 0.1f, 0.17f, 0.17f, 0.18f, 0.26f, 0.26f, 0.5f }; -static float rumblePower_06[ 10 ] = { 0.85f, 0.85f, 0.1f, 0.45f, 0.45f, - 0.05f, 0.25f, 0.25f, 0.01f, 0.0f }; +static float rumblePower_06[10] + = { 0.85f, 0.85f, 0.1f, 0.45f, 0.45f, 0.05f, 0.25f, 0.25f, 0.01f, 0.0f }; static int rumblePoint_07 = 0x00000014; -static float rumbleFrame_07[ 20 ] = { - 0.0f, 0.11f, 0.12f, 0.13f, 0.2f, 0.21f, 0.29f, 0.31f, 0.33f, 0.41f, - 0.42f, 0.52f, 0.53f, 0.54f, 0.62f, 0.64f, 0.72f, 0.74f, 0.75f, 1.0f }; +static float rumbleFrame_07[20] + = { 0.0f, 0.11f, 0.12f, 0.13f, 0.2f, 0.21f, 0.29f, 0.31f, 0.33f, 0.41f, + 0.42f, 0.52f, 0.53f, 0.54f, 0.62f, 0.64f, 0.72f, 0.74f, 0.75f, 1.0f }; -static float rumblePower_07[ 20 ] = { - 0.95f, 0.97f, 0.85f, 0.0f, 0.0f, 0.75f, 0.73f, 0.55f, 0.0f, 0.0f, - 0.6f, 0.63f, 0.32f, 0.0f, 0.0f, 0.51f, 0.48f, 0.19f, 0.02f, 0.0f }; +static float rumblePower_07[20] + = { 0.95f, 0.97f, 0.85f, 0.0f, 0.0f, 0.75f, 0.73f, 0.55f, 0.0f, 0.0f, + 0.6f, 0.63f, 0.32f, 0.0f, 0.0f, 0.51f, 0.48f, 0.19f, 0.02f, 0.0f }; static int rumblePoint_08 = 0x00000004; -static float rumbleFrame_08[ 5 ] = { 0.0f, 0.3f, 0.5f, 0.7f, 1.0f }; +static float rumbleFrame_08[5] = { 0.0f, 0.3f, 0.5f, 0.7f, 1.0f }; -static float rumblePower_08[ 5 ] = { 1.0f, 0.5f, 0.35f, 0.5f, 1.0f }; +static float rumblePower_08[5] = { 1.0f, 0.5f, 0.35f, 0.5f, 1.0f }; static int rumblePoint_09 = 0x00000004; -static float rumbleFrame_09[ 4 ] = { 0.0f, 0.3f, 0.5f, 0.7f }; +static float rumbleFrame_09[4] = { 0.0f, 0.3f, 0.5f, 0.7f }; -static float rumblePower_09[ 4 ] = { 0.5f, 0.24f, 0.18f, 0.23f }; +static float rumblePower_09[4] = { 0.5f, 0.24f, 0.18f, 0.23f }; static int rumblePoint_10 = 0x00000001; -static float rumbleFrame_10[ 1 ] = { 0.0f }; +static float rumbleFrame_10[1] = { 0.0f }; -static float rumblePower_10[ 1 ] = { 0.0f }; +static float rumblePower_10[1] = { 0.0f }; static int rumblePoint_11 = 0x00000001; -static float rumbleFrame_11[ 1 ] = { 0.0f }; +static float rumbleFrame_11[1] = { 0.0f }; -static float rumblePower_11[ 1 ] = { 0.0f }; +static float rumblePower_11[1] = { 0.0f }; static int rumblePoint_12 = 0x00000001; -static float rumbleFrame_12[ 1 ] = { 0.0f }; +static float rumbleFrame_12[1] = { 0.0f }; -static float rumblePower_12[ 1 ] = { 0.0f }; +static float rumblePower_12[1] = { 0.0f }; static int rumblePoint_13 = 0x00000001; -static float rumbleFrame_13[ 1 ] = { 0.0f }; +static float rumbleFrame_13[1] = { 0.0f }; -static float rumblePower_13[ 1 ] = { 0.0f }; +static float rumblePower_13[1] = { 0.0f }; static int rumblePoint_14 = 0x00000001; -static float rumbleFrame_14[ 1 ] = { 0.0f }; +static float rumbleFrame_14[1] = { 0.0f }; -static float rumblePower_14[ 1 ] = { 0.0f }; +static float rumblePower_14[1] = { 0.0f }; static int rumblePoint_15 = 0x00000001; -static float rumbleFrame_15[ 1 ] = { 0.0f }; +static float rumbleFrame_15[1] = { 0.0f }; -static float rumblePower_15[ 1 ] = { 0.0f }; +static float rumblePower_15[1] = { 0.0f }; static int rumblePoint_16 = 0x00000001; -static float rumbleFrame_16[ 1 ] = { 0.0f }; +static float rumbleFrame_16[1] = { 0.0f }; -static float rumblePower_16[ 1 ] = { 0.0f }; +static float rumblePower_16[1] = { 0.0f }; static int rumblePoint_17 = 0x00000001; -static float rumbleFrame_17[ 1 ] = { 0.0f }; +static float rumbleFrame_17[1] = { 0.0f }; -static float rumblePower_17[ 1 ] = { 0.0f }; +static float rumblePower_17[1] = { 0.0f }; static int rumblePoint_18 = 0x00000001; -static float rumbleFrame_18[ 1 ] = { 0.0f }; +static float rumbleFrame_18[1] = { 0.0f }; -static float rumblePower_18[ 1 ] = { 0.0f }; +static float rumblePower_18[1] = { 0.0f }; static int rumblePoint_19 = 0x00000005; -static float rumbleFrame_19[ 5 ] = { 0.0f, 0.11f, 0.2f, 0.32f, 0.4f }; +static float rumbleFrame_19[5] = { 0.0f, 0.11f, 0.2f, 0.32f, 0.4f }; -static float rumblePower_19[ 5 ] = { 0.6f, 0.4f, 0.6f, 0.4f, 0.6f }; +static float rumblePower_19[5] = { 0.6f, 0.4f, 0.6f, 0.4f, 0.6f }; static int rumblePoint_20 = 0x00000002; -static float rumbleFrame_20[ 2 ] = { 0.0f, 1.0f / 60.0f }; +static float rumbleFrame_20[2] = { 0.0f, 1.0f / 60.0f }; -static float rumblePower_20[ 2 ] = { 0.5f, 0.5f }; +static float rumblePower_20[2] = { 0.5f, 0.5f }; static int rumblePoint_21 = 0x00000002; -static float rumbleFrame_21[ 2 ] = { 0.0f, 1.0f / 60.0f }; +static float rumbleFrame_21[2] = { 0.0f, 1.0f / 60.0f }; -static float rumblePower_21[ 2 ] = { 0.75f, 0.75f }; +static float rumblePower_21[2] = { 0.75f, 0.75f }; static int rumblePoint_22 = 0x00000002; -static float rumbleFrame_22[ 2 ] = { 0.0f, 2.0f }; +static float rumbleFrame_22[2] = { 0.0f, 2.0f }; -static float rumblePower_22[ 2 ] = { 0.75f, 0.75f }; +static float rumblePower_22[2] = { 0.75f, 0.75f }; static int rumblePoint_23 = 0x0000004D; -static float rumbleFrame_23[ 77 ] = { - 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, - 1.2f, 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, - 4.16f, 4.17f, 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, - 5.18f, 5.28f, 5.32f, 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, - 5.68f, 6.35f, 6.36f, 6.57f, 6.68f, 6.85f, 6.88f, 7.11f, 7.18f, - 7.5f, 7.66f, 8.09f, 8.67f, 9.08f, 9.1f, 9.63f, 9.64f, 9.65f, - 9.81f, 9.84f, 9.89f, 9.91f, 10.02f, 10.04f, 10.05f, 10.06f, 10.19f, - 10.21f, 10.22f, 10.23f, 10.35f, 10.38f, 10.43f, 10.45f, 10.51f, 10.57f, - 10.61f, 10.68f, 10.78f, 10.82f, 11.0f }; - -static float rumblePower_23[ 77 ] = { - 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, - 0.72f, 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, - 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, - 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f, 0.0f, 0.78f, 0.71f, - 0.0f, 0.0f, 0.78f, 0.68f, 0.0f, 0.0f, 0.42f, 0.72f, 0.87f, 1.0f, - 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, - 0.0f, 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, 0.53f, 0.0f, 0.0f, 0.44f, - 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f }; +static float rumbleFrame_23[77] + = { 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, + 1.2f, 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, + 4.16f, 4.17f, 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, + 5.18f, 5.28f, 5.32f, 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, + 5.68f, 6.35f, 6.36f, 6.57f, 6.68f, 6.85f, 6.88f, 7.11f, 7.18f, + 7.5f, 7.66f, 8.09f, 8.67f, 9.08f, 9.1f, 9.63f, 9.64f, 9.65f, + 9.81f, 9.84f, 9.89f, 9.91f, 10.02f, 10.04f, 10.05f, 10.06f, 10.19f, + 10.21f, 10.22f, 10.23f, 10.35f, 10.38f, 10.43f, 10.45f, 10.51f, 10.57f, + 10.61f, 10.68f, 10.78f, 10.82f, 11.0f }; + +static float rumblePower_23[77] + = { 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, + 0.72f, 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, + 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, + 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f, 0.0f, 0.78f, 0.71f, + 0.0f, 0.0f, 0.78f, 0.68f, 0.0f, 0.0f, 0.42f, 0.72f, 0.87f, 1.0f, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.95f, 0.85f, 0.0f, + 0.0f, 0.8f, 0.73f, 0.0f, 0.0f, 0.64f, 0.53f, 0.0f, 0.0f, 0.44f, + 0.35f, 0.0f, 0.27f, 0.02f, 0.16f, 0.01f, 0.0f }; static int rumblePoint_24 = 0x00000025; -static float rumbleFrame_24[ 37 ] = { - 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, 1.2f, - 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, 4.16f, 4.17f, - 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, 5.18f, 5.28f, 5.32f, - 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, 5.68f }; - -static float rumblePower_24[ 37 ] = { - 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, - 0.72f, 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, - 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, - 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f }; - -RumbleChannelDataTbl channelDataTbl[ 25 ] = { - { &rumblePoint_00, rumbleFrame_00, rumblePower_00 }, - { &rumblePoint_01, rumbleFrame_01, rumblePower_01 }, - { &rumblePoint_02, rumbleFrame_02, rumblePower_02 }, - { &rumblePoint_03, rumbleFrame_03, rumblePower_03 }, - { &rumblePoint_04, rumbleFrame_04, rumblePower_04 }, - { &rumblePoint_05, rumbleFrame_05, rumblePower_05 }, - { &rumblePoint_06, rumbleFrame_06, rumblePower_06 }, - { &rumblePoint_07, rumbleFrame_07, rumblePower_07 }, - { &rumblePoint_08, rumbleFrame_08, rumblePower_08 }, - { &rumblePoint_09, rumbleFrame_09, rumblePower_09 }, - { &rumblePoint_10, rumbleFrame_10, rumblePower_10 }, - { &rumblePoint_11, rumbleFrame_11, rumblePower_11 }, - { &rumblePoint_12, rumbleFrame_12, rumblePower_12 }, - { &rumblePoint_13, rumbleFrame_13, rumblePower_13 }, - { &rumblePoint_14, rumbleFrame_14, rumblePower_14 }, - { &rumblePoint_15, rumbleFrame_15, rumblePower_15 }, - { &rumblePoint_16, rumbleFrame_16, rumblePower_16 }, - { &rumblePoint_17, rumbleFrame_17, rumblePower_17 }, - { &rumblePoint_18, rumbleFrame_18, rumblePower_18 }, - { &rumblePoint_19, rumbleFrame_19, rumblePower_19 }, - { &rumblePoint_20, rumbleFrame_20, rumblePower_20 }, - { &rumblePoint_21, rumbleFrame_21, rumblePower_21 }, - { &rumblePoint_22, rumbleFrame_22, rumblePower_22 }, - { &rumblePoint_23, rumbleFrame_23, rumblePower_23 }, - { &rumblePoint_24, rumbleFrame_24, rumblePower_24 }, +static float rumbleFrame_24[37] + = { 0.0f, 0.07f, 0.13f, 0.25f, 0.26f, 1.02f, 1.03f, 1.14f, 1.14f, 1.2f, + 1.21f, 1.29f, 1.33f, 3.75f, 3.81f, 3.92f, 3.94f, 4.0f, 4.16f, 4.17f, + 4.36f, 4.4f, 4.44f, 4.44f, 4.58f, 4.69f, 5.16f, 5.18f, 5.28f, 5.32f, + 5.4f, 5.41f, 5.52f, 5.56f, 5.58f, 5.66f, 5.68f }; + +static float rumblePower_24[37] + = { 0.8f, 1.0f, 0.95f, 0.8f, 0.0f, 0.0f, 0.95f, 0.95f, 0.41f, 0.44f, + 0.72f, 0.58f, 0.0f, 0.0f, 0.81f, 0.9f, 0.69f, 0.0f, 0.0f, 0.98f, + 0.95f, 0.53f, 0.5f, 0.87f, 0.7f, 0.0f, 0.0f, 0.87f, 0.84f, 0.32f, + 0.27f, 0.69f, 0.55f, 0.0f, 0.34f, 0.27f, 0.0f }; + +RumbleChannelDataTbl channelDataTbl[25] = { + { &rumblePoint_00, rumbleFrame_00, rumblePower_00 }, + { &rumblePoint_01, rumbleFrame_01, rumblePower_01 }, + { &rumblePoint_02, rumbleFrame_02, rumblePower_02 }, + { &rumblePoint_03, rumbleFrame_03, rumblePower_03 }, + { &rumblePoint_04, rumbleFrame_04, rumblePower_04 }, + { &rumblePoint_05, rumbleFrame_05, rumblePower_05 }, + { &rumblePoint_06, rumbleFrame_06, rumblePower_06 }, + { &rumblePoint_07, rumbleFrame_07, rumblePower_07 }, + { &rumblePoint_08, rumbleFrame_08, rumblePower_08 }, + { &rumblePoint_09, rumbleFrame_09, rumblePower_09 }, + { &rumblePoint_10, rumbleFrame_10, rumblePower_10 }, + { &rumblePoint_11, rumbleFrame_11, rumblePower_11 }, + { &rumblePoint_12, rumbleFrame_12, rumblePower_12 }, + { &rumblePoint_13, rumbleFrame_13, rumblePower_13 }, + { &rumblePoint_14, rumbleFrame_14, rumblePower_14 }, + { &rumblePoint_15, rumbleFrame_15, rumblePower_15 }, + { &rumblePoint_16, rumbleFrame_16, rumblePower_16 }, + { &rumblePoint_17, rumbleFrame_17, rumblePower_17 }, + { &rumblePoint_18, rumbleFrame_18, rumblePower_18 }, + { &rumblePoint_19, rumbleFrame_19, rumblePower_19 }, + { &rumblePoint_20, rumbleFrame_20, rumblePower_20 }, + { &rumblePoint_21, rumbleFrame_21, rumblePower_21 }, + { &rumblePoint_22, rumbleFrame_22, rumblePower_22 }, + { &rumblePoint_23, rumbleFrame_23, rumblePower_23 }, + { &rumblePoint_24, rumbleFrame_24, rumblePower_24 }, }; -int channelNum = ARRAY_COUNT( channelDataTbl ); \ No newline at end of file +int channelNum = ARRAY_COUNT(channelDataTbl); diff --git a/src/MarioUtil/RumbleMgr.cpp b/src/MarioUtil/RumbleMgr.cpp index f17494fe..824368d5 100644 --- a/src/MarioUtil/RumbleMgr.cpp +++ b/src/MarioUtil/RumbleMgr.cpp @@ -3,592 +3,614 @@ #include #include -int RumbleMgr::mMotorCountLimit = 900; +int RumbleMgr::mMotorCountLimit = 900; u16 RumbleMgr::mMotorTimerPeriod = 80; -f32 RumbleMgr::mPowerThreshold = 0.5f; +f32 RumbleMgr::mPowerThreshold = 0.5f; -RumbleMgr *SMSRumbleMgr = nullptr; +RumbleMgr* SMSRumbleMgr = nullptr; // Size needed: 0x10, current: 0x10 -void RumbleBase::init() { - mPower = 0.0f; - mAccumulator = 0.0f; +void RumbleBase::init() +{ + mPower = 0.0f; + mAccumulator = 0.0f; } // Size needed: 0x28, current: 0x28 -void RumbleBase::stop() { PADControlMotor( mChan, PAD_MOTOR_STOP_HARD ); } +void RumbleBase::stop() { PADControlMotor(mChan, PAD_MOTOR_STOP_HARD); } // Size needed: 0xAC, current: 0xA0 -void RumbleBase::update( f32 power, bool stopHard ) { - // This function is the likely cause for stack mismatch in - // RumbleMgr::update() as it's the only one whose size mismatches. - mPower = power; - mAccumulator += mPower; - - if ( mPower <= 0.0f ) { - PADControlMotor( mChan, PAD_MOTOR_STOP_HARD ); - } else if ( mAccumulator < 1.0f ) { - if ( stopHard ) { - PADControlMotor( mChan, PAD_MOTOR_STOP_HARD ); - } else { - PADControlMotor( mChan, PAD_MOTOR_STOP ); - } - } else { - // @fake - this doesn't fix our function size but it does match stack in - // RumbleMgr::update() - // f32 accumulator = mAccumulator; - // mAccumulator = accumulator - 1.0f; - mAccumulator -= 1.0f; - PADControlMotor( mChan, PAD_MOTOR_RUMBLE ); - } +void RumbleBase::update(f32 power, bool stopHard) +{ + // This function is the likely cause for stack mismatch in + // RumbleMgr::update() as it's the only one whose size mismatches. + mPower = power; + mAccumulator += mPower; + + if (mPower <= 0.0f) { + PADControlMotor(mChan, PAD_MOTOR_STOP_HARD); + } else if (mAccumulator < 1.0f) { + if (stopHard) { + PADControlMotor(mChan, PAD_MOTOR_STOP_HARD); + } else { + PADControlMotor(mChan, PAD_MOTOR_STOP); + } + } else { + // @fake - this doesn't fix our function size but it does match stack in + // RumbleMgr::update() + // f32 accumulator = mAccumulator; + // mAccumulator = accumulator - 1.0f; + mAccumulator -= 1.0f; + PADControlMotor(mChan, PAD_MOTOR_RUMBLE); + } } // Size needed: 0x10, current: 0x10 void RumbleChannelDataMgr::init() { mChannelDataTbl = channelDataTbl; } // Size needed: 0x14, current: 0x14 -RumbleChannelDataTbl *RumbleChannelDataMgr::getChannelDataTbl( int index ) { - // This feels wrong, but I only see direct loads from channelDataTbl. - // Also, it only matches size when doing this. - return &channelDataTbl[ index ]; +RumbleChannelDataTbl* RumbleChannelDataMgr::getChannelDataTbl(int index) +{ + // This feels wrong, but I only see direct loads from channelDataTbl. + // Also, it only matches size when doing this. + return &channelDataTbl[index]; } -RumbleChannelMgr::RumbleChannelMgr() { - mElapsedTime = 0.0f; - mPower = 0.0f; - mChannelDataIdx = -1; - mRepeatCount = 0; - mMultiplierF = nullptr; - mWorldPos = nullptr; - mChannelDataTbl = nullptr; +RumbleChannelMgr::RumbleChannelMgr() +{ + mElapsedTime = 0.0f; + mPower = 0.0f; + mChannelDataIdx = -1; + mRepeatCount = 0; + mMultiplierF = nullptr; + mWorldPos = nullptr; + mChannelDataTbl = nullptr; } // Size needed: 0x30, current: 0x2C -void RumbleChannelMgr::init( RumbleChannelDataMgr *dataMgr ) { - mElapsedTime = 0.0f; - mPower = 0.0f; - mChannelDataIdx = -1; - mRepeatCount = 0; - mMultiplierF = nullptr; - mWorldPos = nullptr; - mChannelDataTbl = nullptr; - mChannelDataMgr = dataMgr; +void RumbleChannelMgr::init(RumbleChannelDataMgr* dataMgr) +{ + mElapsedTime = 0.0f; + mPower = 0.0f; + mChannelDataIdx = -1; + mRepeatCount = 0; + mMultiplierF = nullptr; + mWorldPos = nullptr; + mChannelDataTbl = nullptr; + mChannelDataMgr = dataMgr; } // Size needed: 0x2C, current: 0x2C -void RumbleChannelMgr::reset() { - mElapsedTime = 0.0f; - mPower = 0.0f; - mChannelDataIdx = -1; - mRepeatCount = 0; - mMultiplierF = nullptr; - mWorldPos = nullptr; - mChannelDataTbl = nullptr; +void RumbleChannelMgr::reset() +{ + mElapsedTime = 0.0f; + mPower = 0.0f; + mChannelDataIdx = -1; + mRepeatCount = 0; + mMultiplierF = nullptr; + mWorldPos = nullptr; + mChannelDataTbl = nullptr; } // Size needed: 0x0C, current: 0x0C void RumbleChannelMgr::repeat() { mElapsedTime = 0.0f; } // Size needed: 0x2C, current: 0x2C -void RumbleChannelMgr::start( int channelDataIdx, int repeatCount, - f32 *multiplierF ) { - mElapsedTime = 0.0f; - mChannelDataTbl = mChannelDataMgr->getChannelDataTbl( channelDataIdx ); - mChannelDataIdx = channelDataIdx; - mRepeatCount = repeatCount; - mMultiplierF = multiplierF; +void RumbleChannelMgr::start(int channelDataIdx, int repeatCount, + f32* multiplierF) +{ + mElapsedTime = 0.0f; + mChannelDataTbl = mChannelDataMgr->getChannelDataTbl(channelDataIdx); + mChannelDataIdx = channelDataIdx; + mRepeatCount = repeatCount; + mMultiplierF = multiplierF; } // Size needed: 0x2C, current: 0x2C -void RumbleChannelMgr::start( int channelDataIdx, int repeatCount, - Vec *worldPos ) { - mElapsedTime = 0.0f; - mChannelDataTbl = mChannelDataMgr->getChannelDataTbl( channelDataIdx ); - mChannelDataIdx = channelDataIdx; - mRepeatCount = repeatCount; - mWorldPos = worldPos; -} - -f32 RumbleChannelMgr::update() { - f32 updateRate = 1.0f / SMSGetVSyncTimesPerSec(); - f32 mult; - - if ( mMultiplierF != nullptr ) { - mult = *mMultiplierF; - if ( mult < 0.0f ) { - mult = 0.0f; - } else if ( mult > 1.0f ) { - mult = 1.0f; - } - } else if ( mWorldPos != nullptr ) { - JGeometry::TVec3< f32 > &v = - *static_cast< JGeometry::TVec3< f32 > * >( mWorldPos ); - f32 dist = SMS_DistanceFromMario( v ); - mult = -( ( dist - 300.0f ) * ( 1.0f / 3000.0f ) - 1.0f ); - if ( mult < 0.0f ) { - mult = 0.0f; - } else if ( mult > 1.0f ) { - mult = 1.0f; - } - } else { - mult = 1.0f; - } - - mPower = 0.0f; - if ( mRepeatCount == 0 ) { - reset(); - } - - if ( mChannelDataTbl != nullptr ) { - mElapsedTime += updateRate; - - for ( int i = 0; i < *mChannelDataTbl->mPointData - 1; i++ ) { - if ( mElapsedTime > mChannelDataTbl->mFrameData[ i ] ) { - f32 delta = mChannelDataTbl->mFrameData[ i + 1 ] - - mChannelDataTbl->mFrameData[ i ]; - f32 frameDelta = - mElapsedTime - mChannelDataTbl->mFrameData[ i ]; - f32 progress; - - if ( delta > 0.0f ) { - progress = frameDelta / delta; - } else { - progress = 1.0f; - } - - mPower = - ( 1.0f - progress ) * mChannelDataTbl->mPowerData[ i ] + - progress * mChannelDataTbl->mPowerData[ i + 1 ]; - } - } - - if ( mElapsedTime > - mChannelDataTbl->mFrameData[ *mChannelDataTbl->mPointData - 1 ] ) { - if ( mRepeatCount > 1 ) { - repeat(); - mRepeatCount--; - } else if ( mRepeatCount < 0 ) { - repeat(); - } else { - reset(); - } - } - } - - mPower *= mult; - return mPower; +void RumbleChannelMgr::start(int channelDataIdx, int repeatCount, Vec* worldPos) +{ + mElapsedTime = 0.0f; + mChannelDataTbl = mChannelDataMgr->getChannelDataTbl(channelDataIdx); + mChannelDataIdx = channelDataIdx; + mRepeatCount = repeatCount; + mWorldPos = worldPos; +} + +f32 RumbleChannelMgr::update() +{ + f32 updateRate = 1.0f / SMSGetVSyncTimesPerSec(); + f32 mult; + + if (mMultiplierF != nullptr) { + mult = *mMultiplierF; + if (mult < 0.0f) { + mult = 0.0f; + } else if (mult > 1.0f) { + mult = 1.0f; + } + } else if (mWorldPos != nullptr) { + JGeometry::TVec3& v + = *static_cast*>(mWorldPos); + f32 dist = SMS_DistanceFromMario(v); + mult = -((dist - 300.0f) * (1.0f / 3000.0f) - 1.0f); + if (mult < 0.0f) { + mult = 0.0f; + } else if (mult > 1.0f) { + mult = 1.0f; + } + } else { + mult = 1.0f; + } + + mPower = 0.0f; + if (mRepeatCount == 0) { + reset(); + } + + if (mChannelDataTbl != nullptr) { + mElapsedTime += updateRate; + + for (int i = 0; i < *mChannelDataTbl->mPointData - 1; i++) { + if (mElapsedTime > mChannelDataTbl->mFrameData[i]) { + f32 delta = mChannelDataTbl->mFrameData[i + 1] + - mChannelDataTbl->mFrameData[i]; + f32 frameDelta = mElapsedTime - mChannelDataTbl->mFrameData[i]; + f32 progress; + + if (delta > 0.0f) { + progress = frameDelta / delta; + } else { + progress = 1.0f; + } + + mPower = (1.0f - progress) * mChannelDataTbl->mPowerData[i] + + progress * mChannelDataTbl->mPowerData[i + 1]; + } + } + + if (mElapsedTime + > mChannelDataTbl->mFrameData[*mChannelDataTbl->mPointData - 1]) { + if (mRepeatCount > 1) { + repeat(); + mRepeatCount--; + } else if (mRepeatCount < 0) { + repeat(); + } else { + reset(); + } + } + } + + mPower *= mult; + return mPower; } // Size needed: 0x58, current: 0x58 -RumbleControllerMgr::RumbleControllerMgr() { - mPower = 0.0f; - mChannelMgrTbl = new RumbleChannelMgr[ RUMBLE_CHANNELS_PER_CONTROLLER ]; +RumbleControllerMgr::RumbleControllerMgr() +{ + mPower = 0.0f; + mChannelMgrTbl = new RumbleChannelMgr[RUMBLE_CHANNELS_PER_CONTROLLER]; } // Size needed: 0x1C4, current: 0x19C -void RumbleControllerMgr::init() { - mPower = 0.0f; +void RumbleControllerMgr::init() +{ + mPower = 0.0f; - for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { - mChannelMgrTbl[ i ].init( mChannelDataMgr ); - } + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + mChannelMgrTbl[i].init(mChannelDataMgr); + } } -void RumbleControllerMgr::reset() { - mPower = 0.0f; +void RumbleControllerMgr::reset() +{ + mPower = 0.0f; - for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { - mChannelMgrTbl[ i ].reset(); - } + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + mChannelMgrTbl[i].reset(); + } - mMotorCounter = 0; - mMotorTimer = 0; - unk12 = 0; + mMotorCounter = 0; + mMotorTimer = 0; + unk12 = 0; } // Hmm... why does this inline in RumbleMgr::start(int, f32*)? #pragma dont_inline on -void RumbleControllerMgr::start( int channelDataIdx, int repeatCount, - f32 *multiplierF ) { - for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { - if ( mChannelMgrTbl[ i ].mChannelDataTbl == nullptr ) { - mChannelMgrTbl[ i ].start( channelDataIdx, repeatCount, - multiplierF ); - break; - } - } +void RumbleControllerMgr::start(int channelDataIdx, int repeatCount, + f32* multiplierF) +{ + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + if (mChannelMgrTbl[i].mChannelDataTbl == nullptr) { + mChannelMgrTbl[i].start(channelDataIdx, repeatCount, multiplierF); + break; + } + } } #pragma dont_inline reset // This one also inlines in RumbleMgr::start(int, Vec*)? #pragma dont_inline on -void RumbleControllerMgr::start( int channelDataIdx, int repeatCount, - Vec *worldPos ) { - for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { - if ( mChannelMgrTbl[ i ].mChannelDataTbl == nullptr ) { - mChannelMgrTbl[ i ].start( channelDataIdx, repeatCount, worldPos ); - break; - } - } +void RumbleControllerMgr::start(int channelDataIdx, int repeatCount, + Vec* worldPos) +{ + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + if (mChannelMgrTbl[i].mChannelDataTbl == nullptr) { + mChannelMgrTbl[i].start(channelDataIdx, repeatCount, worldPos); + break; + } + } } #pragma dont_inline reset // Size needed: 0x10C, current: 0x10C -void RumbleControllerMgr::stop() { - for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { - if ( mChannelMgrTbl[ i ].mChannelDataTbl != nullptr ) { - mChannelMgrTbl[ i ].reset(); - } - } +void RumbleControllerMgr::stop() +{ + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + if (mChannelMgrTbl[i].mChannelDataTbl != nullptr) { + mChannelMgrTbl[i].reset(); + } + } } // This one also inlines in RumbleMgr::stop(int)? #pragma dont_inline on -void RumbleControllerMgr::stop( int channelDataIdx ) { - for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { - if ( mChannelMgrTbl[ i ].mChannelDataTbl != nullptr && - mChannelMgrTbl[ i ].mChannelDataIdx == channelDataIdx ) { - mChannelMgrTbl[ i ].reset(); - } - } +void RumbleControllerMgr::stop(int channelDataIdx) +{ + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + if (mChannelMgrTbl[i].mChannelDataTbl != nullptr + && mChannelMgrTbl[i].mChannelDataIdx == channelDataIdx) { + mChannelMgrTbl[i].reset(); + } + } } #pragma dont_inline reset // Size needed: 0x11C, current: 0x11C -bool RumbleControllerMgr::channelMgrIsAllFree() { - bool allFree = true; - for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { - if ( mChannelMgrTbl[ i ].mChannelDataTbl != nullptr ) { - allFree = false; - } - } - return allFree; -} - -void RumbleControllerMgr::updateMotorCount() { - if ( unk12 ) { - if ( mMotorCounter > 0 ) { - mMotorCounter--; - } else { - unk12 = 0; - mMotorTimer = 0; - } - } else if ( mMotorCounter > RumbleMgr::mMotorCountLimit ) { - unk12 = 1; - } else if ( mMotorTimer > 0 ) { - mMotorTimer--; - mMotorCounter++; - } else { - mMotorCounter = 0; - } -} - -f32 RumbleControllerMgr::update() { - f32 maxPower = 0.0f; - for ( int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++ ) { - if ( mChannelMgrTbl[ i ].mChannelDataTbl != nullptr ) { - mPower = mChannelMgrTbl[ i ].update(); - if ( mPower > maxPower ) { - maxPower = mPower; - } - } - } - - mPower = maxPower; - if ( mPower > 1.0f ) { - mPower = 1.0f; - } else if ( mPower < 0.0f ) { - mPower = 0.0f; - } - - if ( mPower > RumbleMgr::mPowerThreshold ) { - mMotorTimer = RumbleMgr::mMotorTimerPeriod; - } - - if ( unk12 ) { - mPower = 0.0f; - } - - return mPower; -} - -RumbleMgr::RumbleMgr( bool controller1, bool controller2, bool controller3, - bool controller4 ) { - bool enable[ 4 ]; - - mPower = 0.0f; - mTimer = 0.0f; - - enable[ 0 ] = controller1; - enable[ 1 ] = controller2; - enable[ 2 ] = controller3; - enable[ 3 ] = controller4; - - for ( int i = 0; i < PAD_MAX_CONTROLLERS; i++ ) { - mControllerMgrTbl[ i ] = nullptr; - mRumbleBaseTbl[ i ] = nullptr; - - if ( enable[ i ] ) { - mControllerMgrTbl[ i ] = new RumbleControllerMgr(); - mRumbleBaseTbl[ i ] = new RumbleBase( i ); - } - } - - mChannelDataMgr = nullptr; - mChannelDataMgr = new RumbleChannelDataMgr(); - mActive = true; - mPaused = false; - mStopHard = true; -} - -void RumbleMgr::init() { - mPower = 0.0f; - mTimer = 0.0f; - - for ( int i = 0; i < PAD_MAX_CONTROLLERS; i++ ) { - if ( mControllerMgrTbl[ i ] != nullptr ) { - mControllerMgrTbl[ i ]->init(); - mRumbleBaseTbl[ i ]->init(); - } - } - - mChannelDataMgr->init(); - mActive = true; - mPaused = false; - mStopHard = true; -} - -void RumbleMgr::reset() { - mPower = 0.0f; - mTimer = 0.0f; - - for ( int i = 0; i < PAD_MAX_CONTROLLERS; i++ ) { - if ( mControllerMgrTbl[ i ] != nullptr ) { - mControllerMgrTbl[ i ]->reset(); - mRumbleBaseTbl[ i ]->stop(); - mRumbleBaseTbl[ i ]->init(); - } - } - - mPaused = 0; -} - -void RumbleMgr::start( int channelDataIdx, f32 *multiplierF ) { - int controllerIdx = 0; +bool RumbleControllerMgr::channelMgrIsAllFree() +{ + bool allFree = true; + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + if (mChannelMgrTbl[i].mChannelDataTbl != nullptr) { + allFree = false; + } + } + return allFree; +} + +void RumbleControllerMgr::updateMotorCount() +{ + if (unk12) { + if (mMotorCounter > 0) { + mMotorCounter--; + } else { + unk12 = 0; + mMotorTimer = 0; + } + } else if (mMotorCounter > RumbleMgr::mMotorCountLimit) { + unk12 = 1; + } else if (mMotorTimer > 0) { + mMotorTimer--; + mMotorCounter++; + } else { + mMotorCounter = 0; + } +} + +f32 RumbleControllerMgr::update() +{ + f32 maxPower = 0.0f; + for (int i = 0; i < RUMBLE_CHANNELS_PER_CONTROLLER; i++) { + if (mChannelMgrTbl[i].mChannelDataTbl != nullptr) { + mPower = mChannelMgrTbl[i].update(); + if (mPower > maxPower) { + maxPower = mPower; + } + } + } + + mPower = maxPower; + if (mPower > 1.0f) { + mPower = 1.0f; + } else if (mPower < 0.0f) { + mPower = 0.0f; + } + + if (mPower > RumbleMgr::mPowerThreshold) { + mMotorTimer = RumbleMgr::mMotorTimerPeriod; + } + + if (unk12) { + mPower = 0.0f; + } + + return mPower; +} + +RumbleMgr::RumbleMgr(bool controller1, bool controller2, bool controller3, + bool controller4) +{ + bool enable[4]; + + mPower = 0.0f; + mTimer = 0.0f; + + enable[0] = controller1; + enable[1] = controller2; + enable[2] = controller3; + enable[3] = controller4; + + for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { + mControllerMgrTbl[i] = nullptr; + mRumbleBaseTbl[i] = nullptr; + + if (enable[i]) { + mControllerMgrTbl[i] = new RumbleControllerMgr(); + mRumbleBaseTbl[i] = new RumbleBase(i); + } + } + + mChannelDataMgr = nullptr; + mChannelDataMgr = new RumbleChannelDataMgr(); + mActive = true; + mPaused = false; + mStopHard = true; +} + +void RumbleMgr::init() +{ + mPower = 0.0f; + mTimer = 0.0f; + + for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { + if (mControllerMgrTbl[i] != nullptr) { + mControllerMgrTbl[i]->init(); + mRumbleBaseTbl[i]->init(); + } + } + + mChannelDataMgr->init(); + mActive = true; + mPaused = false; + mStopHard = true; +} + +void RumbleMgr::reset() +{ + mPower = 0.0f; + mTimer = 0.0f; + + for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { + if (mControllerMgrTbl[i] != nullptr) { + mControllerMgrTbl[i]->reset(); + mRumbleBaseTbl[i]->stop(); + mRumbleBaseTbl[i]->init(); + } + } + + mPaused = 0; +} - if ( !mPaused && mActive && - mControllerMgrTbl[ controllerIdx ] != nullptr ) { - mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, 1, - multiplierF ); - } +void RumbleMgr::start(int channelDataIdx, f32* multiplierF) +{ + int controllerIdx = 0; + + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, 1, multiplierF); + } } -void RumbleMgr::start( int channelDataIdx, Vec *worldPos ) { - int controllerIdx = 0; +void RumbleMgr::start(int channelDataIdx, Vec* worldPos) +{ + int controllerIdx = 0; - if ( !mPaused && mActive && - mControllerMgrTbl[ controllerIdx ] != nullptr ) { - mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, 1, - worldPos ); - } + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, 1, worldPos); + } } // Size needed: 0x74, current: 0x74 -void RumbleMgr::start( int channelDataIdx, MtxPtr mtx ) { - int controllerIdx = 0; +void RumbleMgr::start(int channelDataIdx, MtxPtr mtx) +{ + int controllerIdx = 0; - if ( !mPaused && mActive && - mControllerMgrTbl[ controllerIdx ] != nullptr ) { - Vec worldPos; - worldPos.x = mtx[ 3 ][ 0 ]; - worldPos.y = mtx[ 3 ][ 1 ]; - worldPos.z = mtx[ 3 ][ 2 ]; + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + Vec worldPos; + worldPos.x = mtx[3][0]; + worldPos.y = mtx[3][1]; + worldPos.z = mtx[3][2]; - mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, 1, - &worldPos ); - } + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, 1, &worldPos); + } } -void RumbleMgr::start( int channelDataIdx, int repeatCount, f32 *multiplierF ) { - int controllerIdx = 0; +void RumbleMgr::start(int channelDataIdx, int repeatCount, f32* multiplierF) +{ + int controllerIdx = 0; - if ( !mPaused && mActive && - mControllerMgrTbl[ controllerIdx ] != nullptr ) { - mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, repeatCount, - multiplierF ); - } + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, + multiplierF); + } } -void RumbleMgr::start( int channelDataIdx, int repeatCount, Vec *worldPos ) { - int controllerIdx = 0; +void RumbleMgr::start(int channelDataIdx, int repeatCount, Vec* worldPos) +{ + int controllerIdx = 0; - if ( !mPaused && mActive && - mControllerMgrTbl[ controllerIdx ] != nullptr ) { - mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, repeatCount, - worldPos ); - } + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, + worldPos); + } } // Size needed: 0x70, current: 0x70 -void RumbleMgr::start( int channelDataIdx, int repeatCount, MtxPtr mtx ) { - int controllerIdx = 0; +void RumbleMgr::start(int channelDataIdx, int repeatCount, MtxPtr mtx) +{ + int controllerIdx = 0; - if ( !mPaused && mActive && - mControllerMgrTbl[ controllerIdx ] != nullptr ) { - Vec worldPos; - worldPos.x = mtx[ 3 ][ 0 ]; - worldPos.y = mtx[ 3 ][ 1 ]; - worldPos.z = mtx[ 3 ][ 2 ]; + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + Vec worldPos; + worldPos.x = mtx[3][0]; + worldPos.y = mtx[3][1]; + worldPos.z = mtx[3][2]; - mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, repeatCount, - &worldPos ); - } + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, + &worldPos); + } } // Size needed: 0x94, current: 0x58 -void RumbleMgr::start( int controllerIdx, int channelDataIdx, int repeatCount, - f32 *multiplierF ) { - if ( !mPaused && mActive && - mControllerMgrTbl[ controllerIdx ] != nullptr ) { - mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, repeatCount, - multiplierF ); - } +void RumbleMgr::start(int controllerIdx, int channelDataIdx, int repeatCount, + f32* multiplierF) +{ + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, + multiplierF); + } } // Size needed: 0x94, current: 0x58 -void RumbleMgr::start( int controllerIdx, int channelDataIdx, int repeatCount, - Vec *worldPos ) { - if ( !mPaused && mActive && - mControllerMgrTbl[ controllerIdx ] != nullptr ) { - mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, repeatCount, - worldPos ); - } +void RumbleMgr::start(int controllerIdx, int channelDataIdx, int repeatCount, + Vec* worldPos) +{ + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, + worldPos); + } } // Size needed: 0x7C, current: 0x74 -void RumbleMgr::start( int controllerIdx, int channelDataIdx, int repeatCount, - MtxPtr mtx ) { - if ( !mPaused && mActive && - mControllerMgrTbl[ controllerIdx ] != nullptr ) { - Vec worldPos; - worldPos.x = mtx[ 3 ][ 0 ]; - worldPos.y = mtx[ 3 ][ 1 ]; - worldPos.z = mtx[ 3 ][ 2 ]; +void RumbleMgr::start(int controllerIdx, int channelDataIdx, int repeatCount, + MtxPtr mtx) +{ + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + Vec worldPos; + worldPos.x = mtx[3][0]; + worldPos.y = mtx[3][1]; + worldPos.z = mtx[3][2]; - mControllerMgrTbl[ controllerIdx ]->start( channelDataIdx, repeatCount, - &worldPos ); - } + mControllerMgrTbl[controllerIdx]->start(channelDataIdx, repeatCount, + &worldPos); + } } // @stack -void RumbleMgr::stop() { - // @fake - this fixes our stack mismatch, perhaps a leftover debug print? - int stack[ 2 ]; - ( void )stack; +void RumbleMgr::stop() +{ + // @fake - this fixes our stack mismatch, perhaps a leftover debug print? + int stack[2]; + (void)stack; - for ( int i = 0; i < PAD_MAX_CONTROLLERS; i++ ) { - if ( mControllerMgrTbl[ i ] != nullptr ) { - mControllerMgrTbl[ i ]->stop(); - } - } + for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { + if (mControllerMgrTbl[i] != nullptr) { + mControllerMgrTbl[i]->stop(); + } + } } -void RumbleMgr::stop( int channelDataIdx ) { - int controllerIdx = 0; +void RumbleMgr::stop(int channelDataIdx) +{ + int controllerIdx = 0; - if ( !mPaused && mActive && - mControllerMgrTbl[ controllerIdx ] != nullptr ) { - mControllerMgrTbl[ controllerIdx ]->stop( channelDataIdx ); - } + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->stop(channelDataIdx); + } } // Size needed: 0x178, current: 0x50 -void RumbleMgr::stop( int controllerIdx, int channelDataIdx ) { - if ( !mPaused && mActive && - mControllerMgrTbl[ controllerIdx ] != nullptr ) { - mControllerMgrTbl[ controllerIdx ]->stop( channelDataIdx ); - } +void RumbleMgr::stop(int controllerIdx, int channelDataIdx) +{ + if (!mPaused && mActive && mControllerMgrTbl[controllerIdx] != nullptr) { + mControllerMgrTbl[controllerIdx]->stop(channelDataIdx); + } } // @stack -void RumbleMgr::update() { - // @fake - this fixes our stack mismatch, perhaps a leftover debug print? - // NOTE: same hack fixes RumbleMgr::stop() - int stack[ 2 ]; - ( void )stack; +void RumbleMgr::update() +{ + // @fake - this fixes our stack mismatch, perhaps a leftover debug print? + // NOTE: same hack fixes RumbleMgr::stop() + int stack[2]; + (void)stack; - f32 updateRate = 1.0f / SMSGetVSyncTimesPerSec(); + f32 updateRate = 1.0f / SMSGetVSyncTimesPerSec(); - if ( mPaused || !mActive ) { - return; - } + if (mPaused || !mActive) { + return; + } - for ( int i = 0; i < PAD_MAX_CONTROLLERS; i++ ) { - if ( mControllerMgrTbl[ i ] != nullptr ) { - if ( !mControllerMgrTbl[ i ]->channelMgrIsAllFree() ) { - mPower = mControllerMgrTbl[ i ]->update(); + for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { + if (mControllerMgrTbl[i] != nullptr) { + if (!mControllerMgrTbl[i]->channelMgrIsAllFree()) { + mPower = mControllerMgrTbl[i]->update(); - if ( mTimer > 0.0f ) { - mPower *= ( ( 1.0f - mPower ) * ( mTimer / 0.5f ) + 1.0f ); - } + if (mTimer > 0.0f) { + mPower *= ((1.0f - mPower) * (mTimer / 0.5f) + 1.0f); + } - if ( mPower > 1.0f ) { - mPower = 1.0f; - } else if ( mPower < 0.0f ) { - mPower = 0.0f; - } + if (mPower > 1.0f) { + mPower = 1.0f; + } else if (mPower < 0.0f) { + mPower = 0.0f; + } - mRumbleBaseTbl[ i ]->update( mPower, mStopHard ); - } else { - mRumbleBaseTbl[ i ]->stop(); - mRumbleBaseTbl[ i ]->init(); - } + mRumbleBaseTbl[i]->update(mPower, mStopHard); + } else { + mRumbleBaseTbl[i]->stop(); + mRumbleBaseTbl[i]->init(); + } - mControllerMgrTbl[ i ]->updateMotorCount(); - } - } + mControllerMgrTbl[i]->updateMotorCount(); + } + } - if ( mTimer > 0.0f ) { - mTimer -= updateRate; - } + if (mTimer > 0.0f) { + mTimer -= updateRate; + } } -void RumbleMgr::setActive( bool active ) { - mActive = active; - if ( !mActive ) { - reset(); - } +void RumbleMgr::setActive(bool active) +{ + mActive = active; + if (!mActive) { + reset(); + } } -void RumbleMgr::startPause() { - for ( int i = 0; i < PAD_MAX_CONTROLLERS; i++ ) { - if ( mRumbleBaseTbl[ i ] != nullptr ) { - mRumbleBaseTbl[ i ]->stop(); - } - } +void RumbleMgr::startPause() +{ + for (int i = 0; i < PAD_MAX_CONTROLLERS; i++) { + if (mRumbleBaseTbl[i] != nullptr) { + mRumbleBaseTbl[i]->stop(); + } + } - mPaused = true; + mPaused = true; } -void RumbleMgr::finishPause() { - mTimer = 0.5f; - mPaused = false; +void RumbleMgr::finishPause() +{ + mTimer = 0.5f; + mPaused = false; } // Size needed: 0x94, current: 0x94 -void RumbleMgr::changePause() { - if ( mPaused ) { - finishPause(); - } else { - startPause(); - } +void RumbleMgr::changePause() +{ + if (mPaused) { + finishPause(); + } else { + startPause(); + } } // Size needed: 0x24, current: 0x24 -void RumbleMgr::changeMode() { - if ( mStopHard ) { - mStopHard = false; - } else { - mStopHard = true; - } -} \ No newline at end of file +void RumbleMgr::changeMode() +{ + if (mStopHard) { + mStopHard = false; + } else { + mStopHard = true; + } +} diff --git a/src/MarioUtil/RumbleType.cpp b/src/MarioUtil/RumbleType.cpp index 2cd83e78..1b580051 100644 --- a/src/MarioUtil/RumbleType.cpp +++ b/src/MarioUtil/RumbleType.cpp @@ -4,55 +4,57 @@ extern int channelNum; struct RumbleTypeInfo { - unsigned int unk0; - char *str; + unsigned int unk0; + char* str; }; // Enum To Str? // @BUG - channelNum (number of rumble types) is 25, // but _info is only 23 elements long. -struct RumbleTypeInfo _info[ 23 ] = { - { 0, "MARIO_HIPDROP" }, - { 1, "MARIO_DAMAGE" }, - { 2, "MARIO_LANDING" }, - { 3, "MARIO_0_1SEC_FULL" }, - { 4, "MARIO_HIP_ATTACK2" }, - { 5, "MARIO_DAMAGE2" }, - { 6, "MARIO_RUMBLE_06" }, - { 7, "MARIO_RUMBLE_07" }, - { 8, "MARIO_1SEC_SIN" }, - { 9, "MARIO_1SEC_SIN_HALF" }, - { 10, "MARIO_RUMBLE_10" }, - { 11, "MARIO_RUMBLE_11" }, - { 12, "MARIO_RUMBLE_12" }, - { 13, "MARIO_RUMBLE_13" }, - { 14, "MARIO_RUMBLE_14" }, - { 15, "MARIO_RUMBLE_15" }, - { 16, "MARIO_RUMBLE_16" }, - { 17, "MARIO_RUMBLE_17" }, - { 18, "MARIO_RUMBLE_18" }, - { 19, "MAPOBJ_APPEAR" }, - { 20, "MARIO_WEAK" }, - { 21, "MARIO_HARD" }, - { 22, "MARIO_ELECTRIC_DAMAGE" }, +struct RumbleTypeInfo _info[23] = { + { 0, "MARIO_HIPDROP" }, + { 1, "MARIO_DAMAGE" }, + { 2, "MARIO_LANDING" }, + { 3, "MARIO_0_1SEC_FULL" }, + { 4, "MARIO_HIP_ATTACK2" }, + { 5, "MARIO_DAMAGE2" }, + { 6, "MARIO_RUMBLE_06" }, + { 7, "MARIO_RUMBLE_07" }, + { 8, "MARIO_1SEC_SIN" }, + { 9, "MARIO_1SEC_SIN_HALF" }, + { 10, "MARIO_RUMBLE_10" }, + { 11, "MARIO_RUMBLE_11" }, + { 12, "MARIO_RUMBLE_12" }, + { 13, "MARIO_RUMBLE_13" }, + { 14, "MARIO_RUMBLE_14" }, + { 15, "MARIO_RUMBLE_15" }, + { 16, "MARIO_RUMBLE_16" }, + { 17, "MARIO_RUMBLE_17" }, + { 18, "MARIO_RUMBLE_18" }, + { 19, "MAPOBJ_APPEAR" }, + { 20, "MARIO_WEAK" }, + { 21, "MARIO_HARD" }, + { 22, "MARIO_ELECTRIC_DAMAGE" }, }; -const char *invalidStr = "Invalid RumbleType"; +const char* invalidStr = "Invalid RumbleType"; -int RumbleType::getIndex( char *strIn ) { - for ( int i = 0; i < channelNum; i++ ) { - if ( !strcmp( strIn, _info[ i ].str ) ) { - return _info[ i ].unk0; - } - } - return -1; +int RumbleType::getIndex(char* strIn) +{ + for (int i = 0; i < channelNum; i++) { + if (!strcmp(strIn, _info[i].str)) { + return _info[i].unk0; + } + } + return -1; } // Size needed: 0x54, current: 0x34 -const char *RumbleType::getName( int index ) { - if ( index < 0 || index >= channelNum ) { - return invalidStr; - } +const char* RumbleType::getName(int index) +{ + if (index < 0 || index >= channelNum) { + return invalidStr; + } - return _info[ index ].str; -} \ No newline at end of file + return _info[index].str; +}