isledecomp/isle
1
0
Fork 0
mirror of https://github.com/isledecomp/isle.git synced 2026-01-21 07:11:16 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Order experimentation

Browse Source
This commit is contained in:
Christian Semmler 2024-12-31 11:03:37 -07:00
parent 70e72de20f
commit e1a1aea32f
11 changed files with 634 additions and 629 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
LEGO1/lego/legoomni/include/helicopter.h
View File

@ -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

37
LEGO1/lego/legoomni/include/islepathactor.h
View File

@ -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

1
LEGO1/lego/legoomni/include/legoanimationmanager.h
View File

@ -8,6 +8,7 @@
#include "legotraninfolist.h"
#include "mxcore.h"
#include "mxgeometry/mxgeometry3d.h"
#include "mxgeometry/mxgeometry4d.h"
class LegoAnimPresenter;
class LegoEntity;

1
LEGO1/lego/sources/anim/legoanim.cpp
View File

@ -1,5 +1,6 @@
#include "legoanim.h"
#include "mxgeometry/mxgeometry4d.h"
#include "mxgeometry/mxmatrix.h"
#include <limits.h>

1
LEGO1/lego/sources/geom/legowegedge.h
View File

@ -4,6 +4,7 @@
#include "decomp.h"
#include "legoweedge.h"
#include "mxgeometry/mxgeometry3d.h"
#include "mxgeometry/mxgeometry4d.h"
class LegoPathStruct;

1
LEGO1/lego/sources/roi/legoroi.cpp
View File

@ -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"

195
LEGO1/mxgeometry/mxgeometry3d.h
View File

@ -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

197
LEGO1/mxgeometry/mxgeometry4d.h Normal file
View File

@ -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

34
LEGO1/mxgeometry/mxmatrix.h
View File

@ -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

351
LEGO1/realtime/matrix.h
View File

@ -3,358 +3,7 @@
#include "vector.h"
#include <memory.h>
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

433
LEGO1/realtime/vector.h
View File

@ -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()