From e1a1aea32f313c440c588cbfe9cbbdccea1ad86a Mon Sep 17 00:00:00 2001 From: Christian Semmler Date: Tue, 31 Dec 2024 11:03:37 -0700 Subject: [PATCH] Order experimentation --- LEGO1/lego/legoomni/include/helicopter.h | 12 +- LEGO1/lego/legoomni/include/islepathactor.h | 37 +- .../legoomni/include/legoanimationmanager.h | 1 + LEGO1/lego/sources/anim/legoanim.cpp | 1 + LEGO1/lego/sources/geom/legowegedge.h | 1 + LEGO1/lego/sources/roi/legoroi.cpp | 1 + LEGO1/mxgeometry/mxgeometry3d.h | 195 -------- LEGO1/mxgeometry/mxgeometry4d.h | 197 ++++++++ LEGO1/mxgeometry/mxmatrix.h | 34 +- LEGO1/realtime/matrix.h | 351 -------------- LEGO1/realtime/vector.h | 433 ++++++++++++++++-- 11 files changed, 634 insertions(+), 629 deletions(-) create mode 100644 LEGO1/mxgeometry/mxgeometry4d.h diff --git a/LEGO1/lego/legoomni/include/helicopter.h b/LEGO1/lego/legoomni/include/helicopter.h index 8d887d73..2e49c024 100644 --- a/LEGO1/lego/legoomni/include/helicopter.h +++ b/LEGO1/lego/legoomni/include/helicopter.h @@ -44,17 +44,16 @@ class HelicopterState : public LegoState { MxU32 m_unk0x08; // 0x08 }; +#include "mxgeometry/mxgeometry4d.h" + // VTABLE: LEGO1 0x100d40f8 // VTABLE: BETA10 0x101b9880 // SIZE 0x230 class Helicopter : public IslePathActor { public: - Helicopter(); - ~Helicopter() override; // vtable+0x00 - // FUNCTION: LEGO1 0x10003070 // FUNCTION: BETA10 0x1002b300 - const char* ClassName() const override // vtable+0x0c + virtual const char* ClassName() const override // vtable+0x0c { // STRING: LEGO1 0x100f0130 return "Helicopter"; @@ -62,11 +61,14 @@ class Helicopter : public IslePathActor { // FUNCTION: LEGO1 0x10003080 // FUNCTION: BETA10 0x1002b330 - MxBool IsA(const char* p_name) const override // vtable+0x10 + virtual MxBool IsA(const char* p_name) const override // vtable+0x10 { return !strcmp(p_name, Helicopter::ClassName()) || IslePathActor::IsA(p_name); } + Helicopter(); + ~Helicopter() override; // vtable+0x00 + MxResult Create(MxDSAction& p_dsAction) override; // vtable+0x18 void Animate(float p_time) override; // vtable+0x70 void VTable0x74(Matrix4& p_transform) override; // vtable+0x74 diff --git a/LEGO1/lego/legoomni/include/islepathactor.h b/LEGO1/lego/legoomni/include/islepathactor.h index 1aa5616a..4a235669 100644 --- a/LEGO1/lego/legoomni/include/islepathactor.h +++ b/LEGO1/lego/legoomni/include/islepathactor.h @@ -86,10 +86,27 @@ class IslePathActor : public LegoPathActor { IslePathActor(); + // FUNCTION: LEGO1 0x10002df0 + virtual MxLong HandleNotification0() { return 0; } // vtable+0xd0 + + // FUNCTION: LEGO1 0x10002e00 + virtual MxLong HandlePathStruct(LegoPathStructNotificationParam&) { return 0; } // vtable+0xdc + // FUNCTION: LEGO1 0x10002e10 ~IslePathActor() override { IslePathActor::Destroy(TRUE); } - MxLong Notify(MxParam& p_param) override; // vtable+0x04 + // FUNCTION: LEGO1 0x10002e70 + virtual MxLong HandleClick() { return 0; } // vtable+0xcc + + // FUNCTION: LEGO1 0x10002e80 + virtual MxLong HandleControl(LegoControlManagerNotificationParam&) { return 0; } // vtable+0xd4 + + // FUNCTION: LEGO1 0x10002e90 + virtual MxLong HandleEndAnim(LegoEndAnimNotificationParam&) { return 0; } // vtable+0xd8 + + MxLong Notify(MxParam& p_param) override; // vtable+0x04 + MxResult Create(MxDSAction& p_dsAction) override; // vtable+0x18 + void Destroy(MxBool p_fromDestructor) override; // vtable+0x1c // FUNCTION: LEGO1 0x10002ea0 // FUNCTION: BETA10 0x10023fa0 @@ -105,24 +122,6 @@ class IslePathActor : public LegoPathActor { return !strcmp(p_name, IslePathActor::ClassName()) || LegoPathActor::IsA(p_name); } - MxResult Create(MxDSAction& p_dsAction) override; // vtable+0x18 - void Destroy(MxBool p_fromDestructor) override; // vtable+0x1c - - // FUNCTION: LEGO1 0x10002e70 - virtual MxLong HandleClick() { return 0; } // vtable+0xcc - - // FUNCTION: LEGO1 0x10002df0 - virtual MxLong HandleNotification0() { return 0; } // vtable+0xd0 - - // FUNCTION: LEGO1 0x10002e80 - virtual MxLong HandleControl(LegoControlManagerNotificationParam&) { return 0; } // vtable+0xd4 - - // FUNCTION: LEGO1 0x10002e90 - virtual MxLong HandleEndAnim(LegoEndAnimNotificationParam&) { return 0; } // vtable+0xd8 - - // FUNCTION: LEGO1 0x10002e00 - virtual MxLong HandlePathStruct(LegoPathStructNotificationParam&) { return 0; } // vtable+0xdc - virtual void Enter(); // vtable+0xe0 virtual void Exit(); // vtable+0xe4 virtual void SpawnPlayer(LegoGameState::Area p_area, MxBool p_enter, MxU8 p_flags); // vtable+0xe8 diff --git a/LEGO1/lego/legoomni/include/legoanimationmanager.h b/LEGO1/lego/legoomni/include/legoanimationmanager.h index 56f6d0a7..32430729 100644 --- a/LEGO1/lego/legoomni/include/legoanimationmanager.h +++ b/LEGO1/lego/legoomni/include/legoanimationmanager.h @@ -8,6 +8,7 @@ #include "legotraninfolist.h" #include "mxcore.h" #include "mxgeometry/mxgeometry3d.h" +#include "mxgeometry/mxgeometry4d.h" class LegoAnimPresenter; class LegoEntity; diff --git a/LEGO1/lego/sources/anim/legoanim.cpp b/LEGO1/lego/sources/anim/legoanim.cpp index 39b8921b..e367b815 100644 --- a/LEGO1/lego/sources/anim/legoanim.cpp +++ b/LEGO1/lego/sources/anim/legoanim.cpp @@ -1,5 +1,6 @@ #include "legoanim.h" +#include "mxgeometry/mxgeometry4d.h" #include "mxgeometry/mxmatrix.h" #include diff --git a/LEGO1/lego/sources/geom/legowegedge.h b/LEGO1/lego/sources/geom/legowegedge.h index 77567bfe..350e31b7 100644 --- a/LEGO1/lego/sources/geom/legowegedge.h +++ b/LEGO1/lego/sources/geom/legowegedge.h @@ -4,6 +4,7 @@ #include "decomp.h" #include "legoweedge.h" #include "mxgeometry/mxgeometry3d.h" +#include "mxgeometry/mxgeometry4d.h" class LegoPathStruct; diff --git a/LEGO1/lego/sources/roi/legoroi.cpp b/LEGO1/lego/sources/roi/legoroi.cpp index 6598af3e..2c0bc7de 100644 --- a/LEGO1/lego/sources/roi/legoroi.cpp +++ b/LEGO1/lego/sources/roi/legoroi.cpp @@ -4,6 +4,7 @@ #include "legolod.h" #include "misc/legocontainer.h" #include "misc/legostorage.h" +#include "mxgeometry/mxgeometry4d.h" #include "realtime/realtime.h" #include "shape/legobox.h" #include "shape/legosphere.h" diff --git a/LEGO1/mxgeometry/mxgeometry3d.h b/LEGO1/mxgeometry/mxgeometry3d.h index 1b41d03e..f35daeb2 100644 --- a/LEGO1/mxgeometry/mxgeometry3d.h +++ b/LEGO1/mxgeometry/mxgeometry3d.h @@ -53,199 +53,4 @@ class Mx3DPointFloat : public Vector3 { float m_elements[3]; // 0x08 }; -// VTABLE: LEGO1 0x100d41e8 -// VTABLE: BETA10 0x101bab78 -// SIZE 0x18 -class Mx4DPointFloat : public Vector4 { -public: - // FUNCTION: LEGO1 0x10048290 - // FUNCTION: BETA10 0x100484c0 - Mx4DPointFloat() : Vector4(m_elements) {} - - // FUNCTION: BETA10 0x10073bb0 - Mx4DPointFloat(float p_x, float p_y, float p_z, float p_a) : Vector4(m_elements) - { - m_elements[0] = p_x; - m_elements[1] = p_y; - m_elements[2] = p_z; - m_elements[3] = p_a; - } - - Mx4DPointFloat(const Mx4DPointFloat& p_other) : Vector4(m_elements) { EqualsImpl(p_other.m_data); } - - // FUNCTION: LEGO1 0x10003200 - virtual void operator=(const Vector4& p_impl) { EqualsImpl(p_impl.m_data); } // vtable+0x98 - - // FUNCTION: BETA10 0x1004af10 - float& operator[](int idx) { return m_data[idx]; } - - // According to the PDB, BETA10 will not link this one if it is never used - // const float& operator[](int idx) const { return m_data[idx]; } - - // only used by a couple of BETA10 functions for some unknown reason - // FUNCTION: BETA10 0x1001c950 - float& index_operator(int idx) { return m_data[idx]; } - - // SYNTHETIC: LEGO1 0x10064b20 - // SYNTHETIC: BETA10 0x10070420 - // ??4Mx4DPointFloat@@QAEAAV0@ABV0@@Z - -private: - float m_elements[4]; // 0x08 -}; - -// SIZE 0x34 -class UnknownMx4DPointFloat { -public: - enum { - c_bit1 = 0x01, - c_bit2 = 0x02 - }; - - UnknownMx4DPointFloat() : m_unk0x30(0) {} - - // FUNCTION: BETA10 0x1004a9b0 - void BETA_1004a9b0(Matrix4& p_m1, Matrix4& p_m2) - { - BETA_1004a9f0(p_m1); - FUN_10004620(p_m2); - } - - // FUNCTION: BETA10 0x1004a9f0 - void BETA_1004a9f0(Matrix4& p_m) - { - p_m.ToQuaternion(m_unk0x00); - m_unk0x30 |= c_bit1; - } - - // FUNCTION: LEGO1 0x10004620 - // FUNCTION: BETA10 0x1004aa30 - void FUN_10004620(Matrix4& p_m) - { - p_m.ToQuaternion(m_unk0x18); - m_unk0x30 |= c_bit2; - } - - // FUNCTION: BETA10 0x10180b80 - void BETA_10180b80(Vector4& p_v) - { - m_unk0x00 = p_v; - m_unk0x30 |= c_bit1; - } - - // FUNCTION: BETA10 0x10180bc0 - void BETA_10180bc0(Vector4& p_v) - { - m_unk0x18 = p_v; - m_unk0x30 |= c_bit2; - } - - const Vector4& GetUnknown0x00() const { return m_unk0x00; } - const Vector4& GetUnknown0x18() const { return m_unk0x18; } - undefined4 GetUnknown0x30() const { return m_unk0x30; } - - inline int BETA_1004aaa0(Matrix4& p_matrix, float p_f); - inline long FUN_10004520(); - -private: - inline int FUN_100040a0(Vector4& p_v, float p_f); - - Mx4DPointFloat m_unk0x00; // 0x00 - Mx4DPointFloat m_unk0x18; // 0x18 - undefined4 m_unk0x30; // 0x30 -}; - -// FUNCTION: BETA10 0x1004aaa0 -inline int UnknownMx4DPointFloat::BETA_1004aaa0(Matrix4& p_matrix, float p_f) -{ - float data[4]; - Vector4 v(data); - - if (FUN_100040a0(v, p_f) == 0) { - return p_matrix.FromQuaternion(v); - } - - return -1; -} - -// FUNCTION: LEGO1 0x10004520 -inline long UnknownMx4DPointFloat::FUN_10004520() -{ - if (!m_unk0x30) { - return -1; - } - - Mx4DPointFloat v1; - Mx4DPointFloat v2; - - v1 = m_unk0x00; - v1 += m_unk0x18; - - v2 = m_unk0x00; - v2 -= m_unk0x18; - - if (v1.Dot(v1, v1) < v2.Dot(v2, v2)) { - m_unk0x18 *= -1.0f; - } - - return 0; -} - -// FUNCTION: LEGO1 0x100040a0 -// FUNCTION: BETA10 0x1004ab10 -inline int UnknownMx4DPointFloat::FUN_100040a0(Vector4& p_v, float p_f) -{ - if (m_unk0x30 == c_bit1) { - p_v = m_unk0x00; - p_v[3] = (float) ((1.0 - p_f) * acos((double) p_v[3]) * 2.0); - return p_v.NormalizeQuaternion(); - } - - if (m_unk0x30 == c_bit2) { - p_v = m_unk0x18; - p_v[3] = (float) (p_f * acos((double) p_v[3]) * 2.0); - return p_v.NormalizeQuaternion(); - } - - if (m_unk0x30 == (c_bit1 | c_bit2)) { - int i; - double d1 = p_v.Dot(m_unk0x00, m_unk0x18); - double a; - double b; - - if (d1 + 1.0 > 0.00001) { - if (1.0 - d1 > 0.00001) { - double d2 = acos(d1); - double denominator = sin(d2); - a = sin((1.0 - p_f) * d2) / denominator; - b = sin(p_f * d2) / denominator; - } - else { - a = 1.0 - p_f; - b = p_f; - } - - for (i = 0; i < 4; i++) { - p_v[i] = (float) (m_unk0x00[i] * a + m_unk0x18[i] * b); - } - } - else { - p_v[0] = -m_unk0x00[1]; - p_v[1] = m_unk0x00[0]; - p_v[2] = -m_unk0x00[3]; - p_v[3] = m_unk0x00[2]; - a = sin((1.0 - p_f) * 1.570796326794895); - b = sin(p_f * 1.570796326794895); - - for (i = 0; i < 3; i++) { - p_v[i] = (float) (m_unk0x00[i] * a + p_v[i] * b); - } - } - - return 0; - } - - return -1; -} - #endif // MXGEOMETRY3D_H diff --git a/LEGO1/mxgeometry/mxgeometry4d.h b/LEGO1/mxgeometry/mxgeometry4d.h new file mode 100644 index 00000000..349854c1 --- /dev/null +++ b/LEGO1/mxgeometry/mxgeometry4d.h @@ -0,0 +1,197 @@ +#ifndef MXGEOMETRY4D_H +#define MXGEOMETRY4D_H + +#include "decomp.h" +#include "realtime/vector.h" + +// VTABLE: LEGO1 0x100d41e8 +// VTABLE: BETA10 0x101bab78 +// SIZE 0x18 +class Mx4DPointFloat : public Vector4 { +public: + // FUNCTION: LEGO1 0x10048290 + // FUNCTION: BETA10 0x100484c0 + Mx4DPointFloat() : Vector4(m_elements) {} + + // FUNCTION: BETA10 0x10073bb0 + Mx4DPointFloat(float p_x, float p_y, float p_z, float p_a) : Vector4(m_elements) + { + m_elements[0] = p_x; + m_elements[1] = p_y; + m_elements[2] = p_z; + m_elements[3] = p_a; + } + + Mx4DPointFloat(const Mx4DPointFloat& p_other) : Vector4(m_elements) { EqualsImpl(p_other.m_data); } + + // FUNCTION: LEGO1 0x10003200 + virtual void operator=(const Vector4& p_impl) { EqualsImpl(p_impl.m_data); } // vtable+0x98 + + // FUNCTION: BETA10 0x1004af10 + float& operator[](int idx) { return m_data[idx]; } + + // According to the PDB, BETA10 will not link this one if it is never used + // const float& operator[](int idx) const { return m_data[idx]; } + + // only used by a couple of BETA10 functions for some unknown reason + // FUNCTION: BETA10 0x1001c950 + float& index_operator(int idx) { return m_data[idx]; } + + // SYNTHETIC: LEGO1 0x10064b20 + // SYNTHETIC: BETA10 0x10070420 + // ??4Mx4DPointFloat@@QAEAAV0@ABV0@@Z + +private: + float m_elements[4]; // 0x08 +}; + +// SIZE 0x34 +class UnknownMx4DPointFloat { +public: + enum { + c_bit1 = 0x01, + c_bit2 = 0x02 + }; + + UnknownMx4DPointFloat() : m_unk0x30(0) {} + + // FUNCTION: BETA10 0x1004a9b0 + void BETA_1004a9b0(Matrix4& p_m1, Matrix4& p_m2) + { + BETA_1004a9f0(p_m1); + FUN_10004620(p_m2); + } + + // FUNCTION: BETA10 0x1004a9f0 + void BETA_1004a9f0(Matrix4& p_m) + { + p_m.ToQuaternion(m_unk0x00); + m_unk0x30 |= c_bit1; + } + + // FUNCTION: LEGO1 0x10004620 + // FUNCTION: BETA10 0x1004aa30 + void FUN_10004620(Matrix4& p_m) + { + p_m.ToQuaternion(m_unk0x18); + m_unk0x30 |= c_bit2; + } + + // FUNCTION: BETA10 0x10180b80 + void BETA_10180b80(Vector4& p_v) + { + m_unk0x00 = p_v; + m_unk0x30 |= c_bit1; + } + + // FUNCTION: BETA10 0x10180bc0 + void BETA_10180bc0(Vector4& p_v) + { + m_unk0x18 = p_v; + m_unk0x30 |= c_bit2; + } + + const Vector4& GetUnknown0x00() const { return m_unk0x00; } + const Vector4& GetUnknown0x18() const { return m_unk0x18; } + undefined4 GetUnknown0x30() const { return m_unk0x30; } + + // FUNCTION: BETA10 0x1004aaa0 + inline int BETA_1004aaa0(Matrix4& p_matrix, float p_f) + { + float data[4]; + Vector4 v(data); + + if (FUN_100040a0(v, p_f) == 0) { + return p_matrix.FromQuaternion(v); + } + + return -1; + } + + // FUNCTION: LEGO1 0x10004520 + inline long FUN_10004520() + { + if (!m_unk0x30) { + return -1; + } + + Mx4DPointFloat v1; + Mx4DPointFloat v2; + + v1 = m_unk0x00; + v1 += m_unk0x18; + + v2 = m_unk0x00; + v2 -= m_unk0x18; + + if (v1.Dot(v1, v1) < v2.Dot(v2, v2)) { + m_unk0x18 *= -1.0f; + } + + return 0; + } + +private: + // FUNCTION: LEGO1 0x100040a0 + // FUNCTION: BETA10 0x1004ab10 + inline int FUN_100040a0(Vector4& p_v, float p_f) + { + if (m_unk0x30 == c_bit1) { + p_v = m_unk0x00; + p_v[3] = (float) ((1.0 - p_f) * acos((double) p_v[3]) * 2.0); + return p_v.NormalizeQuaternion(); + } + + if (m_unk0x30 == c_bit2) { + p_v = m_unk0x18; + p_v[3] = (float) (p_f * acos((double) p_v[3]) * 2.0); + return p_v.NormalizeQuaternion(); + } + + if (m_unk0x30 == (c_bit1 | c_bit2)) { + int i; + double d1 = p_v.Dot(m_unk0x00, m_unk0x18); + double a; + double b; + + if (d1 + 1.0 > 0.00001) { + if (1.0 - d1 > 0.00001) { + double d2 = acos(d1); + double denominator = sin(d2); + a = sin((1.0 - p_f) * d2) / denominator; + b = sin(p_f * d2) / denominator; + } + else { + a = 1.0 - p_f; + b = p_f; + } + + for (i = 0; i < 4; i++) { + p_v[i] = (float) (m_unk0x00[i] * a + m_unk0x18[i] * b); + } + } + else { + p_v[0] = -m_unk0x00[1]; + p_v[1] = m_unk0x00[0]; + p_v[2] = -m_unk0x00[3]; + p_v[3] = m_unk0x00[2]; + a = sin((1.0 - p_f) * 1.570796326794895); + b = sin(p_f * 1.570796326794895); + + for (i = 0; i < 3; i++) { + p_v[i] = (float) (m_unk0x00[i] * a + p_v[i] * b); + } + } + + return 0; + } + + return -1; + } + + Mx4DPointFloat m_unk0x00; // 0x00 + Mx4DPointFloat m_unk0x18; // 0x18 + undefined4 m_unk0x30; // 0x30 +}; + +#endif // MXGEOMETRY4D_H diff --git a/LEGO1/mxgeometry/mxmatrix.h b/LEGO1/mxgeometry/mxmatrix.h index 9f1aa59f..c9aa7620 100644 --- a/LEGO1/mxgeometry/mxmatrix.h +++ b/LEGO1/mxgeometry/mxmatrix.h @@ -1,38 +1,6 @@ #ifndef MXMATRIX_H #define MXMATRIX_H -#include "realtime/matrix.h" - -// VTABLE: LEGO1 0x100d4300 -// VTABLE: BETA10 0x101b82e0 -// SIZE 0x48 -class MxMatrix : public Matrix4 { -public: - // FUNCTION: LEGO1 0x1006b120 - // FUNCTION: BETA10 0x10015370 - MxMatrix() : Matrix4(m_elements) {} - - // FUNCTION: LEGO1 0x10032770 - // FUNCTION: BETA10 0x1001ff30 - MxMatrix(const MxMatrix& p_matrix) : Matrix4(m_elements) { Equals(p_matrix); } - - // FUNCTION: BETA10 0x1000fc20 - MxMatrix(const Matrix4& p_matrix) : Matrix4(m_elements) { Equals(p_matrix); } - - // FUNCTION: BETA10 0x10010860 - float* operator[](int idx) { return m_data[idx]; } - - // FUNCTION: BETA10 0x1001c670 - const float* operator[](int idx) const { return m_data[idx]; } - - // FUNCTION: LEGO1 0x10002850 - void operator=(const Matrix4& p_matrix) override { Equals(p_matrix); } // vtable+0x28 - - // FUNCTION: LEGO1 0x10002860 - virtual void operator=(const MxMatrix& p_matrix) { Equals(p_matrix); } // vtable+0x48 - -private: - float m_elements[4][4]; // 0x08 -}; +#include "realtime/vector.h" #endif // MXMATRIX_H diff --git a/LEGO1/realtime/matrix.h b/LEGO1/realtime/matrix.h index 8704d739..32295113 100644 --- a/LEGO1/realtime/matrix.h +++ b/LEGO1/realtime/matrix.h @@ -3,358 +3,7 @@ #include "vector.h" -#include - -struct UnknownMatrixType { - float m_data[4][4]; -}; - // Note: Many functions most likely take const references/pointers instead of non-const. // The class needs to undergo a very careful refactoring to fix that (no matches should break). -// VTABLE: LEGO1 0x100d4350 -// VTABLE: BETA10 0x101b8340 -// SIZE 0x08 -class Matrix4 { -public: - // FUNCTION: LEGO1 0x10004500 - // FUNCTION: BETA10 0x1000fc70 - Matrix4(float (*p_data)[4]) { SetData(p_data); } - - // Note: virtual function overloads appear in the virtual table - // in reverse order of appearance. - - // FUNCTION: LEGO1 0x10002320 - // FUNCTION: BETA10 0x1000fcb0 - virtual void Equals(float (*p_data)[4]) { memcpy(m_data, p_data, sizeof(float) * 4 * 4); } // vtable+0x04 - - // FUNCTION: LEGO1 0x10002340 - // FUNCTION: BETA10 0x1000fcf0 - virtual void Equals(const Matrix4& p_matrix) - { - memcpy(m_data, p_matrix.m_data, sizeof(float) * 4 * 4); - } // vtable+0x00 - - // FUNCTION: LEGO1 0x10002360 - // FUNCTION: BETA10 0x1000fd30 - virtual void SetData(float (*p_data)[4]) { m_data = p_data; } // vtable+0x0c - - // FUNCTION: LEGO1 0x10002370 - // FUNCTION: BETA10 0x1000fd60 - virtual void SetData(UnknownMatrixType& p_matrix) { m_data = p_matrix.m_data; } // vtable+0x08 - - // FUNCTION: LEGO1 0x10002380 - // FUNCTION: BETA10 0x1000fd90 - virtual float (*GetData())[4] { return m_data; } // vtable+0x14 - - // FUNCTION: LEGO1 0x10002390 - // FUNCTION: BETA10 0x1000fdc0 - virtual float (*GetData() const)[4] { return m_data; } // vtable+0x10 - - // FUNCTION: LEGO1 0x100023a0 - // FUNCTION: BETA10 0x1000fdf0 - virtual float* Element(int p_row, int p_col) { return &m_data[p_row][p_col]; } // vtable+0x1c - - // FUNCTION: LEGO1 0x100023c0 - // FUNCTION: BETA10 0x1000fe30 - virtual const float* Element(int p_row, int p_col) const { return &m_data[p_row][p_col]; } // vtable+0x18 - - // FUNCTION: LEGO1 0x100023e0 - // FUNCTION: BETA10 0x1000fe70 - virtual void Clear() { memset(m_data, 0, 16 * sizeof(float)); } // vtable+0x20 - - // FUNCTION: LEGO1 0x100023f0 - // FUNCTION: BETA10 0x1000feb0 - virtual void SetIdentity() - { - Clear(); - m_data[0][0] = 1.0f; - m_data[1][1] = 1.0f; - m_data[2][2] = 1.0f; - m_data[3][3] = 1.0f; - } // vtable+0x24 - - // FUNCTION: LEGO1 0x10002420 - // FUNCTION: BETA10 0x1000ff20 - virtual void operator=(const Matrix4& p_matrix) { Equals(p_matrix); } // vtable+0x28 - - // FUNCTION: LEGO1 0x10002430 - // FUNCTION: BETA10 0x1000ff50 - virtual Matrix4& operator+=(float (*p_data)[4]) - { - for (int i = 0; i < 16; i++) { - ((float*) m_data)[i] += ((float*) p_data)[i]; - } - return *this; - } // vtable+0x2c - - // FUNCTION: LEGO1 0x10002460 - // FUNCTION: BETA10 0x1000ffc0 - virtual void TranslateBy(const float& p_x, const float& p_y, const float& p_z) - { - m_data[3][0] += p_x; - m_data[3][1] += p_y; - m_data[3][2] += p_z; - } // vtable+0x30 - - // FUNCTION: LEGO1 0x100024a0 - // FUNCTION: BETA10 0x10010040 - virtual void SetTranslation(const float& p_x, const float& p_y, const float& p_z) - { - m_data[3][0] = p_x; - m_data[3][1] = p_y; - m_data[3][2] = p_z; - } // vtable+0x34 - - // FUNCTION: LEGO1 0x100024d0 - // FUNCTION: BETA10 0x100100a0 - virtual void Product(float (*p_a)[4], float (*p_b)[4]) - { - float* cur = (float*) m_data; - for (int row = 0; row < 4; row++) { - for (int col = 0; col < 4; col++) { - *cur = 0.0f; - for (int k = 0; k < 4; k++) { - *cur += p_a[row][k] * p_b[k][col]; - } - cur++; - } - } - } // vtable+0x3c - - // FUNCTION: LEGO1 0x10002530 - // FUNCTION: BETA10 0x10010180 - virtual void Product(const Matrix4& p_a, const Matrix4& p_b) { Product(p_a.m_data, p_b.m_data); } // vtable+0x38 - - inline virtual void ToQuaternion(Vector4& p_resultQuat); // vtable+0x40 - inline virtual int FromQuaternion(const Vector4& p_vec); // vtable+0x44 - - // FUNCTION: LEGO1 0x100a0ff0 - // FUNCTION: BETA10 0x1001fe60 - void Scale(const float& p_x, const float& p_y, const float& p_z) - { - for (int i = 0; i < 4; i++) { - m_data[i][0] *= p_x; - m_data[i][1] *= p_y; - m_data[i][2] *= p_z; - } - } - - // FUNCTION: BETA10 0x1001c6a0 - void RotateX(const float& p_angle) - { - float s = sin(p_angle); - float c = cos(p_angle); - float matrix[4][4]; - memcpy(matrix, m_data, sizeof(float) * 16); - for (int i = 0; i < 4; i++) { - m_data[i][1] = matrix[i][1] * c - matrix[i][2] * s; - m_data[i][2] = matrix[i][2] * c + matrix[i][1] * s; - } - } - - // FUNCTION: BETA10 0x1001fd60 - void RotateY(const float& p_angle) - { - float s = sin(p_angle); - float c = cos(p_angle); - float matrix[4][4]; - memcpy(matrix, m_data, sizeof(float) * 16); - for (int i = 0; i < 4; i++) { - m_data[i][0] = matrix[i][0] * c + matrix[i][2] * s; - m_data[i][2] = matrix[i][2] * c - matrix[i][0] * s; - } - } - - // FUNCTION: BETA10 0x1006ab10 - void RotateZ(const float& p_angle) - { - float s = sin(p_angle); - float c = cos(p_angle); - float matrix[4][4]; - memcpy(matrix, m_data, sizeof(float) * 16); - for (int i = 0; i < 4; i++) { - m_data[i][0] = matrix[i][0] * c - matrix[i][1] * s; - m_data[i][1] = matrix[i][1] * c + matrix[i][0] * s; - } - } - - inline int BETA_1005a590(Matrix4& p_mat); - - // FUNCTION: LEGO1 0x1006b500 - void Swap(int p_d1, int p_d2) - { - for (int i = 0; i < 4; i++) { - float e = m_data[p_d1][i]; - m_data[p_d1][i] = m_data[p_d2][i]; - m_data[p_d2][i] = e; - } - } - - float* operator[](int idx) { return m_data[idx]; } - const float* operator[](int idx) const { return m_data[idx]; } - -protected: - float (*m_data)[4]; -}; - -// FUNCTION: LEGO1 0x10002550 -// FUNCTION: BETA10 0x100101c0 -inline void Matrix4::ToQuaternion(Vector4& p_outQuat) -{ - float trace; - float localc = m_data[0][0] + m_data[1][1] + m_data[2][2]; - - if (localc > 0) { - trace = (float) sqrt(localc + 1.0); - p_outQuat[3] = trace * 0.5f; - trace = 0.5f / trace; - p_outQuat[0] = (m_data[2][1] - m_data[1][2]) * trace; - p_outQuat[1] = (m_data[0][2] - m_data[2][0]) * trace; - p_outQuat[2] = (m_data[1][0] - m_data[0][1]) * trace; - } - else { - // GLOBAL: LEGO1 0x100d4090 - static int rotateIndex[] = {1, 2, 0}; - - // Largest element along the trace - int largest = 0; - if (m_data[0][0] < m_data[1][1]) { - largest = 1; - } - if (*Element(largest, largest) < m_data[2][2]) { - largest = 2; - } - - int next = rotateIndex[largest]; - int nextNext = rotateIndex[next]; - - trace = (float) sqrt(*Element(largest, largest) - (*Element(nextNext, nextNext) + *Element(next, next)) + 1.0); - - p_outQuat[largest] = trace * 0.5f; - trace = 0.5f / trace; - - p_outQuat[3] = (*Element(nextNext, next) - *Element(next, nextNext)) * trace; - p_outQuat[next] = (*Element(largest, next) + *Element(next, largest)) * trace; - p_outQuat[nextNext] = (*Element(largest, nextNext) + *Element(nextNext, largest)) * trace; - } -} - -// FUNCTION: LEGO1 0x10002710 -// FUNCTION: BETA10 0x10010550 -inline int Matrix4::FromQuaternion(const Vector4& p_vec) -{ - float local14 = p_vec.LenSquared(); - - if (local14 > 0.0f) { - local14 = 2.0f / local14; - - float local24 = p_vec[0] * local14; - float local34 = p_vec[1] * local14; - float local10 = p_vec[2] * local14; - - float local28 = p_vec[3] * local24; - float local2c = p_vec[3] * local34; - float local30 = p_vec[3] * local10; - - float local38 = p_vec[0] * local24; - float local8 = p_vec[0] * local34; - float localc = p_vec[0] * local10; - - float local18 = p_vec[1] * local34; - float local1c = p_vec[1] * local10; - float local20 = p_vec[2] * local10; - - m_data[0][0] = 1.0f - (local18 + local20); - m_data[1][0] = local8 + local30; - m_data[2][0] = localc - local2c; - - m_data[0][1] = local8 - local30; - m_data[1][1] = 1.0f - (local38 + local20); - m_data[2][1] = local1c + local28; - - m_data[0][2] = local2c + localc; - m_data[1][2] = local1c - local28; - m_data[2][2] = 1.0f - (local18 + local38); - - m_data[3][0] = 0.0f; - m_data[3][1] = 0.0f; - m_data[3][2] = 0.0f; - m_data[3][3] = 1.0f; - - m_data[0][3] = 0.0f; - m_data[1][3] = 0.0f; - m_data[2][3] = 0.0f; - return 0; - } - else { - return -1; - } -} - -// FUNCTION: BETA10 0x1005a590 -inline int Matrix4::BETA_1005a590(Matrix4& p_mat) -{ - float local5c[4][4]; - Matrix4 localc(local5c); - - ((Matrix4&) localc) = *this; - p_mat.SetIdentity(); - - for (int i = 0; i < 4; i++) { - int local1c = i; - int local10; - - for (local10 = i + 1; local10 < 4; local10++) { - if (fabs(localc[local1c][i]) < fabs(localc[local10][i])) { - local1c = local10; - } - } - - if (local1c != i) { - localc.Swap(local1c, i); - p_mat.Swap(local1c, i); - } - - if (localc[i][i] < 0.001f && localc[i][i] > -0.001f) { - return -1; - } - - float local60 = localc[i][i]; - int local18; - - for (local18 = 0; local18 < 4; local18++) { - p_mat[i][local18] /= local60; - } - - for (local18 = 0; local18 < 4; local18++) { - localc[i][local18] /= local60; - } - - for (local10 = 0; local10 < 4; local10++) { - if (i != local10) { - float afStack70[4]; - - for (local18 = 0; local18 < 4; local18++) { - afStack70[local18] = p_mat[i][local18] * localc[local10][i]; - } - - for (local18 = 0; local18 < 4; local18++) { - p_mat[local10][local18] -= afStack70[local18]; - } - - for (local18 = 0; local18 < 4; local18++) { - afStack70[local18] = localc[i][local18] * localc[local10][i]; - } - - for (local18 = 0; local18 < 4; local18++) { - localc[local10][local18] -= afStack70[local18]; - } - } - } - } - - return 0; -} - #endif // MATRIX_H diff --git a/LEGO1/realtime/vector.h b/LEGO1/realtime/vector.h index e3e71476..0cbe48ca 100644 --- a/LEGO1/realtime/vector.h +++ b/LEGO1/realtime/vector.h @@ -236,14 +236,6 @@ class Vector3 : public Vector2 { // FUNCTION: LEGO1 0x10002300 virtual void EqualsCross(const float* p_a, const Vector3& p_b) { EqualsCrossImpl(p_a, p_b.m_data); } // vtable+0x78 - // FUNCTION: LEGO1 0x10003bf0 - virtual void Fill(const float& p_value) - { - m_data[0] = p_value; - m_data[1] = p_value; - m_data[2] = p_value; - } // vtable+0x84 - // Vector2 overrides // FUNCTION: LEGO1 0x10003a60 @@ -315,9 +307,333 @@ class Vector3 : public Vector2 { return m_data[0] * m_data[0] + m_data[1] * m_data[1] + m_data[2] * m_data[2]; } // vtable+0x40 + // FUNCTION: LEGO1 0x10003bf0 + virtual void Fill(const float& p_value) + { + m_data[0] = p_value; + m_data[1] = p_value; + m_data[2] = p_value; + } // vtable+0x84 + friend class Mx3DPointFloat; }; +struct UnknownMatrixType { + float m_data[4][4]; +}; + +// VTABLE: LEGO1 0x100d4350 +// VTABLE: BETA10 0x101b8340 +// SIZE 0x08 +class Matrix4 { +public: + // FUNCTION: LEGO1 0x10004500 + // FUNCTION: BETA10 0x1000fc70 + Matrix4(float (*p_data)[4]) { SetData(p_data); } + + // Note: virtual function overloads appear in the virtual table + // in reverse order of appearance. + + // FUNCTION: LEGO1 0x10002320 + // FUNCTION: BETA10 0x1000fcb0 + virtual void Equals(float (*p_data)[4]) { memcpy(m_data, p_data, sizeof(float) * 4 * 4); } // vtable+0x04 + + // FUNCTION: LEGO1 0x10002340 + // FUNCTION: BETA10 0x1000fcf0 + virtual void Equals(const Matrix4& p_matrix) + { + memcpy(m_data, p_matrix.m_data, sizeof(float) * 4 * 4); + } // vtable+0x00 + + // FUNCTION: LEGO1 0x10002360 + // FUNCTION: BETA10 0x1000fd30 + virtual void SetData(float (*p_data)[4]) { m_data = p_data; } // vtable+0x0c + + // FUNCTION: LEGO1 0x10002370 + // FUNCTION: BETA10 0x1000fd60 + virtual void SetData(UnknownMatrixType& p_matrix) { m_data = p_matrix.m_data; } // vtable+0x08 + + // FUNCTION: LEGO1 0x10002380 + // FUNCTION: BETA10 0x1000fd90 + virtual float (*GetData())[4] { return m_data; } // vtable+0x14 + + // FUNCTION: LEGO1 0x10002390 + // FUNCTION: BETA10 0x1000fdc0 + virtual float (*GetData() const)[4] { return m_data; } // vtable+0x10 + + // FUNCTION: LEGO1 0x100023a0 + // FUNCTION: BETA10 0x1000fdf0 + virtual float* Element(int p_row, int p_col) { return &m_data[p_row][p_col]; } // vtable+0x1c + + // FUNCTION: LEGO1 0x100023c0 + // FUNCTION: BETA10 0x1000fe30 + virtual const float* Element(int p_row, int p_col) const { return &m_data[p_row][p_col]; } // vtable+0x18 + + // FUNCTION: LEGO1 0x100023e0 + // FUNCTION: BETA10 0x1000fe70 + virtual void Clear() { memset(m_data, 0, 16 * sizeof(float)); } // vtable+0x20 + + // FUNCTION: LEGO1 0x100023f0 + // FUNCTION: BETA10 0x1000feb0 + virtual void SetIdentity() + { + Clear(); + m_data[0][0] = 1.0f; + m_data[1][1] = 1.0f; + m_data[2][2] = 1.0f; + m_data[3][3] = 1.0f; + } // vtable+0x24 + + // FUNCTION: LEGO1 0x10002420 + // FUNCTION: BETA10 0x1000ff20 + virtual void operator=(const Matrix4& p_matrix) { Equals(p_matrix); } // vtable+0x28 + + // FUNCTION: LEGO1 0x10002430 + // FUNCTION: BETA10 0x1000ff50 + virtual Matrix4& operator+=(float (*p_data)[4]) + { + for (int i = 0; i < 16; i++) { + ((float*) m_data)[i] += ((float*) p_data)[i]; + } + return *this; + } // vtable+0x2c + + // FUNCTION: LEGO1 0x10002460 + // FUNCTION: BETA10 0x1000ffc0 + virtual void TranslateBy(const float& p_x, const float& p_y, const float& p_z) + { + m_data[3][0] += p_x; + m_data[3][1] += p_y; + m_data[3][2] += p_z; + } // vtable+0x30 + + // FUNCTION: LEGO1 0x100024a0 + // FUNCTION: BETA10 0x10010040 + virtual void SetTranslation(const float& p_x, const float& p_y, const float& p_z) + { + m_data[3][0] = p_x; + m_data[3][1] = p_y; + m_data[3][2] = p_z; + } // vtable+0x34 + + // FUNCTION: LEGO1 0x100024d0 + // FUNCTION: BETA10 0x100100a0 + virtual void Product(float (*p_a)[4], float (*p_b)[4]) + { + float* cur = (float*) m_data; + for (int row = 0; row < 4; row++) { + for (int col = 0; col < 4; col++) { + *cur = 0.0f; + for (int k = 0; k < 4; k++) { + *cur += p_a[row][k] * p_b[k][col]; + } + cur++; + } + } + } // vtable+0x3c + + // FUNCTION: LEGO1 0x10002530 + // FUNCTION: BETA10 0x10010180 + virtual void Product(const Matrix4& p_a, const Matrix4& p_b) { Product(p_a.m_data, p_b.m_data); } // vtable+0x38 + + inline virtual void ToQuaternion(Vector3& p_resultQuat); // vtable+0x40 + inline virtual int FromQuaternion(const Vector3& p_vec); // vtable+0x44 + + // FUNCTION: LEGO1 0x100a0ff0 + // FUNCTION: BETA10 0x1001fe60 + void Scale(const float& p_x, const float& p_y, const float& p_z) + { + for (int i = 0; i < 4; i++) { + m_data[i][0] *= p_x; + m_data[i][1] *= p_y; + m_data[i][2] *= p_z; + } + } + + // FUNCTION: BETA10 0x1001c6a0 + void RotateX(const float& p_angle) + { + float s = sin(p_angle); + float c = cos(p_angle); + float matrix[4][4]; + memcpy(matrix, m_data, sizeof(float) * 16); + for (int i = 0; i < 4; i++) { + m_data[i][1] = matrix[i][1] * c - matrix[i][2] * s; + m_data[i][2] = matrix[i][2] * c + matrix[i][1] * s; + } + } + + // FUNCTION: BETA10 0x1001fd60 + void RotateY(const float& p_angle) + { + float s = sin(p_angle); + float c = cos(p_angle); + float matrix[4][4]; + memcpy(matrix, m_data, sizeof(float) * 16); + for (int i = 0; i < 4; i++) { + m_data[i][0] = matrix[i][0] * c + matrix[i][2] * s; + m_data[i][2] = matrix[i][2] * c - matrix[i][0] * s; + } + } + + // FUNCTION: BETA10 0x1006ab10 + void RotateZ(const float& p_angle) + { + float s = sin(p_angle); + float c = cos(p_angle); + float matrix[4][4]; + memcpy(matrix, m_data, sizeof(float) * 16); + for (int i = 0; i < 4; i++) { + m_data[i][0] = matrix[i][0] * c - matrix[i][1] * s; + m_data[i][1] = matrix[i][1] * c + matrix[i][0] * s; + } + } + + inline int BETA_1005a590(Matrix4& p_mat); + + // FUNCTION: LEGO1 0x1006b500 + void Swap(int p_d1, int p_d2) + { + for (int i = 0; i < 4; i++) { + float e = m_data[p_d1][i]; + m_data[p_d1][i] = m_data[p_d2][i]; + m_data[p_d2][i] = e; + } + } + + float* operator[](int idx) { return m_data[idx]; } + const float* operator[](int idx) const { return m_data[idx]; } + +protected: + float (*m_data)[4]; +}; + +// FUNCTION: LEGO1 0x10002550 +// FUNCTION: BETA10 0x100101c0 +inline void Matrix4::ToQuaternion(Vector3& p_outQuat) +{ + float trace; + float localc = m_data[0][0] + m_data[1][1] + m_data[2][2]; + + if (localc > 0) { + trace = (float) sqrt(localc + 1.0); + p_outQuat[3] = trace * 0.5f; + trace = 0.5f / trace; + p_outQuat[0] = (m_data[2][1] - m_data[1][2]) * trace; + p_outQuat[1] = (m_data[0][2] - m_data[2][0]) * trace; + p_outQuat[2] = (m_data[1][0] - m_data[0][1]) * trace; + } + else { + // GLOBAL: LEGO1 0x100d4090 + static int rotateIndex[] = {1, 2, 0}; + + // Largest element along the trace + int largest = 0; + if (m_data[0][0] < m_data[1][1]) { + largest = 1; + } + if (*Element(largest, largest) < m_data[2][2]) { + largest = 2; + } + + int next = rotateIndex[largest]; + int nextNext = rotateIndex[next]; + + trace = (float) sqrt(*Element(largest, largest) - (*Element(nextNext, nextNext) + *Element(next, next)) + 1.0); + + p_outQuat[largest] = trace * 0.5f; + trace = 0.5f / trace; + + p_outQuat[3] = (*Element(nextNext, next) - *Element(next, nextNext)) * trace; + p_outQuat[next] = (*Element(largest, next) + *Element(next, largest)) * trace; + p_outQuat[nextNext] = (*Element(largest, nextNext) + *Element(nextNext, largest)) * trace; + } +} + +// FUNCTION: LEGO1 0x10002710 +// FUNCTION: BETA10 0x10010550 +inline int Matrix4::FromQuaternion(const Vector3& p_vec) +{ + float local14 = p_vec.LenSquared(); + + if (local14 > 0.0f) { + local14 = 2.0f / local14; + + float local24 = p_vec[0] * local14; + float local34 = p_vec[1] * local14; + float local10 = p_vec[2] * local14; + + float local28 = p_vec[3] * local24; + float local2c = p_vec[3] * local34; + float local30 = p_vec[3] * local10; + + float local38 = p_vec[0] * local24; + float local8 = p_vec[0] * local34; + float localc = p_vec[0] * local10; + + float local18 = p_vec[1] * local34; + float local1c = p_vec[1] * local10; + float local20 = p_vec[2] * local10; + + m_data[0][0] = 1.0f - (local18 + local20); + m_data[1][0] = local8 + local30; + m_data[2][0] = localc - local2c; + + m_data[0][1] = local8 - local30; + m_data[1][1] = 1.0f - (local38 + local20); + m_data[2][1] = local1c + local28; + + m_data[0][2] = local2c + localc; + m_data[1][2] = local1c - local28; + m_data[2][2] = 1.0f - (local18 + local38); + + m_data[3][0] = 0.0f; + m_data[3][1] = 0.0f; + m_data[3][2] = 0.0f; + m_data[3][3] = 1.0f; + + m_data[0][3] = 0.0f; + m_data[1][3] = 0.0f; + m_data[2][3] = 0.0f; + return 0; + } + else { + return -1; + } +} + +// VTABLE: LEGO1 0x100d4300 +// VTABLE: BETA10 0x101b82e0 +// SIZE 0x48 +class MxMatrix : public Matrix4 { +public: + // FUNCTION: LEGO1 0x1006b120 + // FUNCTION: BETA10 0x10015370 + MxMatrix() : Matrix4(m_elements) {} + + // FUNCTION: LEGO1 0x10032770 + // FUNCTION: BETA10 0x1001ff30 + MxMatrix(const MxMatrix& p_matrix) : Matrix4(m_elements) { Equals(p_matrix); } + + // FUNCTION: BETA10 0x1000fc20 + MxMatrix(const Matrix4& p_matrix) : Matrix4(m_elements) { Equals(p_matrix); } + + // FUNCTION: BETA10 0x10010860 + float* operator[](int idx) { return m_data[idx]; } + + // FUNCTION: BETA10 0x1001c670 + const float* operator[](int idx) const { return m_data[idx]; } + + // FUNCTION: LEGO1 0x10002850 + void operator=(const Matrix4& p_matrix) override { Equals(p_matrix); } // vtable+0x28 + + // FUNCTION: LEGO1 0x10002860 + virtual void operator=(const MxMatrix& p_matrix) { Equals(p_matrix); } // vtable+0x48 + +private: + float m_elements[4][4]; // 0x08 +}; + // VTABLE: LEGO1 0x100d45a0 // VTABLE: BETA10 0x101bac38 // SIZE 0x08 @@ -339,24 +655,6 @@ class Vector4 : public Vector3 { // Note: virtual function overloads appear in the virtual table // in reverse order of appearance. - // FUNCTION: LEGO1 0x10002a40 - virtual void SetMatrixProduct(const float* p_vec, const float* p_mat) - { - m_data[0] = p_vec[0] * p_mat[0] + p_vec[1] * p_mat[4] + p_vec[2] * p_mat[8] + p_vec[3] * p_mat[12]; - m_data[1] = p_vec[0] * p_mat[1] + p_vec[1] * p_mat[5] + p_vec[2] * p_mat[9] + p_vec[4] * p_mat[13]; - m_data[2] = p_vec[0] * p_mat[2] + p_vec[1] * p_mat[6] + p_vec[2] * p_mat[10] + p_vec[4] * p_mat[14]; - m_data[3] = p_vec[0] * p_mat[3] + p_vec[1] * p_mat[7] + p_vec[2] * p_mat[11] + p_vec[4] * p_mat[15]; - } // vtable+0x8c - - // FUNCTION: LEGO1 0x10002ae0 - virtual void SetMatrixProduct(const Vector4& p_a, const float* p_b) - { - SetMatrixProduct(p_a.m_data, p_b); - } // vtable+0x88 - - inline virtual int NormalizeQuaternion(); // vtable+0x90 - inline virtual int EqualsHamiltonProduct(const Vector4& p_a, const Vector4& p_b); // vtable+0x94 - // Vector3 overrides // FUNCTION: LEGO1 0x10002870 @@ -422,6 +720,24 @@ class Vector4 : public Vector3 { // FUNCTION: LEGO1 0x10002a20 void EqualsImpl(const float* p_data) override { memcpy(m_data, p_data, sizeof(float) * 4); } // vtable+0x20 + // FUNCTION: LEGO1 0x10002a40 + virtual void SetMatrixProduct(const float* p_vec, const float* p_mat) + { + m_data[0] = p_vec[0] * p_mat[0] + p_vec[1] * p_mat[4] + p_vec[2] * p_mat[8] + p_vec[3] * p_mat[12]; + m_data[1] = p_vec[0] * p_mat[1] + p_vec[1] * p_mat[5] + p_vec[2] * p_mat[9] + p_vec[4] * p_mat[13]; + m_data[2] = p_vec[0] * p_mat[2] + p_vec[1] * p_mat[6] + p_vec[2] * p_mat[10] + p_vec[4] * p_mat[14]; + m_data[3] = p_vec[0] * p_mat[3] + p_vec[1] * p_mat[7] + p_vec[2] * p_mat[11] + p_vec[4] * p_mat[15]; + } // vtable+0x8c + + // FUNCTION: LEGO1 0x10002ae0 + virtual void SetMatrixProduct(const Vector4& p_a, const float* p_b) + { + SetMatrixProduct(p_a.m_data, p_b); + } // vtable+0x88 + + inline virtual int NormalizeQuaternion(); // vtable+0x90 + inline virtual int EqualsHamiltonProduct(const Vector4& p_a, const Vector4& p_b); // vtable+0x94 + // FUNCTION: LEGO1 0x10002b00 void Clear() override { memset(m_data, 0, sizeof(float) * 4); } // vtable+0x2c @@ -448,6 +764,71 @@ class Vector4 : public Vector3 { friend class Mx4DPointFloat; }; +// FUNCTION: BETA10 0x1005a590 +inline int Matrix4::BETA_1005a590(Matrix4& p_mat) +{ + float local5c[4][4]; + Matrix4 localc(local5c); + + ((Matrix4&) localc) = *this; + p_mat.SetIdentity(); + + for (int i = 0; i < 4; i++) { + int local1c = i; + int local10; + + for (local10 = i + 1; local10 < 4; local10++) { + if (fabs(localc[local1c][i]) < fabs(localc[local10][i])) { + local1c = local10; + } + } + + if (local1c != i) { + localc.Swap(local1c, i); + p_mat.Swap(local1c, i); + } + + if (localc[i][i] < 0.001f && localc[i][i] > -0.001f) { + return -1; + } + + float local60 = localc[i][i]; + int local18; + + for (local18 = 0; local18 < 4; local18++) { + p_mat[i][local18] /= local60; + } + + for (local18 = 0; local18 < 4; local18++) { + localc[i][local18] /= local60; + } + + for (local10 = 0; local10 < 4; local10++) { + if (i != local10) { + float afStack70[4]; + + for (local18 = 0; local18 < 4; local18++) { + afStack70[local18] = p_mat[i][local18] * localc[local10][i]; + } + + for (local18 = 0; local18 < 4; local18++) { + p_mat[local10][local18] -= afStack70[local18]; + } + + for (local18 = 0; local18 < 4; local18++) { + afStack70[local18] = localc[i][local18] * localc[local10][i]; + } + + for (local18 = 0; local18 < 4; local18++) { + localc[local10][local18] -= afStack70[local18]; + } + } + } + } + + return 0; +} + // FUNCTION: LEGO1 0x10002b70 // FUNCTION: BETA10 0x10048ad0 inline int Vector4::NormalizeQuaternion()