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

Mostly implement/align pages 1-3 (10001xxx to 10003xxx) including implementing Helicopter and ongoing work on Vector. Still some poor matches in Helicopter

Browse Source
This commit is contained in:
Nathan 2023-12-06 15:06:29 -05:00
parent b46801a774
commit b0396c5c45
43 changed files with 1095 additions and 961 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -7,6 +7,8 @@ option(ISLE_USE_SMARTHEAP "Build with SmartHeap" ${MSVC})
option(ISLE_USE_DX5 "Build with internal DirectX 5 SDK" ON)
add_library(lego1 SHARED
LEGO1/score.cpp
LEGO1/helicopter.cpp
LEGO1/act1state.cpp
LEGO1/act2brick.cpp
LEGO1/act2policestation.cpp
@ -29,7 +31,6 @@ add_library(lego1 SHARED
LEGO1/gasstationentity.cpp
LEGO1/gasstationstate.cpp
LEGO1/gifmanager.cpp
LEGO1/helicopter.cpp
LEGO1/helicopterstate.cpp
LEGO1/historybook.cpp
LEGO1/hospital.cpp
@ -207,7 +208,6 @@ add_library(lego1 SHARED
LEGO1/realtime/realtimeview.cpp
LEGO1/realtime/vector.cpp
LEGO1/registrationbook.cpp
LEGO1/score.cpp
LEGO1/scorestate.cpp
LEGO1/skateboard.cpp
LEGO1/towtrack.cpp

6
LEGO1/act1state.h
View File

@ -21,6 +21,12 @@ class Act1State : public LegoState {
{
return !strcmp(name, Act1State::ClassName()) || LegoState::IsA(name);
};
inline void SetUnknown18(MxU32 p) { m_unk18 = p; }
protected:
undefined m_unk8[0x10];
MxU32 m_unk18;
};
#endif // ACT1STATE_H

4
LEGO1/act3.h
View File

@ -25,11 +25,13 @@ class Act3 : public LegoWorld {
}
inline void SetUnkown420c(MxEntity* p_entity) { m_unk420c = p_entity; }
inline void SetUnkown4270(MxU32 p) { m_unk4270 = p; }
protected:
undefined m_unkf8[0x4114];
MxEntity* m_unk420c;
undefined m_unk4210[0x64];
undefined m_unk4210[0x60];
MxU32 m_unk4270;
};
#endif // ACT3_H

20
LEGO1/gifmanager.cpp
View File

@ -3,23 +3,7 @@
DECOMP_SIZE_ASSERT(GifData, 0x14);
DECOMP_SIZE_ASSERT(GifMapEntry, 0x14);
DECOMP_SIZE_ASSERT(GifMap, 0x08);
DECOMP_SIZE_ASSERT(GifManagerBase, 0x14);
DECOMP_SIZE_ASSERT(GifManager, 0x30);
DECOMP_SIZE_ASSERT(GifManagerBase, 0x10);
DECOMP_SIZE_ASSERT(GifManager, 0x24);
GifMapEntry* DAT_100f0100;
// FUNCTION: LEGO1 0x10001cc0
GifMapEntry* GifMap::FindNode(const char*& string)
{
GifMapEntry* ret = m_unk4;
GifMapEntry* current = ret->m_parent;
while (current != DAT_100f0100) {
if (strcmp(current->m_key, string) <= 0) {
ret = current;
current = current->m_right;
}
else
current = current->m_left;
}
return ret;
}

20
LEGO1/gifmanager.h
View File

@ -24,10 +24,25 @@ struct GifMapEntry {
const char* m_key;
GifData* m_value;
};
extern GifMapEntry* DAT_100f0100;
class GifMap {
public:
GifMapEntry* FindNode(const char*& string);
// FUNCTION: LEGO1 0x10001cc0
GifMapEntry* GifMap::FindNode(const char*& string)
{
GifMapEntry* ret = m_unk4;
GifMapEntry* current = ret->m_parent;
while (current != DAT_100f0100) {
if (strcmp(current->m_key, string) <= 0) {
ret = current;
current = current->m_right;
}
else
current = current->m_left;
}
return ret;
}
inline GifData* Get(const char* string)
{
@ -51,7 +66,6 @@ class GifManagerBase {
inline GifData* Get(const char* name) { return m_unk8.Get(name); }
protected:
undefined4 m_unk0;
undefined4 m_unk4;
GifMap m_unk8;
};
@ -63,7 +77,7 @@ class GifManager : public GifManagerBase {
virtual ~GifManager() {} // vtable+00
protected:
undefined m_unk[0x1c];
undefined m_unk[0x14];
};
#endif // GIFMANAGER_H

270
LEGO1/helicopter.cpp
View File

@ -1,12 +1,15 @@
#include "helicopter.h"
#include "act1state.h"
#include "act3.h"
#include "isle.h"
#include "legoanimationmanager.h"
#include "legocontrolmanager.h"
#include "legogamestate.h"
#include "legoomni.h"
#include "legoutil.h"
#include "legoworld.h"
#include "mxtransitionmanager.h"
DECOMP_SIZE_ASSERT(Helicopter, 0x230)
@ -63,16 +66,263 @@ void Helicopter::VTable0xe4()
}
}
m_state->SetUnknown8(0);
FUN_1003ee00(m_unk22c, 0x16);
FUN_1003ee00(m_unk22c, 0x17);
FUN_1003ee00(m_unk22c, 0x18);
FUN_1003ee00(m_unk22c, 0x19);
FUN_1003ee00(m_unk22c, 0x1a);
FUN_1003ee00(m_unk22c, 0x1b);
FUN_1003ee00(m_unk22c, 0x1c);
FUN_1003ee00(m_unk22c, 0x1d);
FUN_1003ee00(m_unk22c, 0x1e);
FUN_1003ee00(m_unk22c, 0x1f);
FUN_1003ee00(m_script, 0x16);
FUN_1003ee00(m_script, 0x17);
FUN_1003ee00(m_script, 0x18);
FUN_1003ee00(m_script, 0x19);
FUN_1003ee00(m_script, 0x1a);
FUN_1003ee00(m_script, 0x1b);
FUN_1003ee00(m_script, 0x1c);
FUN_1003ee00(m_script, 0x1d);
FUN_1003ee00(m_script, 0x1e);
FUN_1003ee00(m_script, 0x1f);
AnimationManager()->FUN_1005f6d0(TRUE);
ControlManager()->Unregister(this);
}
// FUNCTION: LEGO1 0x10003480
MxU32 Helicopter::VTable0xcc()
{
if (!FUN_1003ef60())
return 1;
if (!m_LegoWorld)
m_LegoWorld = GetCurrentWorld();
AnimationManager()->FUN_1005f6d0(FALSE);
if (GetCurrentVehicle()) {
if (GetCurrentVehicle()->VTable0x60() != GameState()->GetUnknownC()) {
GetCurrentVehicle()->VTable0xe4();
}
}
switch (GameState()->GetUnknown10()) {
case 0:
m_script = *g_isleScript;
AnimationManager()->FUN_10064670(FALSE);
VTable0xe8(0x29, TRUE, 7);
((Isle*) GetCurrentWorld())->setUnknown13c(0x3c);
FUN_10015820(1, 0);
TransitionManager()->StartTransition(MxTransitionManager::PIXELATION, 50, FALSE, TRUE);
SetUnknownDC(4);
FUN_10015910(9);
break;
case 1:
m_script = *g_act2mainScript;
break;
case 2:
m_script = *g_act3Script;
break;
}
VTable0xe0();
InvokeAction(ExtraActionType_start, m_script, 0x15, NULL);
GetCurrentAction().SetObjectId(-1);
ControlManager()->Register(this);
return 1;
}
// FUNCTION: LEGO1 0x100035e0
MxU32 Helicopter::VTable0xd4(MxType17NotificationParam& p)
{
MxU32 ret = 0;
MxAtomId l_script;
switch (GameState()->GetUnknown10()) {
case 0:
l_script = *g_isleScript;
break;
case 1:
l_script = *g_act2mainScript;
break;
case 2:
l_script = *g_act3Script;
break;
}
if (p.GetUnknown28() == 1) {
switch (p.GetUnknown20()) {
case 0x17:
if (*g_act3Script == l_script) {
((Act3*) GetCurrentWorld())->SetUnkown4270(2);
TransitionManager()->StartTransition(MxTransitionManager::PIXELATION, 50, FALSE, FALSE);
}
else if (m_state->GetUnkown8() != 0)
break;
VTable0xe4();
GameState()->SetUnknown424(0x42);
ret = 1;
break;
case 0x18: {
if (*g_act3Script == l_script)
break;
Act1State* state = (Act1State*) GameState()->GetState("Act1State");
if (m_state->GetUnkown8() == 0) {
state->SetUnknown18(4);
m_state->SetUnknown8(1);
m_LegoWorld->FUN_1001fc80(this);
InvokeAction(ExtraActionType_start, l_script, 0x20, NULL);
SetUnknownDC(0);
}
ret = 1;
break;
}
case 0x19:
if (*g_act3Script == l_script)
break;
if (m_state->GetUnkown8() == 2) {
m_state->SetUnknown8(3);
m_LegoWorld->FUN_1001fc80(this);
InvokeAction(ExtraActionType_start, l_script, 0x21, NULL);
SetUnknownDC(4);
}
ret = 1;
break;
case 0x1a:
if (*g_act3Script != l_script)
break;
ret = 1;
/* fall through */
case 0x1b:
if (*g_act3Script != l_script)
break;
if (m_LegoWorld && m_LegoWorld->GetCamera()) {
Vector3Data loc, dir, lookat;
loc.CopyFrom(m_LegoWorld->GetCamera()->FUN_100127f0());
dir.CopyFrom(m_LegoWorld->GetCamera()->FUN_100128a0());
lookat = dir;
float scale = 3;
lookat.Mul(scale);
lookat.Add(&loc);
Vector3Data v68, v7c, v90(0, 1, 0), va4;
v68.CopyFrom(m_LegoWorld->GetCamera()->FUN_10012740());
va4.EqualsCross(v68, dir);
v7c.EqualsCross(va4, v90);
if (ret)
if (m_LegoWorld->FUN_100727e0(m_unk138, loc, dir, v7c))
break;
else if (m_LegoWorld->FUN_10072980(m_unk138, loc, dir, v7c))
break;
}
ret = 1;
break;
case 0x1c:
if (GameState()->GetUnknown10() == 0) {
((Isle*) GetCurrentWorld())->setUnknown13c(2);
TransitionManager()->StartTransition(MxTransitionManager::PIXELATION, 50, FALSE, FALSE);
VTable0xe4();
}
ret = 1;
break;
case 0x1d:
ret = 1;
break;
}
}
return ret;
}
// FUNCTION: LEGO1 0x10003c20
MxU32 Helicopter::VTable0xd8(MxType18NotificationParam& p)
{
switch (m_state->GetUnkown8()) {
case 1: {
if (GameState()->GetUnknown10() == 0) {
((Act1State*) GameState()->GetState("Act1State"))->SetUnknown18(4);
VTable0xe8(0x2a, TRUE, 7);
}
else
VTable0xe8(0x31, TRUE, 7);
m_state->SetUnknown8(2);
Matrix4Data mat;
mat.SetIdentity();
Matrix4 mat2 = mat.GetMatrix();
float s = sin(0.5235987901687622); // PI / 6, 30 deg
float c = cos(0.5235987901687622); // PI / 6, 30 deg
for (int i = 0; i < 4; i++) {
mat.GetMatrix()[i][1] = mat2[i][1] * c - mat2[i][2] * s;
mat.GetMatrix()[i][2] = mat2[i][2] * c + mat2[i][1] * s;
}
Vector3Impl at(mat.GetMatrix()[3]), dir(mat.GetMatrix()[2]), up(mat.GetMatrix()[1]);
m_LegoWorld->GetCamera()->LookAt(at, dir, up);
FUN_10010c30();
break;
}
case 3: {
Matrix4Data mat;
mat.SetIdentity();
Vector3Impl at(mat.GetMatrix()[3]), dir(mat.GetMatrix()[2]), up(mat.GetMatrix()[1]);
at[1] = 1.25;
m_LegoWorld->GetCamera()->LookAt(at, dir, up);
if (GameState()->GetUnknown10() == 0) {
((Act1State*) GameState()->GetState("Act1State"))->SetUnknown18(0);
VTable0xe8(0x29, TRUE, 7);
}
else
VTable0xe8(0x30, TRUE, 7);
m_state->SetUnknown8(0);
break;
}
default:
return 0;
}
return 1;
}
// FUNCTION: LEGO1 0x10003e90
void Helicopter::VTable0x74(Matrix4Impl& p_transform)
{
if (m_unkea != 0) {
m_roi->FUN_100a46b0(p_transform);
FUN_10010c30();
}
else {
m_roi->FUN_100a58f0(p_transform);
m_roi->VTable0x14();
if (m_cameraFlag)
FUN_10010c30();
}
}
// FUNCTION: LEGO1 0x10003ee0
void Helicopter::VTable0x70(float p)
{
int state = m_state->GetUnkown8();
switch (state) {
default:
LegoPathActor::VTable0x70(p);
return;
case 4:
case 5:
float f = m_unk1f0 - p + 3000;
if (f >= 0) {
float f2 = f / 3000 + 1;
if (f2 < 0)
f2 = 0;
if (1.0f < f2)
f2 = 1.0f;
Vector3Impl v(m_unk160.GetMatrix()[3]);
Matrix4Data mat;
Vector3Impl v2(m_unk1a8.GetMatrix()[3]);
float* loc = m_unk1a8.GetMatrix()[3];
mat.SetIdentity();
float fa[4];
Vector4Impl v3(fa);
if (m_unk1f4.FUN_100040a0(v3, f2) == SUCCESS) {
mat.FromQuaternion(v3);
}
v2.SetVector(loc);
v2.Sub(&v);
v2.Mul(f2);
v2.Add(&v);
m_LegoWorld->GetCamera()->FUN_100123e0(mat, 0);
}
else {
if (state == 4)
m_LegoWorld->FUN_10073400();
else
m_LegoWorld->FUN_10073430();
m_unkdc = 4;
}
}
}
// STUB: LEGO1 0x100040a0
MxResult HelicopterSubclass::FUN_100040a0(Vector4Impl& p_v, float p_f)
{
return SUCCESS;
}

26
LEGO1/helicopter.h
View File

@ -5,11 +5,23 @@
#include "islepathactor.h"
#include "realtime/matrix.h"
class HelicopterSubclass {
public:
inline HelicopterSubclass() : m_unk30(0) {}
MxResult FUN_100040a0(Vector4Impl& p_v, float p_f);
private:
Vector4Data m_unk0;
Vector4Data m_unk18;
undefined4 m_unk30;
};
// VTABLE: LEGO1 0x100d40f8
// SIZE 0x230
class Helicopter : public IslePathActor {
public:
Helicopter();
virtual ~Helicopter() override; // vtable+0x0
// FUNCTION: LEGO1 0x10003070
inline virtual const char* ClassName() const override // vtable+0x0c
@ -26,20 +38,22 @@ class Helicopter : public IslePathActor {
virtual MxResult Create(MxDSObject& p_dsObject) override; // vtable+0x18
virtual void VTable0xe4() override;
virtual MxU32 VTable0xcc() override;
virtual MxU32 VTable0xd4(MxType17NotificationParam& p) override;
virtual MxU32 VTable0xd8(MxType18NotificationParam& p) override;
void VTable0x74(Matrix4Impl& p_transform);
void VTable0x70(float p);
// SYNTHETIC: LEGO1 0x10003210
// Helicopter::`scalar deleting destructor'
virtual ~Helicopter() override; // vtable+0x0
protected:
Matrix4Data m_unk160;
Matrix4Data m_unk1a8;
undefined4 m_unk1f0;
Vector4Data m_unk1f4;
Vector4Data m_unk20c;
undefined4 m_unk224;
float m_unk1f0;
HelicopterSubclass m_unk1f4;
HelicopterState* m_state;
MxAtomId m_unk22c;
MxAtomId m_script;
private:
void GetState();

5
LEGO1/helicopterstate.h
View File

@ -21,10 +21,11 @@ class HelicopterState : public LegoState {
return !strcmp(name, HelicopterState::ClassName()) || LegoState::IsA(name);
}
inline void SetUnknown8(undefined4 p_unk8) { m_unk8 = p_unk8; }
inline void SetUnknown8(MxU32 p_unk8) { m_unk8 = p_unk8; }
inline MxU32 GetUnkown8() { return m_unk8; }
protected:
undefined4 m_unk8;
MxU32 m_unk8;
};
#endif // HELICOPTERSTATE_H

6
LEGO1/isle.h
View File

@ -22,6 +22,12 @@ class Isle : public LegoWorld {
{
return !strcmp(name, Isle::ClassName()) || LegoWorld::IsA(name);
}
inline void setUnknown13c(MxU32 p) { m_unk13c = p; }
protected:
undefined m_unkf8[0x44];
MxU32 m_unk13c;
};
#endif // ISLE_H

34
LEGO1/islepathactor.cpp
View File

@ -2,42 +2,10 @@
DECOMP_SIZE_ASSERT(IslePathActor, 0x160)
// Probably in header
// STUB: LEGO1 0x10002df0
void IslePathActor::VTable0xd0()
{
// TODO
}
// STUB: LEGO1 0x10002e00
void IslePathActor::VTable0xdc()
{
// TODO
}
// STUB: LEGO1 0x10002e70
void IslePathActor::VTable0xcc()
{
// TODO
}
// STUB: LEGO1 0x10002e80
void IslePathActor::VTable0xd4()
{
// TODO
}
// STUB: LEGO1 0x10002e90
void IslePathActor::VTable0xd8()
{
// TODO
}
// End header
// FUNCTION: LEGO1 0x1001a200
IslePathActor::IslePathActor()
{
this->m_pLegoWorld = NULL;
this->m_LegoWorld = NULL;
this->m_unk13c = 6.0;
this->m_unk15c = 1.0;
this->m_unk158 = 0;

30
LEGO1/islepathactor.h
View File

@ -3,6 +3,9 @@
#include "legopathactor.h"
#include "legoworld.h"
#include "mxtype17notificationparam.h"
#include "mxtype18notificationparam.h"
#include "mxtype19notificationparam.h"
#include "mxtypes.h"
// VTABLE: LEGO1 0x100d4398
@ -11,6 +14,19 @@ class IslePathActor : public LegoPathActor {
public:
IslePathActor();
// FUNCTION: LEGO1 0x10002e70
virtual MxU32 VTable0xcc() { return 0; } // vtable+0xcc
// FUNCTION: LEGO1 0x10002df0
virtual MxU32 VTable0xd0() { return 0; } // vtable+0xd0
// FUNCTION: LEGO1 0x10002e10
inline virtual ~IslePathActor() override { IslePathActor::Destroy(TRUE); }
// FUNCTION: LEGO1 0x10002e80
virtual MxU32 VTable0xd4(MxType17NotificationParam& p) { return 0; } // vtable+0xd4
// FUNCTION: LEGO1 0x10002e90
virtual MxU32 VTable0xd8(MxType18NotificationParam& p) { return 0; } // vtable+0xd8
// FUNCTION: LEGO1 0x10002e00
virtual MxU32 VTable0xdc(MxType19NotificationParam& p) { return 0; } // vtable+0xdc
// FUNCTION: LEGO1 0x10002ea0
inline virtual const char* ClassName() const override // vtable+0x0c
{
@ -26,24 +42,18 @@ class IslePathActor : public LegoPathActor {
// SYNTHETIC: LEGO1 0x10002ff0
// IslePathActor::`scalar deleting destructor'
inline virtual ~IslePathActor() override { IslePathActor::Destroy(TRUE); }
virtual MxResult Create(MxDSObject& p_dsObject) override; // vtable+0x18
virtual void VTable0xcc(); // vtable+0xcc
virtual void VTable0xd0(); // vtable+0xd0
virtual void VTable0xd4(); // vtable+0xd4
virtual void VTable0xd8(); // vtable+0xd8
virtual void VTable0xdc(); // vtable+0xdc
virtual void VTable0xe0(); // vtable+0xe0
virtual void VTable0xe4(); // vtable+0xe4
virtual void VTable0xe8(MxU32 p_1, MxBool p_2, MxU8 p_3); // vtable+0xe8
virtual void VTable0xec(); // vtable+0xec
inline void SetWorld(LegoWorld* p_world) { m_pLegoWorld = p_world; }
inline LegoWorld* GetWorld() { return m_pLegoWorld; }
inline void SetWorld(LegoWorld* p_world) { m_LegoWorld = p_world; }
inline LegoWorld* GetWorld() { return m_LegoWorld; }
private:
LegoWorld* m_pLegoWorld; // 0x154
protected:
LegoWorld* m_LegoWorld; // 0x154
MxFloat m_unk158;
MxFloat m_unk15c;
};

5
LEGO1/legoanimationmanager.cpp
View File

@ -48,3 +48,8 @@ MxResult LegoAnimationManager::Tickle()
return SUCCESS;
}
// STUB: LEGO1 0x10064670
void LegoAnimationManager::FUN_10064670(MxBool p)
{
}

1
LEGO1/legoanimationmanager.h
View File

@ -27,6 +27,7 @@ class LegoAnimationManager : public MxCore {
}
void FUN_1005f6d0(MxBool p);
void FUN_10064670(MxBool p);
__declspec(dllexport) static void configureLegoAnimationManager(int param_1);

28
LEGO1/legocameracontroller.cpp
View File

@ -11,3 +11,31 @@ LegoCameraController::~LegoCameraController()
{
// TODO
}
// STUB: LEGO1 0x10012260
void LegoCameraController::LookAt(Vector3Impl& p_at, Vector3Impl& p_dir, Vector3Impl& p_up)
{
}
// STUB: LEGO1 0x100123e0
void LegoCameraController::FUN_100123e0(Matrix4Data& p_transform, MxU32 p_2)
{
}
// STUB: LEGO1 0x10012740
Vector3Data& LegoCameraController::FUN_10012740()
{
return Vector3Data();
}
// STUB: LEGO1 0x100127f0
Vector3Data& LegoCameraController::FUN_100127f0()
{
return Vector3Data();
}
// STUB: LEGO1 0x100128a0
Vector3Data& LegoCameraController::FUN_100128a0()
{
return Vector3Data();
}

7
LEGO1/legocameracontroller.h
View File

@ -2,6 +2,8 @@
#define LEGOCAMERACONTROLLER_H
#include "mxcore.h"
#include "realtime/matrix.h"
#include "realtime/vector.h"
// VTABLE: LEGO1 0x100d57b0
// SIZE 0xc8
@ -22,6 +24,11 @@ class LegoCameraController : public MxCore {
{
return !strcmp(name, ClassName()) || MxCore::IsA(name);
}
void LegoCameraController::LookAt(Vector3Impl& p_at, Vector3Impl& p_dir, Vector3Impl& p_up);
void LegoCameraController::FUN_100123e0(Matrix4Data& p_transform, MxU32 p_2);
Vector3Data& FUN_10012740();
Vector3Data& FUN_100127f0();
Vector3Data& FUN_100128a0();
};
#endif // LEGOCAMERACONTROLLER_H

5
LEGO1/legoentity.cpp
View File

@ -102,6 +102,11 @@ void LegoEntity::ParseAction(char* p_extra)
}
}
// STUB: LEGO1 0x10010c30
void LegoEntity::FUN_10010c30()
{
}
// STUB: LEGO1 0x10010f10
void LegoEntity::VTable0x34()
{

1
LEGO1/legoentity.h
View File

@ -46,6 +46,7 @@ class LegoEntity : public MxEntity {
virtual void VTable0x44(); // vtable+0x44
virtual void VTable0x48(); // vtable+0x48
virtual void VTable0x4c(); // vtable+0x4c
void LegoEntity::FUN_10010c30();
protected:
void Init();

2
LEGO1/legogamestate.cpp
View File

@ -9,8 +9,6 @@
#include "mxstring.h"
#include "mxvariabletable.h"
// Based on the highest dword offset (0x42c) referenced in the constructor.
// There may be other members that come after.
DECOMP_SIZE_ASSERT(LegoGameState, 0x430)
// GLOBAL: LEGO1 0x100f3e40

2
LEGO1/legogamestate.h
View File

@ -16,7 +16,6 @@ struct ColorStringStruct {
const char* m_colorName;
};
// SIZE 0x430 (at least)
class LegoGameState {
public:
__declspec(dllexport) LegoGameState();
@ -34,6 +33,7 @@ class LegoGameState {
void FUN_1003a720(MxU32 p_unk);
void HandleAction(MxU32 p_unk);
inline MxU32 GetUnknownC() { return m_unkC; }
inline MxU32 GetUnknown10() { return m_unk10; }
inline void SetUnknown424(undefined4 p_unk424) { m_unk424 = p_unk424; }

3
LEGO1/legoomni.cpp
View File

@ -1,6 +1,7 @@
#include "legoomni.h"
#include "gifmanager.h"
#include "islepathactor.h"
#include "legoanimationmanager.h"
#include "legobuildingmanager.h"
#include "legogamestate.h"
@ -164,7 +165,7 @@ LegoNavController* NavController()
}
// FUNCTION: LEGO1 0x10015790
LegoWorld* GetCurrentVehicle()
IslePathActor* GetCurrentVehicle()
{
return LegoOmni::GetInstance()->GetCurrentVehicle();
}

7
LEGO1/legoomni.h
View File

@ -2,6 +2,7 @@
#define LEGOOMNI_H
#include "compat.h"
#include "islepathactor.h"
#include "mxdsaction.h"
#include "mxomni.h"
@ -103,7 +104,7 @@ class LegoOmni : public MxOmni {
GifManager* GetGifManager() { return m_gifManager; }
LegoWorld* GetCurrentWorld() { return m_currentWorld; }
LegoNavController* GetNavController() { return m_navController; }
LegoWorld* GetCurrentVehicle() { return m_currentVehicle; }
IslePathActor* GetCurrentVehicle() { return m_currentVehicle; }
LegoPlantManager* GetLegoPlantManager() { return m_plantManager; }
LegoAnimationManager* GetAnimationManager() { return m_animationManager; }
LegoBuildingManager* GetLegoBuildingManager() { return m_buildingManager; }
@ -121,7 +122,7 @@ class LegoOmni : public MxOmni {
LegoWorld* m_currentWorld;
MxBool m_unk80;
LegoNavController* m_navController; // 0x84
LegoWorld* m_currentVehicle; // 0x88
IslePathActor* m_currentVehicle; // 0x88
LegoUnkSaveDataWriter* m_unkLegoSaveDataWriter;
LegoPlantManager* m_plantManager; // 0x90
LegoAnimationManager* m_animationManager;
@ -151,7 +152,7 @@ __declspec(dllexport) LegoVideoManager* VideoManager();
LegoAnimationManager* AnimationManager();
LegoBuildingManager* BuildingManager();
LegoControlManager* ControlManager();
LegoWorld* GetCurrentVehicle();
IslePathActor* GetCurrentVehicle();
LegoPlantManager* PlantManager();
MxBool KeyValueStringParse(char*, const char*, const char*);
LegoWorld* GetCurrentWorld();

84
LEGO1/legopathactor.cpp
View File

@ -2,86 +2,6 @@
DECOMP_SIZE_ASSERT(LegoPathActor, 0x154)
// Probably in header
// STUB: LEGO1 0x10002d20
void LegoPathActor::VTable0x78()
{
// TODO
}
// STUB: LEGO1 0x10002d30
void LegoPathActor::VTable0x7c()
{
// TODO
}
// STUB: LEGO1 0x10002d40
void LegoPathActor::VTable0x90()
{
// TODO
}
// STUB: LEGO1 0x10002d50
void LegoPathActor::VTable0x94()
{
// TODO
}
// STUB: LEGO1 0x10002d60
void LegoPathActor::VTable0xa0()
{
// TODO
}
// STUB: LEGO1 0x10002d70
void LegoPathActor::VTable0xac()
{
// TODO
}
// STUB: LEGO1 0x10002d80
void LegoPathActor::VTable0xb0()
{
// TODO
}
// STUB: LEGO1 0x10002d90
void LegoPathActor::VTable0xb4()
{
// TODO
}
// STUB: LEGO1 0x10002da0
void LegoPathActor::VTable0xb8()
{
// TODO
}
// STUB: LEGO1 0x10002db0
void LegoPathActor::VTable0xbc()
{
// TODO
}
// STUB: LEGO1 0x10002dc0
void LegoPathActor::VTable0xc0()
{
// TODO
}
// STUB: LEGO1 0x10002dd0
void LegoPathActor::VTable0xc4()
{
// TODO
}
// STUB: LEGO1 0x10002de0
void LegoPathActor::VTable0xc8()
{
// TODO
}
// End header
// STUB: LEGO1 0x1002d700
LegoPathActor::LegoPathActor()
{
@ -119,13 +39,13 @@ void LegoPathActor::VTable0x8c()
}
// STUB: LEGO1 0x1002e740
void LegoPathActor::VTable0x74()
void LegoPathActor::VTable0x74(Matrix4Impl& p_transform)
{
// TODO
}
// STUB: LEGO1 0x1002e790
void LegoPathActor::VTable0x70()
void LegoPathActor::VTable0x70(float p)
{
// TODO
}

78
LEGO1/legopathactor.h
View File

@ -25,39 +25,59 @@ class LegoPathActor : public LegoActor {
return !strcmp(name, LegoPathActor::ClassName()) || LegoActor::IsA(name);
}
virtual void VTable0x68(); // vtable+0x68
virtual void VTable0x6c(); // vtable+0x6c
virtual void VTable0x70(); // vtable+0x70
virtual void VTable0x74(); // vtable+0x74
virtual void VTable0x78(); // vtable+0x78
virtual void VTable0x7c(); // vtable+0x7c
virtual void VTable0x80(); // vtable+0x80
virtual void VTable0x84(); // vtable+0x84
virtual void VTable0x88(); // vtable+0x88
virtual void VTable0x8c(); // vtable+0x8c
virtual void VTable0x90(); // vtable+0x90
virtual void VTable0x94(); // vtable+0x94
virtual void VTable0x98(); // vtable+0x98
virtual void VTable0x9c(); // vtable+0x9c
virtual void VTable0xa0(); // vtable+0xa0
virtual void VTable0xa4(); // vtable+0xa4
virtual void VTable0xa8(); // vtable+0xa8
virtual void VTable0xac(); // vtable+0xac
virtual void VTable0xb0(); // vtable+0xb0
virtual void VTable0xb4(); // vtable+0xb4
virtual void VTable0xb8(); // vtable+0xb8
virtual void VTable0xbc(); // vtable+0xbc
virtual void VTable0xc0(); // vtable+0xc0
virtual void VTable0xc4(); // vtable+0xc4
virtual void VTable0xc8(); // vtable+0xc8
inline void SetUnknownDC(MxU32 p) { m_unkdc = p; }
virtual void VTable0x68(); // vtable+0x68
virtual void VTable0x6c(); // vtable+0x6c
virtual void VTable0x70(float p); // vtable+0x70
virtual void VTable0x74(Matrix4Impl& p_transform); // vtable+0x74
// FUNCTION: LEGO1 0x10002d20
virtual void VTable0x78(MxU8 p_1) { m_unkea = p_1; } // vtable+0x78
// FUNCTION: LEGO1 0x10002d30
virtual MxU8 VTable0x7c() { return m_unkea; } // vtable+0x7c
virtual void VTable0x80(); // vtable+0x80
virtual void VTable0x84(); // vtable+0x84
virtual void VTable0x88(); // vtable+0x88
virtual void VTable0x8c(); // vtable+0x8c
// FUNCTION: LEGO1 0x10002d40
virtual MxS32 VTable0x90() { return 0; } // vtable+0x90
// FUNCTION: LEGO1 0x10002d50
virtual MxS32 VTable0x94() { return 0; } // vtable+0x94
virtual void VTable0x98(); // vtable+0x98
virtual void VTable0x9c(); // vtable+0x9c
// FUNCTION: LEGO1 0x10002d60
virtual MxS32 VTable0xa0() { return 0; } // vtable+0xa0
virtual void VTable0xa4(); // vtable+0xa4
virtual void VTable0xa8(); // vtable+0xa8
// FUNCTION: LEGO1 0x10002d70
virtual void VTable0xac(MxFloat p_1) { m_unk140 = p_1; } // vtable+0xac
// FUNCTION: LEGO1 0x10002d80
virtual MxFloat VTable0xb0() { return m_unk13c; } // vtable+0xb0
// FUNCTION: LEGO1 0x10002d90
virtual MxFloat VTable0xb4() { return m_unk140; } // vtable+0xb4
// FUNCTION: LEGO1 0x10002da0
virtual MxFloat VTable0xb8() { return m_unk144; } // vtable+0xb8
// FUNCTION: LEGO1 0x10002db0
virtual void VTable0xbc(MxFloat p_1) { m_unk140 = p_1; } // vtable+0xbc
// FUNCTION: LEGO1 0x10002dc0
virtual void VTable0xc0(MxFloat p_1) { m_unk144 = p_1; } // vtable+0xc0
// FUNCTION: LEGO1 0x10002dd0
virtual void VTable0xc4() {} // vtable+0xc4
// FUNCTION: LEGO1 0x10002de0
virtual void VTable0xc8(MxU8 p_1) { m_unk148 = p_1; } // vtable+0xc8
protected:
// TODO: the types
undefined unk78[0xc4];
undefined m_unk78[0x64];
MxU32 m_unkdc;
undefined m_unke0[0xa];
MxU8 m_unkea;
undefined m_unk[0x4d];
MxU32 m_unk138;
MxFloat m_unk13c;
MxS32 m_unk140;
MxS32 m_unk144;
undefined m_unk148;
MxFloat m_unk140;
MxFloat m_unk144;
MxU8 m_unk148;
MxS32 m_unk14c;
MxFloat m_unk150;
};

9
LEGO1/legoroi.cpp
View File

@ -35,6 +35,15 @@ MxS32 g_roiConfig = 100;
// GLOBAL: LEGO1 0x101013ac
ROIHandler g_someHandlerFunction = NULL;
// STUB: LEGO1 0x100a46b0
void LegoROI::FUN_100a46b0(Matrix4Impl& p_transform)
{
}
void LegoROI::FUN_100a58f0(Matrix4Impl& p_transform)
{
}
// FUNCTION: LEGO1 0x100a81c0
void LegoROI::configureLegoROI(MxS32 p_roi)
{

5
LEGO1/legoroi.h
View File

@ -2,10 +2,11 @@
#define LEGOROI_H
#include "mxtypes.h"
#include "viewmanager/viewroi.h"
typedef MxBool (*ROIHandler)(char*, char*, MxU32);
class LegoROI {
class LegoROI : public ViewROI {
public:
__declspec(dllexport) void SetDisplayBB(MxS32 p_displayBB);
__declspec(dllexport) static void configureLegoROI(MxS32 p_roi);
@ -19,6 +20,8 @@ class LegoROI {
MxFloat& p_other
);
static MxBool ColorAliasLookup(char* p_param, MxFloat& p_red, MxFloat& p_green, MxFloat& p_blue, MxFloat& p_other);
void FUN_100a46b0(Matrix4Impl& p_transform);
void FUN_100a58f0(Matrix4Impl& p_transform);
};
#endif // LEGOROI_H

12
LEGO1/legoutil.cpp
View File

@ -1,5 +1,6 @@
#include "legoutil.h"
#include "legoentity.h"
#include "mxomni.h"
#include "mxtypes.h"
@ -34,6 +35,11 @@ ExtraActionType MatchActionString(const char* p_str)
return result;
}
// STUB: LEGO1 0x1003e430
void InvokeAction(ExtraActionType actionId, MxAtomId& pAtom, int targetEntityId, LegoEntity* sender)
{
}
// FUNCTION: LEGO1 0x1003eae0
void ConvertHSVToRGB(float h, float s, float v, float* r_out, float* b_out, float* g_out)
{
@ -112,3 +118,9 @@ void SetAppCursor(WPARAM p_wparam)
{
PostMessageA(MxOmni::GetInstance()->GetWindowHandle(), 0x5400, p_wparam, 0);
}
// STUB: LEGO1 0x1003ef60
MxBool FUN_1003ef60()
{
return true;
}

4
LEGO1/legoutil.h
View File

@ -2,7 +2,9 @@
#define LEGOUTIL_H
#include "extra.h"
#include "legoentity.h"
#include "mxatomid.h"
#include "mxtypes.h"
#include <windows.h>
@ -54,8 +56,10 @@ inline void GetString(char** p_source, const char* p_dest, T* p_obj, void (T::*p
}
ExtraActionType MatchActionString(const char*);
void InvokeAction(ExtraActionType actionId, MxAtomId& pAtom, int targetEntityId, LegoEntity* sender);
void ConvertHSVToRGB(float r, float g, float b, float* out_r, float* out_g, float* out_b);
void FUN_1003ee00(MxAtomId& p_atomId, MxS32 p_id);
void SetAppCursor(WPARAM p_wparam);
MxBool FUN_1003ef60();
#endif // LEGOUTIL_H

38
LEGO1/legoworld.cpp
View File

@ -11,11 +11,6 @@ DECOMP_SIZE_ASSERT(LegoWorld, 0xf8);
MxBool g_isWorldActive;
// FUNCTION: LEGO1 0x100010a0
void LegoWorld::VTable0x60()
{
}
// STUB: LEGO1 0x10015820
void FUN_10015820(MxU32 p_unk1, MxU32 p_unk2)
{
@ -91,6 +86,11 @@ void LegoWorld::VTable0x54()
// TODO
}
// FUNCTION: LEGO1 0x1001fc80
void LegoWorld::FUN_1001fc80(IslePathActor* actor)
{
}
// STUB: LEGO1 0x10020220
void LegoWorld::VTable0x58(MxCore* p_object)
{
@ -108,8 +108,36 @@ void LegoWorld::VTable0x68(MxBool p_add)
// TODO
}
// STUB: LEGO1 0x10022080
MxResult LegoWorld::Tickle()
{
return SUCCESS;
}
// FUNCTION: LEGO1 0x10022340
void LegoWorld::Stop()
{
TickleManager()->UnregisterClient(this);
}
// STUB: LEGO1 0x100727e0
MxBool LegoWorld::FUN_100727e0(MxU32 p, Vector3Data& loc, Vector3Data& dir, Vector3Data& up)
{
return FALSE;
}
// STUB: LEGO1 0x10072980
MxBool LegoWorld::FUN_10072980(MxU32 p, Vector3Data& loc, Vector3Data& dir, Vector3Data& up)
{
return FALSE;
}
// STUB: LEGO1 0x10073400
void LegoWorld::FUN_10073400()
{
}
// STUB: LEGO1 0x10073400
void LegoWorld::FUN_10073430()
{
}

17
LEGO1/legoworld.h
View File

@ -7,6 +7,8 @@
#include "mxpresenter.h"
#include "mxpresenterlist.h"
class IslePathActor;
// VTABLE: LEGO1 0x100d6280
// SIZE 0xf8
class LegoWorld : public LegoEntity {
@ -15,6 +17,7 @@ class LegoWorld : public LegoEntity {
__declspec(dllexport) virtual ~LegoWorld(); // vtable+0x0
virtual MxLong Notify(MxParam& p) override; // vtable+0x4
MxResult Tickle();
// FUNCTION: LEGO1 0x1001d690
inline virtual const char* ClassName() const override // vtable+0x0c
@ -33,12 +36,19 @@ class LegoWorld : public LegoEntity {
virtual void VTable0x54(); // vtable+54
virtual void VTable0x58(MxCore* p_object); // vtable+58
virtual MxBool VTable0x5c(); // vtable+5c
virtual void VTable0x60(); // vtable+60
virtual MxBool VTable0x64(); // vtable+64
virtual void VTable0x68(MxBool p_add); // vtable+68
// FUNCTION: LEGO1 0x100010a0
virtual void VTable0x60() {} // vtable+60
virtual MxBool VTable0x64(); // vtable+64
virtual void VTable0x68(MxBool p_add); // vtable+68
MxResult SetAsCurrentWorld(MxDSObject& p_dsObject);
void EndAction(MxPresenter* p_presenter);
void FUN_1001fc80(IslePathActor* actor);
inline LegoCameraController* GetCamera() { return m_camera; }
MxBool FUN_100727e0(MxU32 p, Vector3Data& loc, Vector3Data& dir, Vector3Data& up);
MxBool FUN_10072980(MxU32 p, Vector3Data& loc, Vector3Data& dir, Vector3Data& up);
void FUN_10073400();
void FUN_10073430();
protected:
LegoPathControllerList m_list0x68; // 0x68
@ -52,6 +62,7 @@ class LegoWorld : public LegoEntity {
};
void FUN_10015820(MxU32 p_unk1, MxU32 p_unk2);
void FUN_100158e0();
void FUN_10015910(MxU32 p_unk1);
void SetIsWorldActive(MxBool p_isWorldActive);

6
LEGO1/mxcore.cpp
View File

@ -2,12 +2,6 @@
#include "define.h"
// FUNCTION: LEGO1 0x10001f70
MxResult MxCore::Tickle()
{
return SUCCESS;
}
// FUNCTION: LEGO1 0x100ae1a0
MxCore::MxCore()
{

4
LEGO1/mxcore.h
View File

@ -22,7 +22,9 @@ class MxCore {
__declspec(dllexport) MxCore();
__declspec(dllexport) virtual ~MxCore(); // vtable+00
__declspec(dllexport) virtual MxLong Notify(MxParam& p); // vtable+04
virtual MxResult Tickle(); // vtable+08
// FUNCTION: LEGO1 0x10001f70
virtual MxResult Tickle() { return SUCCESS; } // vtable+08
inline virtual const char* ClassName() const // vtable+0c
{

8
LEGO1/mxentity.cpp
View File

@ -2,14 +2,6 @@
DECOMP_SIZE_ASSERT(MxEntity, 0x10)
// FUNCTION: LEGO1 0x10001070
MxResult MxEntity::Create(MxS32 p_id, const MxAtomId& p_atom)
{
this->m_mxEntityId = p_id;
this->m_atom = p_atom;
return SUCCESS;
}
// FUNCTION: LEGO1 0x1000c110
MxEntity::~MxEntity()
{

9
LEGO1/mxentity.h
View File

@ -27,7 +27,14 @@ class MxEntity : public MxCore {
return !strcmp(name, MxEntity::ClassName()) || MxCore::IsA(name);
}
virtual MxResult Create(MxS32 p_id, const MxAtomId& p_atom); // vtable+0x14
// FUNCTION: LEGO1 0x10001070
virtual MxResult Create(MxS32 p_id, const MxAtomId& p_atom)
{
this->m_mxEntityId = p_id;
this->m_atom = p_atom;
return SUCCESS;
}
inline MxResult Create(MxDSObject& p_dsObject)
{
m_mxEntityId = p_dsObject.GetObjectId();

14
LEGO1/mxtype18notificationparam.h Normal file
View File

@ -0,0 +1,14 @@
#ifndef MXTYPE18NOTIFICATIONPARAM_H
#define MXTYPE18NOTIFICATIONPARAM_H
#include "decomp.h"
#include "mxnotificationparam.h"
// VTABLE: LEGO1 0x100d7e80
class MxType18NotificationParam : public MxNotificationParam {
public:
protected:
undefined4 m_unkc;
};
#endif // MXTYPE18NOTIFICATIONPARAM_H

14
LEGO1/mxtype19notificationparam.h Normal file
View File

@ -0,0 +1,14 @@
#ifndef MXTYPE19NOTIFICATIONPARAM_H
#define MXTYPE19NOTIFICATIONPARAM_H
#include "decomp.h"
#include "mxnotificationparam.h"
// VTABLE: LEGO1 0x100d6230
class MxType19NotificationParam : public MxNotificationParam {
public:
protected:
undefined4 m_unkc;
};
#endif // MXTYPE19NOTIFICATIONPARAM_H

175
LEGO1/realtime/matrix.cpp
View File

@ -9,178 +9,3 @@
DECOMP_SIZE_ASSERT(Matrix4, 0x40);
DECOMP_SIZE_ASSERT(Matrix4Impl, 0x8);
DECOMP_SIZE_ASSERT(Matrix4Data, 0x48);
// FUNCTION: LEGO1 0x10002320
void Matrix4Impl::EqualsMatrixData(const Matrix4& p_matrix)
{
*m_data = p_matrix;
}
// FUNCTION: LEGO1 0x10002340
void Matrix4Impl::EqualsMatrixImpl(const Matrix4Impl* p_other)
{
*m_data = *p_other->m_data;
}
// FUNCTION: LEGO1 0x10002360
void Matrix4Impl::AnotherSetData(Matrix4& p_data)
{
m_data = &p_data;
}
// FUNCTION: LEGO1 0x10002370
void Matrix4Impl::SetData(Matrix4& p_data)
{
m_data = &p_data;
}
// FUNCTION: LEGO1 0x10002380
const Matrix4* Matrix4Impl::GetData() const
{
return m_data;
}
// FUNCTION: LEGO1 0x10002390
Matrix4* Matrix4Impl::GetData()
{
return m_data;
}
// FUNCTION: LEGO1 0x100023a0
const float* Matrix4Impl::Element(int p_row, int p_col) const
{
return &(*m_data)[p_row][p_col];
}
// FUNCTION: LEGO1 0x100023c0
float* Matrix4Impl::Element(int p_row, int p_col)
{
return &(*m_data)[p_row][p_col];
}
// FUNCTION: LEGO1 0x100023e0
void Matrix4Impl::Clear()
{
memset(m_data, 0, 16 * sizeof(float));
}
// FUNCTION: LEGO1 0x100023f0
void Matrix4Impl::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;
}
// FUNCTION: LEGO1 0x10002430
Matrix4Impl* Matrix4Impl::operator+=(const Matrix4& p_matrix)
{
for (int i = 0; i < 16; ++i)
((float*) m_data)[i] += ((float*) &p_matrix)[i];
return this;
}
// Matches but instructions are significantly out of order. Probably not wrong
// code given that the very similar SetTranslation does match.
// FUNCTION: LEGO1 0x10002460
void Matrix4Impl::TranslateBy(const float* p_x, const float* p_y, const float* p_z)
{
((float*) m_data)[12] += *p_x;
((float*) m_data)[13] += *p_y;
((float*) m_data)[14] += *p_z;
}
// FUNCTION: LEGO1 0x100024a0
void Matrix4Impl::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;
}
// FUNCTION: LEGO1 0x100024d0
void Matrix4Impl::EqualsDataProduct(const Matrix4& p_a, const Matrix4& p_b)
{
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++;
}
}
}
// FUNCTION: LEGO1 0x10002530
void Matrix4Impl::EqualsMxProduct(const Matrix4Impl* p_a, const Matrix4Impl* p_b)
{
EqualsDataProduct(*p_a->m_data, *p_b->m_data);
}
// Not close, Ghidra struggles understinging this method so it will have to
// be manually worked out. Included since I at least figured out what it was
// doing with rotateIndex and what overall operation it's trying to do.
// STUB: LEGO1 0x10002550
void Matrix4Impl::ToQuaternion(Vector4Impl* p_outQuat)
{
/*
float trace = m_data[0] + m_data[5] + m_data[10];
if (trace > 0) {
trace = sqrt(trace + 1.0);
p_outQuat->GetData()[3] = trace * 0.5f;
p_outQuat->GetData()[0] = (m_data[9] - m_data[6]) * trace;
p_outQuat->GetData()[1] = (m_data[2] - m_data[8]) * trace;
p_outQuat->GetData()[2] = (m_data[4] - m_data[1]) * trace;
return;
}
// GLOBAL: LEGO1 0x100d4090
static int rotateIndex[] = {1, 2, 0};
// Largest element along the trace
int largest = m_data[0] < m_data[5];
if (*Element(largest, largest) < m_data[10])
largest = 2;
int next = rotateIndex[largest];
int nextNext = rotateIndex[next];
float valueA = *Element(nextNext, nextNext);
float valueB = *Element(next, next);
float valueC = *Element(largest, largest);
// Above is somewhat decomped, below is pure speculation since the automatic
// decomp becomes very garbled.
float traceValue = sqrt(valueA - valueB - valueC + 1.0);
p_outQuat->GetData()[largest] = traceValue * 0.5f;
traceValue = 0.5f / traceValue;
p_outQuat->GetData()[3] = (m_data[next + 4 * nextNext] - m_data[nextNext + 4 * next]) * traceValue;
p_outQuat->GetData()[next] = (m_data[next + 4 * largest] + m_data[largest + 4 * next]) * traceValue;
p_outQuat->GetData()[nextNext] = (m_data[nextNext + 4 * largest] + m_data[largest + 4 * nextNext]) * traceValue;
*/
}
// No idea what this function is doing and it will be hard to tell until
// we have a confirmed usage site.
// STUB: LEGO1 0x10002710
int Matrix4Impl::FUN_10002710(const Vector3Impl* p_vec)
{
return -1;
}
// FUNCTION: LEGO1 0x10002850
void Matrix4Impl::operator=(const Matrix4Impl& p_other)
{
EqualsMatrixImpl(&p_other);
}
// FUNCTION: LEGO1 0x10002860
void Matrix4Data::operator=(const Matrix4Data& p_other)
{
EqualsMatrixImpl(&p_other);
}

202
LEGO1/realtime/matrix.h
View File

@ -1,8 +1,8 @@
#ifndef MATRIX_H
#define MATRIX_H
#include "memory.h"
#include "vector.h"
/*
* A simple array of four Vector4s that can be indexed into.
*/
@ -35,35 +35,178 @@ class Matrix4 {
// SIZE 0x8
class Matrix4Impl {
public:
inline Matrix4Impl(Matrix4& p_data) : m_data(&p_data) {}
inline Matrix4Impl(Matrix4& p_data) { m_data = &p_data; }
// vtable + 0x00
virtual void EqualsMatrixImpl(const Matrix4Impl* p_other);
virtual void EqualsMatrixData(const Matrix4& p_matrix);
virtual void SetData(Matrix4& p_data);
virtual void AnotherSetData(Matrix4& p_data);
// FUNCTION: LEGO1 0x10002340
virtual void EqualsMatrixImpl(const Matrix4Impl* p_other) { *m_data = *p_other->m_data; }
// vtable + 0x10
virtual Matrix4* GetData();
virtual const Matrix4* GetData() const;
virtual float* Element(int p_row, int p_col);
virtual const float* Element(int p_row, int p_col) const;
// FUNCTION: LEGO1 0x10002320
virtual void EqualsMatrixData(const Matrix4& p_matrix) { *m_data = p_matrix; }
// vtable + 0x20
virtual void Clear();
virtual void SetIdentity();
virtual void operator=(const Matrix4Impl& p_other);
virtual Matrix4Impl* operator+=(const Matrix4& p_matrix);
// FUNCTION: LEGO1 0x10002370
virtual void SetData(Matrix4& p_data) { m_data = &p_data; }
// vtable + 0x30
virtual void TranslateBy(const float* p_x, const float* p_y, const float* p_z);
virtual void SetTranslation(const float* p_x, const float* p_y, const float* p_z);
virtual void EqualsMxProduct(const Matrix4Impl* p_a, const Matrix4Impl* p_b);
virtual void EqualsDataProduct(const Matrix4& p_a, const Matrix4& p_b);
// FUNCTION: LEGO1 0x10002360
virtual void AnotherSetData(Matrix4& p_data) { m_data = &p_data; }
// vtable + 0x40
virtual void ToQuaternion(Vector4Impl* p_resultQuat);
virtual int FUN_10002710(const Vector3Impl* p_vec);
// FUNCTION: LEGO1 0x10002390
virtual Matrix4* GetData() { return m_data; }
// FUNCTION: LEGO1 0x10002380
virtual const Matrix4* GetData() const { return m_data; }
// FUNCTION: LEGO1 0x100023c0
virtual float* Element(int p_row, int p_col) { return &(*m_data)[p_row][p_col]; }
// FUNCTION: LEGO1 0x100023a0
virtual const float* Element(int p_row, int p_col) const { return &(*m_data)[p_row][p_col]; }
// FUNCTION: LEGO1 0x100023e0
virtual void Clear() { memset(m_data, 0, 16 * sizeof(float)); }
// FUNCTION: LEGO1 0x100023f0
virtual inline 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;
}
// FUNCTION: LEGO1 0x10002420
virtual void operator=(const Matrix4Impl& p_other) { EqualsMatrixImpl(&p_other); }
// FUNCTION: LEGO1 0x10002430
virtual Matrix4Impl* operator+=(const Matrix4& p_matrix)
{
for (int i = 0; i < 16; ++i)
((float*) m_data)[i] += ((float*) &p_matrix)[i];
return this;
}
// Matches but instructions are significantly out of order. Probably not wrong
// code given that the very similar SetTranslation does match.
// FUNCTION: LEGO1 0x10002460
virtual void TranslateBy(const float* p_x, const float* p_y, const float* p_z)
{
((float*) m_data)[12] += *p_x;
((float*) m_data)[13] += *p_y;
((float*) m_data)[14] += *p_z;
}
// FUNCTION: LEGO1 0x100024a0
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;
}
// FUNCTION: LEGO1 0x10002530
virtual void EqualsMxProduct(const Matrix4Impl* p_a, const Matrix4Impl* p_b)
{
EqualsDataProduct(*p_a->m_data, *p_b->m_data);
}
// FUNCTION: LEGO1 0x100024d0
virtual void EqualsDataProduct(const Matrix4& p_a, const Matrix4& p_b)
{
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++;
}
}
}
// FUNCTION: LEGO1 0x10002550
virtual void ToQuaternion(Vector4Impl& p_outQuat)
{
float trace = TRACE3(*m_data);
if (trace > 0) {
trace = sqrt(trace + 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 {
// FUNCTION: LEGO1 0x100d4090
static int rotateIndex[] = {1, 2, 0};
int i, j, k;
i = 0;
// Largest element along the trace
if ((*m_data)[1][1] > (*m_data)[0][0])
i = 1;
if ((*m_data)[2][2] > *Element(i, i))
i = 2;
j = rotateIndex[i];
k = rotateIndex[j];
// Above is somewhat decomped, below is pure speculation since the automatic
// decomp becomes very garbled.
float traceValue = sqrt(*Element(i, i) - (*Element(j, j) + *Element(k, k)) + 1.0);
p_outQuat[i] = traceValue * 0.5f;
traceValue = 0.5f / traceValue;
p_outQuat.GetData()[3] = traceValue * ((*m_data)[k][j] - (*m_data)[j][k]);
p_outQuat.GetData()[j] = traceValue * (*m_data)[j][i] + (*m_data)[i][j];
p_outQuat.GetData()[k] = traceValue * (*m_data)[k][i] + (*m_data)[i][k];
}
}
// FUNCTION: LEGO1 0x10002710
virtual int FromQuaternion(const Vector4Impl& p_quat)
{
float lensq;
if ((lensq = p_quat.LenSquared()) > 0) {
lensq = 2 / lensq;
float XX = p_quat[0] * lensq;
float YY = p_quat[1] * lensq;
float ZZ = p_quat[2] * lensq;
float WXX = p_quat[3] * XX;
float XXX = p_quat[0] * XX;
float WYY = p_quat[3] * YY;
float XYY = p_quat[0] * YY;
float YYY = p_quat[1] * YY;
float WZZ = p_quat[3] * ZZ;
float XZZ = p_quat[0] * ZZ;
float YZZ = p_quat[1] * ZZ;
float ZZZ = p_quat[2] * ZZ;
(*m_data)[0][0] = 1 - (YYY + ZZZ);
(*m_data)[1][0] = XYY + WZZ;
(*m_data)[2][0] = XZZ - WYY;
(*m_data)[0][1] = XYY - WZZ;
(*m_data)[1][1] = 1 - (XXX + ZZZ);
(*m_data)[2][1] = YZZ + WXX;
(*m_data)[0][2] = XZZ + WYY;
(*m_data)[1][2] = YZZ - WXX;
(*m_data)[2][2] = 1 - (XXX + YYY);
(*m_data)[3][0] = 0;
(*m_data)[3][1] = 0;
(*m_data)[3][2] = 0;
(*m_data)[3][3] = 1;
(*m_data)[0][3] = 0;
(*m_data)[1][3] = 0;
(*m_data)[2][3] = 0;
return 0;
}
return -1;
}
inline float& operator[](size_t idx) { return ((float*) m_data)[idx]; }
@ -80,10 +223,11 @@ class Matrix4Data : public Matrix4Impl {
inline Matrix4Data(Matrix4Data& p_other) : Matrix4Impl(m_matrix) { m_matrix = *p_other.m_data; }
inline Matrix4& GetMatrix() { return *m_data; }
// No idea why there's another equals. Maybe to some other type like the
// DirectX Retained Mode Matrix type which is also a float* alias?
// vtable + 0x44
virtual void operator=(const Matrix4Data& p_other);
// FUNCTION: LEGO1 0x10002850
virtual void Matrix4Data::operator=(const Matrix4Impl& p_other) { EqualsMatrixImpl(&p_other); }
// FUNCTION: LEGO1 0x10002860
virtual void Matrix4Data::operator=(const Matrix4Data& p_other) { EqualsMatrixImpl(&p_other); }
Matrix4 m_matrix;
};

4
LEGO1/realtime/orientableroi.h
View File

@ -23,13 +23,11 @@ class OrientableROI : public ROI {
virtual const BoundingBox& GetWorldBoundingBox() const;
virtual const BoundingSphere& GetWorldBoundingSphere() const;
protected:
// vtable + 0x14
virtual void VTable0x14() { VTable0x1c(); }
virtual void UpdateWorldBoundingVolumes() = 0;
public:
virtual void VTable0x1c();
// vtable + 0x20
virtual void SetLocalTransform(const Matrix4Impl& p_transform);
virtual void VTable0x24(const Matrix4Data& p_transform);

447
LEGO1/realtime/vector.cpp
View File

@ -11,450 +11,3 @@ DECOMP_SIZE_ASSERT(Vector3Impl, 0x8);
DECOMP_SIZE_ASSERT(Vector4Impl, 0x8);
DECOMP_SIZE_ASSERT(Vector3Data, 0x14);
DECOMP_SIZE_ASSERT(Vector4Data, 0x18);
// FUNCTION: LEGO1 0x10001f80
void Vector2Impl::AddVectorImpl(float* p_value)
{
m_data[0] += p_value[0];
m_data[1] += p_value[1];
}
// FUNCTION: LEGO1 0x10001fa0
void Vector2Impl::AddScalarImpl(float p_value)
{
m_data[0] += p_value;
m_data[1] += p_value;
}
// FUNCTION: LEGO1 0x10001fc0
void Vector2Impl::SubVectorImpl(float* p_value)
{
m_data[0] -= p_value[0];
m_data[1] -= p_value[1];
}
// FUNCTION: LEGO1 0x10001fe0
void Vector2Impl::MullVectorImpl(float* p_value)
{
m_data[0] *= p_value[0];
m_data[1] *= p_value[1];
}
// FUNCTION: LEGO1 0x10002000
void Vector2Impl::MullScalarImpl(float* p_value)
{
m_data[0] *= *p_value;
m_data[1] *= *p_value;
}
// FUNCTION: LEGO1 0x10002020
void Vector2Impl::DivScalarImpl(float* p_value)
{
m_data[0] /= *p_value;
m_data[1] /= *p_value;
}
// FUNCTION: LEGO1 0x10002040
float Vector2Impl::DotImpl(float* p_a, float* p_b) const
{
return p_b[0] * p_a[0] + p_b[1] * p_a[1];
}
// FUNCTION: LEGO1 0x10002060
// Vector2Impl::SetData
// FUNCTION: LEGO1 0x10002070
void Vector2Impl::EqualsImpl(float* p_data)
{
float* vec = m_data;
vec[0] = p_data[0];
vec[1] = p_data[1];
}
// FUNCTION: LEGO1 0x10002090
float* Vector2Impl::GetData()
{
return m_data;
}
// FUNCTION: LEGO1 0x100020a0
const float* Vector2Impl::GetData() const
{
return m_data;
}
// FUNCTION: LEGO1 0x100020b0
void Vector2Impl::Clear()
{
float* vec = m_data;
vec[0] = 0.0f;
vec[1] = 0.0f;
}
// FUNCTION: LEGO1 0x100020d0
float Vector2Impl::Dot(float* p_a, float* p_b) const
{
return DotImpl(p_a, p_b);
}
// FUNCTION: LEGO1 0x100020f0
float Vector2Impl::Dot(Vector2Impl* p_a, Vector2Impl* p_b) const
{
return DotImpl(p_a->m_data, p_b->m_data);
}
// FUNCTION: LEGO1 0x10002110
float Vector2Impl::Dot(float* p_a, Vector2Impl* p_b) const
{
return DotImpl(p_a, p_b->m_data);
}
// FUNCTION: LEGO1 0x10002130
float Vector2Impl::Dot(Vector2Impl* p_a, float* p_b) const
{
return DotImpl(p_a->m_data, p_b);
}
// FUNCTION: LEGO1 0x10002150
float Vector2Impl::LenSquared() const
{
return m_data[0] * m_data[0] + m_data[1] * m_data[1];
}
// FUNCTION: LEGO1 0x10002160
int Vector2Impl::Unitize()
{
float sq = LenSquared();
if (sq > 0.0f) {
float root = sqrt(sq);
if (root > 0) {
DivScalarImpl(&root);
return 0;
}
}
return -1;
}
// FUNCTION: LEGO1 0x100021c0
void Vector2Impl::AddScalar(float p_value)
{
AddScalarImpl(p_value);
}
// FUNCTION: LEGO1 0x100021d0
void Vector2Impl::AddVector(float* p_other)
{
AddVectorImpl(p_other);
}
// FUNCTION: LEGO1 0x100021e0
void Vector2Impl::AddVector(Vector2Impl* p_other)
{
AddVectorImpl(p_other->m_data);
}
// FUNCTION: LEGO1 0x100021f0
void Vector2Impl::SubVector(float* p_other)
{
SubVectorImpl(p_other);
}
// FUNCTION: LEGO1 0x10002200
void Vector2Impl::SubVector(Vector2Impl* p_other)
{
SubVectorImpl(p_other->m_data);
}
// FUNCTION: LEGO1 0x10002210
void Vector2Impl::MullVector(float* p_other)
{
MullVectorImpl(p_other);
}
// FUNCTION: LEGO1 0x10002220
void Vector2Impl::MullVector(Vector2Impl* p_other)
{
MullVectorImpl(p_other->m_data);
}
// FUNCTION: LEGO1 0x10002230
void Vector2Impl::MullScalar(float* p_value)
{
MullScalarImpl(p_value);
}
// FUNCTION: LEGO1 0x10002240
void Vector2Impl::DivScalar(float* p_value)
{
DivScalarImpl(p_value);
}
// FUNCTION: LEGO1 0x10002250
void Vector2Impl::SetVector(float* p_other)
{
EqualsImpl(p_other);
}
// FUNCTION: LEGO1 0x10002260
void Vector2Impl::SetVector(Vector2Impl* p_other)
{
EqualsImpl(p_other->m_data);
}
// FUNCTION: LEGO1 0x10002270
void Vector3Impl::EqualsCrossImpl(float* p_a, 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
void Vector3Impl::EqualsCross(Vector3Impl* p_a, Vector3Impl* p_b)
{
EqualsCrossImpl(p_a->m_data, p_b->m_data);
}
// FUNCTION: LEGO1 0x100022e0
void Vector3Impl::EqualsCross(Vector3Impl* p_a, float* p_b)
{
EqualsCrossImpl(p_a->m_data, p_b);
}
// FUNCTION: LEGO1 0x10002300
void Vector3Impl::EqualsCross(float* p_a, Vector3Impl* p_b)
{
EqualsCrossImpl(p_a, p_b->m_data);
}
// FUNCTION: LEGO1 0x10002870
void Vector4Impl::AddVectorImpl(float* p_value)
{
m_data[0] += p_value[0];
m_data[1] += p_value[1];
m_data[2] += p_value[2];
m_data[3] += p_value[3];
}
// FUNCTION: LEGO1 0x100028b0
void Vector4Impl::AddScalarImpl(float p_value)
{
m_data[0] += p_value;
m_data[1] += p_value;
m_data[2] += p_value;
m_data[3] += p_value;
}
// FUNCTION: LEGO1 0x100028f0
void Vector4Impl::SubVectorImpl(float* p_value)
{
m_data[0] -= p_value[0];
m_data[1] -= p_value[1];
m_data[2] -= p_value[2];
m_data[3] -= p_value[3];
}
// FUNCTION: LEGO1 0x10002930
void Vector4Impl::MullVectorImpl(float* p_value)
{
m_data[0] *= p_value[0];
m_data[1] *= p_value[1];
m_data[2] *= p_value[2];
m_data[3] *= p_value[3];
}
// FUNCTION: LEGO1 0x10002970
void Vector4Impl::MullScalarImpl(float* p_value)
{
m_data[0] *= *p_value;
m_data[1] *= *p_value;
m_data[2] *= *p_value;
m_data[3] *= *p_value;
}
// FUNCTION: LEGO1 0x100029b0
void Vector4Impl::DivScalarImpl(float* p_value)
{
m_data[0] /= *p_value;
m_data[1] /= *p_value;
m_data[2] /= *p_value;
m_data[3] /= *p_value;
}
// FUNCTION: LEGO1 0x100029f0
float Vector4Impl::DotImpl(float* p_a, 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]);
}
// FUNCTION: LEGO1 0x10002a20
void Vector4Impl::EqualsImpl(float* p_data)
{
float* vec = m_data;
vec[0] = p_data[0];
vec[1] = p_data[1];
vec[2] = p_data[2];
vec[3] = p_data[3];
}
// FUNCTION: LEGO1 0x10002a40
void Vector4Impl::SetMatrixProductImpl(float* p_vec, 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];
}
// FUNCTION: LEGO1 0x10002ae0
void Vector4Impl::SetMatrixProduct(Vector4Impl* p_a, float* p_b)
{
SetMatrixProductImpl(p_a->m_data, p_b);
}
// FUNCTION: LEGO1 0x10002b00
void Vector4Impl::Clear()
{
float* vec = m_data;
vec[0] = 0.0f;
vec[1] = 0.0f;
vec[2] = 0.0f;
vec[3] = 0.0f;
}
// FUNCTION: LEGO1 0x10002b20
float Vector4Impl::LenSquared() const
{
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];
}
// FUNCTION: LEGO1 0x10002b40
void Vector4Impl::EqualsScalar(float* p_value)
{
m_data[0] = *p_value;
m_data[1] = *p_value;
m_data[2] = *p_value;
m_data[3] = *p_value;
}
// Note close yet, included because I'm at least confident I know what operation
// it's trying to do.
// STUB: LEGO1 0x10002b70
int Vector4Impl::NormalizeQuaternion()
{
float* v = m_data;
float magnitude = v[1] * v[1] + v[2] * v[2] + v[0] * v[0];
if (magnitude > 0.0f) {
float theta = v[3] * 0.5f;
v[3] = cos(theta);
float frac = sin(theta);
magnitude = frac / sqrt(magnitude);
v[0] *= magnitude;
v[1] *= magnitude;
v[2] *= magnitude;
return 0;
}
return -1;
}
// FUNCTION: LEGO1 0x10002bf0
void Vector4Impl::UnknownQuaternionOp(Vector4Impl* p_a, Vector4Impl* p_b)
{
float* bDat = p_b->m_data;
float* aDat = p_a->m_data;
this->m_data[3] = aDat[3] * bDat[3] - (bDat[0] * aDat[0] + aDat[2] * bDat[2] + aDat[1] * aDat[1]);
this->m_data[0] = bDat[2] * aDat[1] - bDat[1] * aDat[2];
this->m_data[1] = aDat[2] * bDat[0] - bDat[2] * aDat[0];
this->m_data[2] = bDat[1] * aDat[0] - aDat[1] * bDat[0];
m_data[0] = p_b->m_data[3] * p_a->m_data[0] + p_a->m_data[3] * p_b->m_data[0] + m_data[0];
m_data[1] = p_b->m_data[1] * p_a->m_data[3] + p_a->m_data[1] * p_b->m_data[3] + m_data[1];
m_data[2] = p_b->m_data[2] * p_a->m_data[3] + p_a->m_data[2] * p_b->m_data[3] + m_data[2];
}
// FUNCTION: LEGO1 0x10003a60
void Vector3Impl::AddVectorImpl(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 Vector3Impl::AddScalarImpl(float p_value)
{
m_data[0] += p_value;
m_data[1] += p_value;
m_data[2] += p_value;
}
// FUNCTION: LEGO1 0x10003ac0
void Vector3Impl::SubVectorImpl(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 Vector3Impl::MullVectorImpl(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 Vector3Impl::MullScalarImpl(float* p_value)
{
m_data[0] *= *p_value;
m_data[1] *= *p_value;
m_data[2] *= *p_value;
}
// FUNCTION: LEGO1 0x10003b50
void Vector3Impl::DivScalarImpl(float* p_value)
{
m_data[0] /= *p_value;
m_data[1] /= *p_value;
m_data[2] /= *p_value;
}
// FUNCTION: LEGO1 0x10003b80
float Vector3Impl::DotImpl(float* p_a, 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
void Vector3Impl::EqualsImpl(float* p_data)
{
float* vec = m_data;
vec[0] = p_data[0];
vec[1] = p_data[1];
vec[2] = p_data[2];
}
// FUNCTION: LEGO1 0x10003bc0
void Vector3Impl::Clear()
{
float* vec = m_data;
vec[0] = 0.0f;
vec[1] = 0.0f;
vec[2] = 0.0f;
}
// FUNCTION: LEGO1 0x10003bd0
float Vector3Impl::LenSquared() const
{
return m_data[1] * m_data[1] + m_data[0] * m_data[0] + m_data[2] * m_data[2];
}
// FUNCTION: LEGO1 0x10003bf0
void Vector3Impl::EqualsScalar(float* p_value)
{
m_data[0] = *p_value;
m_data[1] = *p_value;
m_data[2] = *p_value;
}

428
LEGO1/realtime/vector.h
View File

@ -64,54 +64,139 @@ struct Vector4 {
// SIZE 0x8
class Vector2Impl {
public:
inline Vector2Impl(float* p_data) { this->SetData(p_data); }
inline Vector2Impl(float* p_data) { m_data = p_data; }
// vtable + 0x00 (no virtual destructor)
virtual void AddScalarImpl(float p_value) = 0;
virtual void AddVectorImpl(float* p_value) = 0;
virtual void SubVectorImpl(float* p_value) = 0;
virtual void MullScalarImpl(float* p_value) = 0;
// FUNCTION: LEGO1 0x10001f80
virtual void AddImpl(float* p_value)
{
m_data[0] += p_value[0];
m_data[1] += p_value[1];
}
// vtable + 0x10
virtual void MullVectorImpl(float* p_value) = 0;
virtual void DivScalarImpl(float* p_value) = 0;
virtual float DotImpl(float* p_a, float* p_b) const = 0;
// FUNCTION: LEGO1 0x10001fa0
virtual void AddImpl(float p_value)
{
m_data[0] += p_value;
m_data[1] += p_value;
}
// FUNCTION: LEGO1 0x10001fc0
virtual void SubImpl(float* p_value)
{
m_data[0] -= p_value[0];
m_data[1] -= p_value[1];
}
// FUNCTION: LEGO1 0x10001fe0
virtual void MulImpl(float* p_value)
{
m_data[0] *= p_value[0];
m_data[1] *= p_value[1];
}
// FUNCTION: LEGO1 0x10002000
virtual void MulImpl(float& p_value)
{
m_data[0] *= p_value;
m_data[1] *= p_value;
}
// FUNCTION: LEGO1 0x10002020
virtual void DivImpl(float* p_value)
{
m_data[0] /= *p_value;
m_data[1] /= *p_value;
}
// FUNCTION: LEGO1 0x10002040
virtual float DotImpl(float* p_a, float* p_b) const { return p_b[0] * p_a[0] + p_b[1] * p_a[1]; }
// FUNCTION: LEGO1 0x10002060
virtual void SetData(float* p_data) { this->m_data = p_data; }
// vtable + 0x20
virtual void EqualsImpl(float* p_data) = 0;
virtual float* GetData();
virtual const float* GetData() const;
virtual void Clear() = 0;
// FUNCTION: LEGO1 0x10002070
virtual void EqualsImpl(float* p_data)
{
float* vec = m_data;
vec[0] = p_data[0];
vec[1] = p_data[1];
}
// vtable + 0x30
virtual float Dot(Vector2Impl* p_a, float* p_b) const;
virtual float Dot(float* p_a, Vector2Impl* p_b) const;
virtual float Dot(Vector2Impl* p_a, Vector2Impl* p_b) const;
virtual float Dot(float* p_a, float* p_b) const;
// FUNCTION: LEGO1 0x10002090
virtual float* GetData() { return m_data; }
// vtable + 0x40
virtual float LenSquared() const = 0;
virtual int Unitize();
// FUNCTION: LEGO1 0x100020a0
virtual const float* GetData() const { return m_data; }
// vtable + 0x48
virtual void AddVector(Vector2Impl* p_other);
virtual void AddVector(float* p_other);
virtual void AddScalar(float p_value);
// FUNCTION: LEGO1 0x100020b0
virtual void Clear()
{
float* vec = m_data;
vec[0] = 0.0f;
vec[1] = 0.0f;
}
// vtable + 0x54
virtual void SubVector(Vector2Impl* p_other);
virtual void SubVector(float* p_other);
// FUNCTION: LEGO1 0x100020d0
virtual float Dot(float* p_a, float* p_b) const { return DotImpl(p_a, p_b); }
// vtable + 0x5C
virtual void MullScalar(float* p_value);
virtual void MullVector(Vector2Impl* p_other);
virtual void MullVector(float* p_other);
virtual void DivScalar(float* p_value);
// FUNCTION: LEGO1 0x100020f0
virtual float Dot(Vector2Impl* p_a, Vector2Impl* p_b) const { return DotImpl(p_a->m_data, p_b->m_data); }
// vtable + 0x6C
virtual void SetVector(Vector2Impl* p_other);
virtual void SetVector(float* p_other);
// FUNCTION: LEGO1 0x10002110
virtual float Dot(float* p_a, Vector2Impl* p_b) const { return DotImpl(p_a, p_b->m_data); }
// FUNCTION: LEGO1 0x10002130
virtual float Dot(Vector2Impl* p_a, float* p_b) const { return DotImpl(p_a->m_data, p_b); }
// FUNCTION: LEGO1 0x10002150
virtual float LenSquared() { return NORMSQRD2(m_data); }
// FUNCTION: LEGO1 0x10002160
virtual int Normalize()
{
float sq = LenSquared();
if (sq > 0.0f) {
float root = sqrt(sq);
if (root > 0) {
Div(&root);
return 0;
}
}
return -1;
}
// FUNCTION: LEGO1 0x100021c0
virtual void Add(float p_value) { AddImpl(p_value); }
// FUNCTION: LEGO1 0x100021d0
virtual void Add(float* p_other) { AddImpl(p_other); }
// FUNCTION: LEGO1 0x100021e0
virtual void Add(Vector2Impl* p_other) { AddImpl(p_other->m_data); }
// FUNCTION: LEGO1 0x100021f0
virtual void Sub(float* p_other) { SubImpl(p_other); }
// FUNCTION: LEGO1 0x10002200
virtual void Sub(Vector2Impl* p_other) { SubImpl(p_other->m_data); }
// FUNCTION: LEGO1 0x10002210
virtual void Mul(float* p_other) { MulImpl(p_other); }
// FUNCTION: LEGO1 0x10002220
virtual void Mul(Vector2Impl* p_other) { MulImpl(p_other->m_data); }
// FUNCTION: LEGO1 0x10002230
virtual void Mul(float& p_value) { MulImpl(p_value); }
// FUNCTION: LEGO1 0x10002240
virtual void Div(float* p_value) { DivImpl(p_value); }
// FUNCTION: LEGO1 0x10002250
virtual void SetVector(float* p_other) { EqualsImpl(p_other); }
// FUNCTION: LEGO1 0x10002260
virtual void SetVector(Vector2Impl* p_other) { EqualsImpl(p_other->m_data); }
inline float& operator[](size_t idx) { return m_data[idx]; }
inline const float& operator[](size_t idx) const { return m_data[idx]; }
@ -125,29 +210,103 @@ class Vector2Impl {
class Vector3Impl : public Vector2Impl {
public:
inline Vector3Impl(float* p_data) : Vector2Impl(p_data) {}
// FUNCTION: LEGO1 0x10003a90
virtual void AddImpl(float p_value)
{
m_data[0] += p_value;
m_data[1] += p_value;
m_data[2] += p_value;
}
void AddScalarImpl(float p_value);
// FUNCTION: LEGO1 0x10003a60
virtual void AddImpl(float* p_value)
{
m_data[0] += p_value[0];
m_data[1] += p_value[1];
m_data[2] += p_value[2];
}
void AddVectorImpl(float* p_value);
// FUNCTION: LEGO1 0x10003ac0
virtual void SubImpl(float* p_value)
{
m_data[0] -= p_value[0];
m_data[1] -= p_value[1];
m_data[2] -= p_value[2];
}
void SubVectorImpl(float* p_value);
void MullScalarImpl(float* p_value);
void MullVectorImpl(float* p_value);
void DivScalarImpl(float* p_value);
float DotImpl(float* p_a, float* p_b) const;
// FUNCTION: LEGO1 0x10003b20
virtual void MulImpl(float& p_value)
{
m_data[0] *= p_value;
m_data[1] *= p_value;
m_data[2] *= p_value;
}
void EqualsImpl(float* p_data);
// FUNCTION: LEGO1 0x10003af0
virtual void MulImpl(float* p_value)
{
m_data[0] *= p_value[0];
m_data[1] *= p_value[1];
m_data[2] *= p_value[2];
}
void Clear();
// FUNCTION: LEGO1 0x10003b50
virtual void DivImpl(float* p_value)
{
m_data[0] /= *p_value;
m_data[1] /= *p_value;
m_data[2] /= *p_value;
}
float LenSquared() const;
// FUNCTION: LEGO1 0x10003b80
virtual float DotImpl(float* p_a, 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
virtual void EqualsImpl(float* p_data)
{
float* vec = m_data;
vec[0] = p_data[0];
vec[1] = p_data[1];
vec[2] = p_data[2];
}
// FUNCTION: LEGO1 0x10003bc0
virtual void Clear()
{
float* vec = m_data;
vec[0] = 0.0f;
vec[1] = 0.0f;
vec[2] = 0.0f;
}
// FUNCTION: LEGO1 0x10003bd0
virtual float LenSquared() const { return m_data[1] * m_data[1] + m_data[0] * m_data[0] + m_data[2] * m_data[2]; }
// FUNCTION: LEGO1 0x10003bf0
virtual void EqualsScalar(float* p_value)
{
m_data[0] = *p_value;
m_data[1] = *p_value;
m_data[2] = *p_value;
}
// vtable + 0x74
virtual void EqualsCrossImpl(float* p_a, float* p_b);
virtual void EqualsCross(float* p_a, Vector3Impl* p_b);
virtual void EqualsCross(Vector3Impl* p_a, float* p_b);
virtual void EqualsCross(Vector3Impl* p_a, Vector3Impl* p_b);
virtual void EqualsScalar(float* p_value);
// FUNCTION: LEGO1 0x10002270
virtual void EqualsCrossImpl(float* p_a, 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 0x10002300
virtual void EqualsCross(float* p_a, Vector3Impl* p_b) { EqualsCrossImpl(p_a, p_b->m_data); }
// FUNCTION: LEGO1 0x100022e0
virtual void EqualsCross(Vector3Impl* p_a, float* p_b) { EqualsCrossImpl(p_a->m_data, p_b); }
// FUNCTION: LEGO1 0x100022c0
virtual void EqualsCross(Vector3Impl* p_a, Vector3Impl* p_b) { EqualsCrossImpl(p_a->m_data, p_b->m_data); }
inline void Fill(float p_value) { EqualsScalar(&p_value); }
};
@ -158,29 +317,148 @@ class Vector4Impl : public Vector3Impl {
public:
inline Vector4Impl(float* p_data) : Vector3Impl(p_data) {}
void AddScalarImpl(float p_value);
// FUNCTION: LEGO1 0x10002870
virtual void AddImpl(float* p_value)
{
m_data[0] += p_value[0];
m_data[1] += p_value[1];
m_data[2] += p_value[2];
m_data[3] += p_value[3];
}
void AddVectorImpl(float* p_value);
// FUNCTION: LEGO1 0x100028b0
virtual void AddImpl(float p_value)
{
m_data[0] += p_value;
m_data[1] += p_value;
m_data[2] += p_value;
m_data[3] += p_value;
}
void SubVectorImpl(float* p_value);
void MullScalarImpl(float* p_value);
void MullVectorImpl(float* p_value);
void DivScalarImpl(float* p_value);
float DotImpl(float* p_a, float* p_b) const;
// FUNCTION: LEGO1 0x100028f0
virtual void SubImpl(float* p_value)
{
m_data[0] -= p_value[0];
m_data[1] -= p_value[1];
m_data[2] -= p_value[2];
m_data[3] -= p_value[3];
}
void EqualsImpl(float* p_data);
// FUNCTION: LEGO1 0x10002930
virtual void MulImpl(float* p_value)
{
m_data[0] *= p_value[0];
m_data[1] *= p_value[1];
m_data[2] *= p_value[2];
m_data[3] *= p_value[3];
}
void Clear();
// FUNCTION: LEGO1 0x10002970
virtual void MulImpl(float& p_value)
{
m_data[0] *= p_value;
m_data[1] *= p_value;
m_data[2] *= p_value;
m_data[3] *= p_value;
}
float LenSquared() const;
// FUNCTION: LEGO1 0x100029b0
virtual void DivImpl(float* p_value)
{
m_data[0] /= *p_value;
m_data[1] /= *p_value;
m_data[2] /= *p_value;
m_data[3] /= *p_value;
}
void EqualsScalar(float* p_value);
// FUNCTION: LEGO1 0x100029f0
virtual float DotImpl(float* p_a, 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]);
}
// vtable + 0x84
virtual void SetMatrixProduct(Vector4Impl* p_a, float* p_b);
virtual void SetMatrixProductImpl(float* p_vec, float* p_mat);
virtual int NormalizeQuaternion();
virtual void UnknownQuaternionOp(Vector4Impl* p_a, Vector4Impl* p_b);
// FUNCTION: LEGO1 0x10002a20
virtual void EqualsImpl(float* p_data)
{
float* vec = m_data;
vec[0] = p_data[0];
vec[1] = p_data[1];
vec[2] = p_data[2];
vec[3] = p_data[3];
}
// FUNCTION: LEGO1 0x10002a40
virtual void SetMatrixProductImpl(float* p_vec, 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];
}
// FUNCTION: LEGO1 0x10002ae0
virtual void SetMatrixProduct(Vector4Impl* p_a, float* p_b) { SetMatrixProductImpl(p_a->m_data, p_b); }
// FUNCTION: LEGO1 0x10002b00
virtual void Clear()
{
float* vec = m_data;
vec[0] = 0.0f;
vec[1] = 0.0f;
vec[2] = 0.0f;
vec[3] = 0.0f;
}
// FUNCTION: LEGO1 0x10002b20
virtual float LenSquared() const
{
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];
}
// FUNCTION: LEGO1 0x10002b40
virtual void EqualsScalar(float* p_value)
{
m_data[0] = *p_value;
m_data[1] = *p_value;
m_data[2] = *p_value;
m_data[3] = *p_value;
}
// Note close yet, included because I'm at least confident I know what operation
// it's trying to do.
// STUB: LEGO1 0x10002b70
virtual int NormalizeQuaternion()
{
float* v = m_data;
float magnitude = v[1] * v[1] + v[2] * v[2] + v[0] * v[0];
if (magnitude > 0.0f) {
float theta = v[3] * 0.5f;
v[3] = cos(theta);
float frac = sin(theta);
magnitude = frac / sqrt(magnitude);
v[0] *= magnitude;
v[1] *= magnitude;
v[2] *= magnitude;
return 0;
}
return -1;
}
// FUNCTION: LEGO1 0x10002bf0
virtual void UnknownQuaternionOp(Vector4Impl* p_a, Vector4Impl* p_b)
{
float* bDat = p_b->m_data;
float* aDat = p_a->m_data;
this->m_data[3] = aDat[3] * bDat[3] - (bDat[0] * aDat[0] + aDat[2] * bDat[2] + aDat[1] * aDat[1]);
this->m_data[0] = bDat[2] * aDat[1] - bDat[1] * aDat[2];
this->m_data[1] = aDat[2] * bDat[0] - bDat[2] * aDat[0];
this->m_data[2] = bDat[1] * aDat[0] - aDat[1] * bDat[0];
m_data[0] = p_b->m_data[3] * p_a->m_data[0] + p_a->m_data[3] * p_b->m_data[0] + m_data[0];
m_data[1] = p_b->m_data[1] * p_a->m_data[3] + p_a->m_data[1] * p_b->m_data[3] + m_data[1];
m_data[2] = p_b->m_data[2] * p_a->m_data[3] + p_a->m_data[2] * p_b->m_data[3] + m_data[2];
}
};
// VTABLE: LEGO1 0x100d4488
@ -189,17 +467,25 @@ class Vector3Data : public Vector3Impl {
public:
inline Vector3Data() : Vector3Impl(m_vector.elements) {}
inline Vector3Data(float p_x, float p_y, float p_z) : Vector3Impl(m_vector.elements), m_vector(p_x, p_y, p_z) {}
inline Vector3Data& operator=(Vector3Data& p_other)
{
EqualsImpl(p_other.m_data);
SET3(m_vector, p_other.m_vector);
return *this;
}
void CopyFrom(Vector3Data& p_other)
inline void CopyFrom(Vector3Data& p_other)
{
EqualsImpl(p_other.m_data);
float* dest = m_vector.elements;
float* src = p_other.m_vector.elements;
for (size_t i = sizeof(m_vector) / sizeof(float); i > 0; --i)
for (; dest < (m_vector.elements + 3);)
*dest++ = *src++;
}
inline void EqualsCross(Vector3Data& p_a, Vector3Data& p_b) { EqualsCrossImpl(p_a.m_data, p_b.m_data); }
private:
Vector3 m_vector;
};

6
LEGO1/score.cpp
View File

@ -22,12 +22,6 @@ Score::Score()
NotificationManager()->Register(this);
}
// FUNCTION: LEGO1 0x100010b0
MxBool Score::VTable0x5c()
{
return TRUE;
}
// FUNCTION: LEGO1 0x10001200
Score::~Score()
{

4
LEGO1/score.h
View File

@ -15,6 +15,9 @@ class Score : public LegoWorld {
virtual ~Score() override; // vtable+0x0
virtual MxLong Notify(MxParam& p) override; // vtable+0x4
// FUNCTION: LEGO1 0x100010b0
MxBool VTable0x5c() { return TRUE; }
// FUNCTION: LEGO1 0x100010c0
inline virtual const char* ClassName() const override // vtable+0x0c
{
@ -33,7 +36,6 @@ class Score : public LegoWorld {
virtual MxResult Create(MxDSObject& p_dsObject) override; // vtable+18
virtual void Stop() override; // vtable+50
virtual MxBool VTable0x5c() override; // vtable+5c
virtual MxBool VTable0x64() override; // vtable+64
virtual void VTable0x68(MxBool p_add) override; // vtable+68

2
LEGO1/viewmanager/viewlodlist.h
View File

@ -44,7 +44,7 @@ class ViewLODList : public LODList<ViewLOD> {
// ??? for now, until we have symbol management
typedef const char* ROIName;
struct ROINameComparator {
bool operator()(const ROIName& rName1, const ROIName& rName2) const
int operator()(const ROIName& rName1, const ROIName& rName2) const
{
return strcmp((const char*) rName1, (const char*) rName2) > 0;
}