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

WIP

Browse Source
This commit is contained in:
Christian Semmler 2025-01-03 10:10:56 -07:00
parent f82253d689
commit c27243d991
3 changed files with 493 additions and 349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

464
LEGO1/realtime/vector.h
View File

@ -6,6 +6,9 @@
#include <math.h> #include <math.h>
#include <memory.h> #include <memory.h>
// Note: virtual function overloads appear in the virtual table
// in reverse order of appearance.
// VTABLE: LEGO1 0x100d4288 // VTABLE: LEGO1 0x100d4288
// VTABLE: BETA10 0x101b8440 // VTABLE: BETA10 0x101b8440
// SIZE 0x08 // SIZE 0x08
@ -15,142 +18,38 @@ class Vector2 {
// FUNCTION: BETA10 0x100116a0 // FUNCTION: BETA10 0x100116a0
Vector2(float* p_data) { SetData(p_data); } Vector2(float* p_data) { SetData(p_data); }
// Note: virtual function overloads appear in the virtual table protected:
// in reverse order of appearance. inline virtual void AddImpl(const float* p_value); // vtable+0x04
inline virtual void AddImpl(float p_value); // vtable+0x00
inline virtual void SubImpl(const float* p_value); // vtable+0x08
inline virtual void MulImpl(const float* p_value); // vtable+0x10
inline virtual void MulImpl(const float& p_value); // vtable+0x0c
inline virtual void DivImpl(const float& p_value); // vtable+0x14
inline virtual float DotImpl(const float* p_a, const float* p_b) const; // vtable+0x18
inline virtual void SetData(float* p_data); // vtable+0x1c
inline virtual void EqualsImpl(const float* p_data); // vtable+0x20
// FUNCTION: LEGO1 0x10001f80 public:
virtual void AddImpl(const float* p_value) inline virtual float* GetData(); // vtable+0x28
{ inline virtual const float* GetData() const; // vtable+0x24
m_data[0] += p_value[0]; inline virtual void Clear(); // vtable+0x2c
m_data[1] += p_value[1]; inline virtual float Dot(const float* p_a, const float* p_b) const; // vtable+0x3c
} // vtable+0x04 inline virtual float Dot(const Vector2& p_a, const Vector2& p_b) const; // vtable+0x38
inline virtual float Dot(const float* p_a, const Vector2& p_b) const; // vtable+0x34
// FUNCTION: LEGO1 0x10001fa0 inline virtual float Dot(const Vector2& p_a, const float* p_b) const; // vtable+0x30
virtual void AddImpl(float p_value) inline virtual float LenSquared() const; // vtable+0x40
{ inline virtual int Unitize(); // vtable+0x44
m_data[0] += p_value; inline virtual void operator+=(float p_value); // vtable+0x50
m_data[1] += p_value; inline virtual void operator+=(const float* p_other); // vtable+0x4c
} // vtable+0x00 inline virtual void operator+=(const Vector2& p_other); // vtable+0x48
inline virtual void operator-=(const float* p_other); // vtable+0x58
// FUNCTION: LEGO1 0x10001fc0 inline virtual void operator-=(const Vector2& p_other); // vtable+0x54
virtual void SubImpl(const float* p_value) inline virtual void operator*=(const float* p_other); // vtable+0x64
{ inline virtual void operator*=(const Vector2& p_other); // vtable+0x60
m_data[0] -= p_value[0]; inline virtual void operator*=(const float& p_value); // vtable+0x5c
m_data[1] -= p_value[1]; inline virtual void operator/=(const float& p_value); // vtable+0x68
} // vtable+0x08 inline virtual void SetVector(const float* p_other); // vtable+0x70
inline virtual void SetVector(const Vector2& p_other); // vtable+0x6c
// FUNCTION: LEGO1 0x10001fe0
virtual void MulImpl(const float* p_value)
{
m_data[0] *= p_value[0];
m_data[1] *= p_value[1];
} // vtable+0x10
// FUNCTION: LEGO1 0x10002000
virtual void MulImpl(const float& p_value)
{
m_data[0] *= p_value;
m_data[1] *= p_value;
} // vtable+0x0c
// FUNCTION: LEGO1 0x10002020
virtual void DivImpl(const float& p_value)
{
m_data[0] /= p_value;
m_data[1] /= p_value;
} // vtable+0x14
// FUNCTION: LEGO1 0x10002040
virtual float DotImpl(const float* p_a, const float* p_b) const
{
return p_b[0] * p_a[0] + p_b[1] * p_a[1];
} // vtable+0x18
// FUNCTION: LEGO1 0x10002060
// FUNCTION: BETA10 0x10010c90
virtual void SetData(float* p_data) { m_data = p_data; } // vtable+0x1c
// FUNCTION: LEGO1 0x10002070
virtual void EqualsImpl(const float* p_data) { memcpy(m_data, p_data, sizeof(float) * 2); } // vtable+0x20
// FUNCTION: LEGO1 0x10002090
virtual float* GetData() { return m_data; } // vtable+0x28
// FUNCTION: LEGO1 0x100020a0
virtual const float* GetData() const { return m_data; } // vtable+0x24
// FUNCTION: LEGO1 0x100020b0
virtual void Clear() { memset(m_data, 0, sizeof(float) * 2); } // vtable+0x2c
// FUNCTION: LEGO1 0x100020d0
virtual float Dot(const float* p_a, const float* p_b) const { return DotImpl(p_a, p_b); } // vtable+0x3c
// FUNCTION: LEGO1 0x100020f0
// FUNCTION: BETA10 0x100108c0
virtual float Dot(const Vector2& p_a, const Vector2& p_b) const
{
return DotImpl(p_a.m_data, p_b.m_data);
} // vtable+0x38
// FUNCTION: LEGO1 0x10002110
virtual float Dot(const float* p_a, const Vector2& p_b) const { return DotImpl(p_a, p_b.m_data); } // vtable+0x34
// FUNCTION: LEGO1 0x10002130
virtual float Dot(const Vector2& p_a, const float* p_b) const { return DotImpl(p_a.m_data, p_b); } // vtable+0x30
// FUNCTION: LEGO1 0x10002150
virtual float LenSquared() const { return m_data[0] * m_data[0] + m_data[1] * m_data[1]; } // vtable+0x40
// FUNCTION: LEGO1 0x10002160
// FUNCTION: BETA10 0x10010900
virtual int Unitize()
{
float sq = LenSquared();
if (sq > 0.0f) {
float root = sqrt(sq);
if (root > 0.0f) {
DivImpl(root);
return 0;
}
}
return -1;
} // vtable+0x44
// FUNCTION: LEGO1 0x100021c0
virtual void operator+=(float p_value) { AddImpl(p_value); } // vtable+0x50
// FUNCTION: LEGO1 0x100021d0
virtual void operator+=(const float* p_other) { AddImpl(p_other); } // vtable+0x4c
// FUNCTION: LEGO1 0x100021e0
virtual void operator+=(const Vector2& p_other) { AddImpl(p_other.m_data); } // vtable+0x48
// FUNCTION: LEGO1 0x100021f0
virtual void operator-=(const float* p_other) { SubImpl(p_other); } // vtable+0x58
// FUNCTION: LEGO1 0x10002200
virtual void operator-=(const Vector2& p_other) { SubImpl(p_other.m_data); } // vtable+0x54
// FUNCTION: LEGO1 0x10002210
virtual void operator*=(const float* p_other) { MulImpl(p_other); } // vtable+0x64
// FUNCTION: LEGO1 0x10002220
virtual void operator*=(const Vector2& p_other) { MulImpl(p_other.m_data); } // vtable+0x60
// FUNCTION: LEGO1 0x10002230
virtual void operator*=(const float& p_value) { MulImpl(p_value); } // vtable+0x5c
// FUNCTION: LEGO1 0x10002240
virtual void operator/=(const float& p_value) { DivImpl(p_value); } // vtable+0x68
// FUNCTION: LEGO1 0x10002250
virtual void SetVector(const float* p_other) { EqualsImpl(p_other); } // vtable+0x70
// FUNCTION: LEGO1 0x10002260
// FUNCTION: BETA10 0x100110c0
virtual void SetVector(const Vector2& p_other) { EqualsImpl(p_other.m_data); } // vtable+0x6c
// Note: it's unclear whether Vector3::operator= has been defined explicitly // Note: it's unclear whether Vector3::operator= has been defined explicitly
// with the same function body as Vector2& operator=. The BETA indicates that; // with the same function body as Vector2& operator=. The BETA indicates that;
@ -208,111 +107,76 @@ class Vector3 : public Vector2 {
// FUNCTION: BETA10 0x100109a0 // FUNCTION: BETA10 0x100109a0
Vector3(const float* p_data) : Vector2((float*) p_data) {} Vector3(const float* p_data) : Vector2((float*) p_data) {}
protected:
inline void AddImpl(const float* p_value) override; // vtable+0x04
inline void AddImpl(float p_value) override; // vtable+0x00
inline void SubImpl(const float* p_value) override; // vtable+0x08
inline void MulImpl(const float* p_value) override; // vtable+0x10
inline void MulImpl(const float& p_value) override; // vtable+0x0c
inline void DivImpl(const float& p_value) override; // vtable+0x14
inline float DotImpl(const float* p_a, const float* p_b) const override; // vtable+0x18
inline void EqualsImpl(const float* p_data) override; // vtable+0x20
inline virtual void EqualsCrossImpl(const float* p_a, const float* p_b); // vtable+0x74
public:
inline void Clear() override; // vtable+0x2c
inline float LenSquared() const override; // vtable+0x40
inline virtual void EqualsCross(const Vector3& p_a, const Vector3& p_b); // vtable+0x80
inline virtual void EqualsCross(const Vector3& p_a, const float* p_b); // vtable+0x7c
inline virtual void EqualsCross(const float* p_a, const Vector3& p_b); // vtable+0x78
inline virtual void Fill(const float& p_value); // vtable+0x84
friend class Mx3DPointFloat;
};
#include "vector2d.inl"
#include "vector3d.inl"
// VTABLE: LEGO1 0x100d45a0
// VTABLE: BETA10 0x101bac38
// SIZE 0x08
class Vector4 : public Vector3 {
public:
// FUNCTION: BETA10 0x10048780
inline Vector4(float* p_data) : Vector3(p_data) {}
// Some code initializes a Vector4 from a `const float*` source.
// Example: `LegoCarBuild::VTable0x6c`
// Vector4 however is a class that can mutate its underlying source, making
// initialization with a const source fundamentally incompatible.
// BETA10 appears to have two separate constructors for Vector4 as well,
// supporting the theory that this decompilation is correct.
// FUNCTION: BETA10 0x100701b0
inline Vector4(const float* p_data) : Vector3((float*) p_data) {}
// Note: virtual function overloads appear in the virtual table // Note: virtual function overloads appear in the virtual table
// in reverse order of appearance. // in reverse order of appearance.
// FUNCTION: LEGO1 0x10002270 inline void AddImpl(const float* p_value) override; // vtable+0x04
// FUNCTION: BETA10 0x10011350 inline void AddImpl(float p_value) override; // vtable+0x00
virtual void EqualsCrossImpl(const float* p_a, const float* p_b) inline void SubImpl(const float* p_value) override; // vtable+0x08
{ inline void MulImpl(const float* p_value) override; // vtable+0x10
m_data[0] = p_a[1] * p_b[2] - p_a[2] * p_b[1]; inline void MulImpl(const float& p_value) override; // vtable+0x0c
m_data[1] = p_a[2] * p_b[0] - p_a[0] * p_b[2]; inline void DivImpl(const float& p_value) override; // vtable+0x14
m_data[2] = p_a[0] * p_b[1] - p_a[1] * p_b[0]; inline float DotImpl(const float* p_a, const float* p_b) const override; // vtable+0x18
} // vtable+0x74 inline void EqualsImpl(const float* p_data) override; // vtable+0x20
// FUNCTION: LEGO1 0x100022c0 inline void Clear() override; // vtable+0x2c
// FUNCTION: BETA10 0x10011430 inline float LenSquared() const override; // vtable+0x40
virtual void EqualsCross(const Vector3& p_a, const Vector3& p_b) inline void Fill(const float& p_value) override; // vtable+0x84
{
EqualsCrossImpl(p_a.m_data, p_b.m_data);
} // vtable+0x80
// FUNCTION: LEGO1 0x100022e0 inline virtual void SetMatrixProduct(const float* p_vec, const float* p_mat); // vtable+0x8c
virtual void EqualsCross(const Vector3& p_a, const float* p_b) { EqualsCrossImpl(p_a.m_data, p_b); } // vtable+0x7c inline virtual void SetMatrixProduct(const Vector4& p_a, const float* 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 0x10002300 float& operator[](int idx) { return m_data[idx]; }
virtual void EqualsCross(const float* p_a, const Vector3& p_b) { EqualsCrossImpl(p_a, p_b.m_data); } // vtable+0x78
// Vector2 overrides // FUNCTION: BETA10 0x10010890
const float& operator[](int idx) const { return m_data[idx]; }
// FUNCTION: LEGO1 0x10003a60 friend class Mx4DPointFloat;
void AddImpl(const float* p_value) override
{
m_data[0] += p_value[0];
m_data[1] += p_value[1];
m_data[2] += p_value[2];
} // vtable+0x04
// FUNCTION: LEGO1 0x10003a90
void AddImpl(float p_value) override
{
m_data[0] += p_value;
m_data[1] += p_value;
m_data[2] += p_value;
} // vtable+0x00
// FUNCTION: LEGO1 0x10003ac0
void SubImpl(const float* p_value) override
{
m_data[0] -= p_value[0];
m_data[1] -= p_value[1];
m_data[2] -= p_value[2];
} // vtable+0x08
// FUNCTION: LEGO1 0x10003af0
void MulImpl(const float* p_value) override
{
m_data[0] *= p_value[0];
m_data[1] *= p_value[1];
m_data[2] *= p_value[2];
} // vtable+0x10
// FUNCTION: LEGO1 0x10003b20
void MulImpl(const float& p_value) override
{
m_data[0] *= p_value;
m_data[1] *= p_value;
m_data[2] *= p_value;
} // vtable+0x0c
// FUNCTION: LEGO1 0x10003b50
void DivImpl(const float& p_value) override
{
m_data[0] /= p_value;
m_data[1] /= p_value;
m_data[2] /= p_value;
} // vtable+0x14
// FUNCTION: LEGO1 0x10003b80
float DotImpl(const float* p_a, const float* p_b) const override
{
return p_a[0] * p_b[0] + p_a[2] * p_b[2] + p_a[1] * p_b[1];
} // vtable+0x18
// FUNCTION: LEGO1 0x10003ba0
// FUNCTION: BETA10 0x100113f0
void EqualsImpl(const float* p_data) override { memcpy(m_data, p_data, sizeof(float) * 3); } // vtable+0x20
// FUNCTION: LEGO1 0x10003bc0
// FUNCTION: BETA10 0x100114f0
void Clear() override { memset(m_data, 0, sizeof(float) * 3); } // vtable+0x2c
// FUNCTION: LEGO1 0x10003bd0
// FUNCTION: BETA10 0x10011530
float LenSquared() const override
{
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 { struct UnknownMatrixType {
@ -631,135 +495,107 @@ class MxMatrix : public Matrix4 {
float m_elements[4][4]; // 0x08 float m_elements[4][4]; // 0x08
}; };
// VTABLE: LEGO1 0x100d45a0 // FUNCTION: LEGO1 0x10002870
// VTABLE: BETA10 0x101bac38 void Vector4::AddImpl(const float* p_value)
// SIZE 0x08 {
class Vector4 : public Vector3 {
public:
// FUNCTION: BETA10 0x10048780
Vector4(float* p_data) : Vector3(p_data) {}
// Some code initializes a Vector4 from a `const float*` source.
// Example: `LegoCarBuild::VTable0x6c`
// Vector4 however is a class that can mutate its underlying source, making
// initialization with a const source fundamentally incompatible.
// BETA10 appears to have two separate constructors for Vector4 as well,
// supporting the theory that this decompilation is correct.
// FUNCTION: BETA10 0x100701b0
Vector4(const float* p_data) : Vector3((float*) p_data) {}
// Note: virtual function overloads appear in the virtual table
// in reverse order of appearance.
// Vector3 overrides
// FUNCTION: LEGO1 0x10002870
void AddImpl(const float* p_value) override
{
m_data[0] += p_value[0]; m_data[0] += p_value[0];
m_data[1] += p_value[1]; m_data[1] += p_value[1];
m_data[2] += p_value[2]; m_data[2] += p_value[2];
m_data[3] += p_value[3]; m_data[3] += p_value[3];
} // vtable+0x04 }
// FUNCTION: LEGO1 0x100028b0 // FUNCTION: LEGO1 0x100028b0
void AddImpl(float p_value) override void Vector4::AddImpl(float p_value)
{ {
m_data[0] += p_value; m_data[0] += p_value;
m_data[1] += p_value; m_data[1] += p_value;
m_data[2] += p_value; m_data[2] += p_value;
m_data[3] += p_value; m_data[3] += p_value;
} // vtable+0x00 }
// FUNCTION: LEGO1 0x100028f0 // FUNCTION: LEGO1 0x100028f0
void SubImpl(const float* p_value) override void Vector4::SubImpl(const float* p_value)
{ {
m_data[0] -= p_value[0]; m_data[0] -= p_value[0];
m_data[1] -= p_value[1]; m_data[1] -= p_value[1];
m_data[2] -= p_value[2]; m_data[2] -= p_value[2];
m_data[3] -= p_value[3]; m_data[3] -= p_value[3];
} // vtable+0x08 }
// FUNCTION: LEGO1 0x10002930 // FUNCTION: LEGO1 0x10002930
void MulImpl(const float* p_value) override void Vector4::MulImpl(const float* p_value)
{ {
m_data[0] *= p_value[0]; m_data[0] *= p_value[0];
m_data[1] *= p_value[1]; m_data[1] *= p_value[1];
m_data[2] *= p_value[2]; m_data[2] *= p_value[2];
m_data[3] *= p_value[3]; m_data[3] *= p_value[3];
} // vtable+0x10 }
// FUNCTION: LEGO1 0x10002970 // FUNCTION: LEGO1 0x10002970
void MulImpl(const float& p_value) override void Vector4::MulImpl(const float& p_value)
{ {
m_data[0] *= p_value; m_data[0] *= p_value;
m_data[1] *= p_value; m_data[1] *= p_value;
m_data[2] *= p_value; m_data[2] *= p_value;
m_data[3] *= p_value; m_data[3] *= p_value;
} // vtable+0x0c }
// FUNCTION: LEGO1 0x100029b0 // FUNCTION: LEGO1 0x100029b0
void DivImpl(const float& p_value) override void Vector4::DivImpl(const float& p_value)
{ {
m_data[0] /= p_value; m_data[0] /= p_value;
m_data[1] /= p_value; m_data[1] /= p_value;
m_data[2] /= p_value; m_data[2] /= p_value;
m_data[3] /= p_value; m_data[3] /= p_value;
} // vtable+0x14 }
// FUNCTION: LEGO1 0x100029f0 // FUNCTION: LEGO1 0x100029f0
float DotImpl(const float* p_a, const float* p_b) const override float Vector4::DotImpl(const float* p_a, const float* p_b) const
{ {
return p_a[0] * p_b[0] + p_a[2] * p_b[2] + (p_a[1] * p_b[1] + p_a[3] * p_b[3]); return p_a[0] * p_b[0] + p_a[2] * p_b[2] + (p_a[1] * p_b[1] + p_a[3] * p_b[3]);
} // vtable+0x18 }
// FUNCTION: LEGO1 0x10002a20 // FUNCTION: LEGO1 0x10002a20
void EqualsImpl(const float* p_data) override { memcpy(m_data, p_data, sizeof(float) * 4); } // vtable+0x20 void Vector4::EqualsImpl(const float* p_data)
{
memcpy(m_data, p_data, sizeof(float) * 4);
}
// FUNCTION: LEGO1 0x10002a40 // FUNCTION: LEGO1 0x10002a40
virtual void SetMatrixProduct(const float* p_vec, const float* p_mat) void Vector4::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[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[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[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]; 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 // FUNCTION: LEGO1 0x10002ae0
virtual void SetMatrixProduct(const Vector4& p_a, const float* p_b) void Vector4::SetMatrixProduct(const Vector4& p_a, const float* p_b)
{ {
SetMatrixProduct(p_a.m_data, p_b); SetMatrixProduct(p_a.m_data, p_b);
} // vtable+0x88 }
inline virtual int NormalizeQuaternion(); // vtable+0x90 // FUNCTION: LEGO1 0x10002b00
inline virtual int EqualsHamiltonProduct(const Vector4& p_a, const Vector4& p_b); // vtable+0x94 void Vector4::Clear()
{
memset(m_data, 0, sizeof(float) * 4);
}
// FUNCTION: LEGO1 0x10002b00 // FUNCTION: LEGO1 0x10002b20
void Clear() override { memset(m_data, 0, sizeof(float) * 4); } // vtable+0x2c float Vector4::LenSquared() const
{
// FUNCTION: LEGO1 0x10002b20
float LenSquared() const override
{
return m_data[1] * m_data[1] + m_data[0] * m_data[0] + m_data[2] * m_data[2] + m_data[3] * m_data[3]; return m_data[1] * m_data[1] + m_data[0] * m_data[0] + m_data[2] * m_data[2] + m_data[3] * m_data[3];
} // vtable+0x40 }
// FUNCTION: LEGO1 0x10002b40 // FUNCTION: LEGO1 0x10002b40
void Fill(const float& p_value) override void Vector4::Fill(const float& p_value)
{ {
m_data[0] = p_value; m_data[0] = p_value;
m_data[1] = p_value; m_data[1] = p_value;
m_data[2] = p_value; m_data[2] = p_value;
m_data[3] = p_value; m_data[3] = p_value;
} // vtable+0x84 }
float& operator[](int idx) { return m_data[idx]; }
// FUNCTION: BETA10 0x10010890
const float& operator[](int idx) const { return m_data[idx]; }
friend class Mx4DPointFloat;
};
// FUNCTION: BETA10 0x1005a590 // FUNCTION: BETA10 0x1005a590
inline int Matrix4::BETA_1005a590(Matrix4& p_mat) inline int Matrix4::BETA_1005a590(Matrix4& p_mat)

196
LEGO1/realtime/vector2d.inl Normal file
View File

@ -0,0 +1,196 @@
#include "vector.h"
// FUNCTION: LEGO1 0x10001f80
void Vector2::AddImpl(const float* p_value)
{
m_data[0] += p_value[0];
m_data[1] += p_value[1];
}
// FUNCTION: LEGO1 0x10001fa0
void Vector2::AddImpl(float p_value)
{
m_data[0] += p_value;
m_data[1] += p_value;
}
// FUNCTION: LEGO1 0x10001fc0
void Vector2::SubImpl(const float* p_value)
{
m_data[0] -= p_value[0];
m_data[1] -= p_value[1];
}
// FUNCTION: LEGO1 0x10001fe0
void Vector2::MulImpl(const float* p_value)
{
m_data[0] *= p_value[0];
m_data[1] *= p_value[1];
}
// FUNCTION: LEGO1 0x10002000
void Vector2::MulImpl(const float& p_value)
{
m_data[0] *= p_value;
m_data[1] *= p_value;
}
// FUNCTION: LEGO1 0x10002020
void Vector2::DivImpl(const float& p_value)
{
m_data[0] /= p_value;
m_data[1] /= p_value;
}
// FUNCTION: LEGO1 0x10002040
float Vector2::DotImpl(const float* p_a, const float* p_b) const
{
return p_b[0] * p_a[0] + p_b[1] * p_a[1];
}
// FUNCTION: LEGO1 0x10002060
// FUNCTION: BETA10 0x10010c90
void Vector2::SetData(float* p_data)
{
m_data = p_data;
}
// FUNCTION: LEGO1 0x10002070
void Vector2::EqualsImpl(const float* p_data)
{
memcpy(m_data, p_data, sizeof(float) * 2);
}
// FUNCTION: LEGO1 0x10002090
float* Vector2::GetData()
{
return m_data;
}
// FUNCTION: LEGO1 0x100020a0
const float* Vector2::GetData() const
{
return m_data;
}
// FUNCTION: LEGO1 0x100020b0
void Vector2::Clear()
{
memset(m_data, 0, sizeof(float) * 2);
}
// FUNCTION: LEGO1 0x100020d0
float Vector2::Dot(const float* p_a, const float* p_b) const
{
return DotImpl(p_a, p_b);
}
// FUNCTION: LEGO1 0x100020f0
// FUNCTION: BETA10 0x100108c0
float Vector2::Dot(const Vector2& p_a, const Vector2& p_b) const
{
return DotImpl(p_a.m_data, p_b.m_data);
}
// FUNCTION: LEGO1 0x10002110
float Vector2::Dot(const float* p_a, const Vector2& p_b) const
{
return DotImpl(p_a, p_b.m_data);
}
// FUNCTION: LEGO1 0x10002130
float Vector2::Dot(const Vector2& p_a, const float* p_b) const
{
return DotImpl(p_a.m_data, p_b);
}
// FUNCTION: LEGO1 0x10002150
float Vector2::LenSquared() const
{
return m_data[0] * m_data[0] + m_data[1] * m_data[1];
}
// FUNCTION: LEGO1 0x10002160
// FUNCTION: BETA10 0x10010900
int Vector2::Unitize()
{
float sq = LenSquared();
if (sq > 0.0f) {
float root = sqrt(sq);
if (root > 0.0f) {
DivImpl(root);
return 0;
}
}
return -1;
}
// FUNCTION: LEGO1 0x100021c0
void Vector2::operator+=(float p_value)
{
AddImpl(p_value);
}
// FUNCTION: LEGO1 0x100021d0
void Vector2::operator+=(const float* p_other)
{
AddImpl(p_other);
}
// FUNCTION: LEGO1 0x100021e0
void Vector2::operator+=(const Vector2& p_other)
{
AddImpl(p_other.m_data);
}
// FUNCTION: LEGO1 0x100021f0
void Vector2::operator-=(const float* p_other)
{
SubImpl(p_other);
}
// FUNCTION: LEGO1 0x10002200
void Vector2::operator-=(const Vector2& p_other)
{
SubImpl(p_other.m_data);
}
// FUNCTION: LEGO1 0x10002210
void Vector2::operator*=(const float* p_other)
{
MulImpl(p_other);
}
// FUNCTION: LEGO1 0x10002220
void Vector2::operator*=(const Vector2& p_other)
{
MulImpl(p_other.m_data);
}
// FUNCTION: LEGO1 0x10002230
void Vector2::operator*=(const float& p_value)
{
MulImpl(p_value);
}
// FUNCTION: LEGO1 0x10002240
void Vector2::operator/=(const float& p_value)
{
DivImpl(p_value);
}
// FUNCTION: LEGO1 0x10002250
void Vector2::SetVector(const float* p_other)
{
EqualsImpl(p_other);
}
// FUNCTION: LEGO1 0x10002260
// FUNCTION: BETA10 0x100110c0
void Vector2::SetVector(const Vector2& p_other)
{
EqualsImpl(p_other.m_data);
}

112
LEGO1/realtime/vector3d.inl Normal file
View File

@ -0,0 +1,112 @@
#include "vector.h"
// FUNCTION: LEGO1 0x10002270
// FUNCTION: BETA10 0x10011350
void Vector3::EqualsCrossImpl(const float* p_a, const float* p_b)
{
m_data[0] = p_a[1] * p_b[2] - p_a[2] * p_b[1];
m_data[1] = p_a[2] * p_b[0] - p_a[0] * p_b[2];
m_data[2] = p_a[0] * p_b[1] - p_a[1] * p_b[0];
}
// FUNCTION: LEGO1 0x100022c0
// FUNCTION: BETA10 0x10011430
void Vector3::EqualsCross(const Vector3& p_a, const Vector3& p_b)
{
EqualsCrossImpl(p_a.m_data, p_b.m_data);
}
// FUNCTION: LEGO1 0x100022e0
void Vector3::EqualsCross(const Vector3& p_a, const float* p_b)
{
EqualsCrossImpl(p_a.m_data, p_b);
}
// FUNCTION: LEGO1 0x10002300
void Vector3::EqualsCross(const float* p_a, const Vector3& p_b)
{
EqualsCrossImpl(p_a, p_b.m_data);
}
// FUNCTION: LEGO1 0x10003a60
void Vector3::AddImpl(const float* p_value)
{
m_data[0] += p_value[0];
m_data[1] += p_value[1];
m_data[2] += p_value[2];
}
// FUNCTION: LEGO1 0x10003a90
void Vector3::AddImpl(float p_value)
{
m_data[0] += p_value;
m_data[1] += p_value;
m_data[2] += p_value;
}
// FUNCTION: LEGO1 0x10003ac0
void Vector3::SubImpl(const float* p_value)
{
m_data[0] -= p_value[0];
m_data[1] -= p_value[1];
m_data[2] -= p_value[2];
}
// FUNCTION: LEGO1 0x10003af0
void Vector3::MulImpl(const float* p_value)
{
m_data[0] *= p_value[0];
m_data[1] *= p_value[1];
m_data[2] *= p_value[2];
}
// FUNCTION: LEGO1 0x10003b20
void Vector3::MulImpl(const float& p_value)
{
m_data[0] *= p_value;
m_data[1] *= p_value;
m_data[2] *= p_value;
}
// FUNCTION: LEGO1 0x10003b50
void Vector3::DivImpl(const float& p_value)
{
m_data[0] /= p_value;
m_data[1] /= p_value;
m_data[2] /= p_value;
}
// FUNCTION: LEGO1 0x10003b80
float Vector3::DotImpl(const float* p_a, const float* p_b) const
{
return p_a[0] * p_b[0] + p_a[2] * p_b[2] + p_a[1] * p_b[1];
}
// FUNCTION: LEGO1 0x10003ba0
// FUNCTION: BETA10 0x100113f0
void Vector3::EqualsImpl(const float* p_data)
{
memcpy(m_data, p_data, sizeof(float) * 3);
}
// FUNCTION: LEGO1 0x10003bc0
// FUNCTION: BETA10 0x100114f0
void Vector3::Clear()
{
memset(m_data, 0, sizeof(float) * 3);
}
// FUNCTION: LEGO1 0x10003bd0
// FUNCTION: BETA10 0x10011530
float Vector3::LenSquared() const
{
return m_data[0] * m_data[0] + m_data[1] * m_data[1] + m_data[2] * m_data[2];
}
// FUNCTION: LEGO1 0x10003bf0
void Vector3::Fill(const float& p_value)
{
m_data[0] = p_value;
m_data[1] = p_value;
m_data[2] = p_value;
}