From a5d1c8aa82dd979835e736611c5f5b66c01a20c2 Mon Sep 17 00:00:00 2001 From: Hyblocker Date: Sun, 12 Oct 2025 19:53:37 +0200 Subject: [PATCH 01/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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); } } }