Files
wii-ipl/include/math/iplMathTypes.h
coah f8d83e5ff2 Fork for AI-assisted matching work
Personal fork so AI-assisted decomp work has a home without disturbing
upstream. README explains the fork; AGENTS.md documents the method and
forbids ever opening a PR against koopthekoopa/wii-ipl.

Matching progress: +9 exact functions, 0 regressions, main.dol still
byte-identical (26116613f624061ba99c8d1a299aaa6efa85670d).

iplESMisc gains CheckTmdParentalControl, CheckSafeDeleteTitle,
NumPrivateContents, checkContentsNum and GetValidTicketIndex, plus the
other functions matched in the previous pass.

The load-bearing finding, written up in AGENTS.md: MWCC emits a
translation unit's string literals in source-token order. A missing
function, or an inverted if/else, shifts every later string offset and
breaks functions that were never edited. Fixing that pool ordering lifted
TMDFile::Open from 99.92 to 99.96 without touching Open.

Adds tools/decomp-assist/ with pool_diff.py, ctxdiff.py, disasm_fn.py,
export_pyghidra.py and the Ghidra decompilation dump.
2026-09-19 13:19:34 +00:00

152 lines
4.2 KiB
C++

#ifndef IPL_MATH_TYPES_H
#define IPL_MATH_TYPES_H
#ifdef __cplusplus
#include <nw4r/math.h>
/*
* MWerks math.h defines a macro that replaces all occurences of abs with __abs,
* breaking code matching in some places that explicitly require ipl::math::abs.
*/
#undef abs
#define IPL_MATH_CLAMP(x, min, max) x < min ? min : (x > max ? max : x)
#define IPL_MATH_INF ((1.0f / 0.0f))
#define IPL_MATH_NAN ((0.0f / 0.0f))
#define IPL_MATH_NULL_FLOAT IPL_MATH_INF
namespace ipl {
namespace math {
template <typename T>
inline T abs(const T& x) {
return nw4r::math::FAbs(x);
}
template <typename T>
T abs_clamp(const T& x, const T& y) {
if (x > y) {
return y;
} else if (x < -y) {
return -y;
} else {
return x;
}
}
typedef struct MTX33 : public nw4r::math::MTX33 {
} MTX33;
typedef struct MTX34 : public nw4r::math::MTX34 {
} MTX34;
typedef struct MTX44 : public nw4r::math::MTX44 {
} MTX44;
typedef struct VEC2 : public nw4r::math::VEC2 {
VEC2() {}
operator nw4r::math::_VEC2*() { return reinterpret_cast<nw4r::math::_VEC2*>(this); }
operator const nw4r::math::_VEC2*() const { return reinterpret_cast<const nw4r::math::_VEC2*>(this); }
VEC2(const nw4r::math::_VEC2& r) {
x = r.x;
y = r.y;
}
VEC2(f32 fx, f32 fy) {
x = fx;
y = fy;
}
void operator=(const VEC2& r);
VEC2 operator*(f32 val) const { return VEC2(x * val, y * val); }
void set(f32 fx, f32 fy) {
x = fx;
y = fy;
}
void clear() {
y = 0;
x = 0;
}
} VEC2;
typedef struct VEC3 : public nw4r::math::VEC3 {
VEC3() {}
operator nw4r::math::_VEC3*() { return reinterpret_cast<nw4r::math::_VEC3*>(this); }
operator const nw4r::math::_VEC3*() const { return reinterpret_cast<const nw4r::math::_VEC3*>(this); }
VEC3(const nw4r::math::_VEC3& r) {
x = r.x;
y = r.y;
z = r.z;
}
VEC3(const nw4r::math::_VEC2& r) {
x = r.x;
y = r.y;
z = 0.0f;
}
VEC3(f32 fx, f32 fy, f32 fz) {
x = fx;
y = fy;
z = fz;
}
VEC3& operator+=(const VEC3& rhs) {
VEC3Add(this, this, &rhs);
return *this;
}
VEC3& operator+=(f32 v) {
x + v;
y + v;
z + v;
return *this;
}
VEC3& operator-=(const VEC3& rhs) {
VEC3Sub(this, this, &rhs);
return *this;
}
VEC3& operator*=(f32 val) {
VEC3Scale(this, this, val);
return *this;
}
VEC3& operator/=(f32 val) { return operator*=(1.f / val); }
VEC3 operator+(const VEC3& rhs) const { return VEC3(x + rhs.x, y + rhs.y, z + rhs.z); }
VEC3 operator+(f32 v) const { return VEC3(x + v, y + v, z + v); }
VEC3 operator-(const VEC3& rhs) const { return VEC3(x - rhs.x, y - rhs.y, z - rhs.z); }
VEC3 operator*(f32 val) const { return VEC3(x * val, y * val, z * val); }
VEC3 operator*(f64 val) const {
nw4r::math::VEC3 vecOut;
VEC3Scale(&vecOut, this, (f32)val);
return vecOut;
}
void set(f32 fx, f32 fy, f32 fz) {
x = fx;
y = fx;
z = fz;
}
void clear() {
z = 0;
y = 0;
x = 0;
}
} VEC3;
inline VEC3* VEC3Transform(VEC3* pOut, const nw4r::math::MTX34* pMtx, const VEC3* pVec) {
MTXMultVec(*pMtx, *pVec, *pOut);
return pOut;
}
} // namespace math
} // namespace ipl
#endif // __cplusplus
#endif // IPL_MATH_TYPES_H