Reorganize sources and files (#414)

* Reorganize sources

* Refactor

* Remove relative paths

* Renames

* Fix gitignore

* Remove stuff

* Try fixing format script

* Fix format

* Fix format

* Fix naming script

* Test format

* Fix format

LEGO1/lego/legoomni/include/act1state.h

@@ -0,0 +1,33 @@
+#ifndef ACT1STATE_H
+#define ACT1STATE_H
+
+#include "legostate.h"
+
+// VTABLE: LEGO1 0x100d7028
+// SIZE 0x26c
+class Act1State : public LegoState {
+public:
+	Act1State();
+
+	// FUNCTION: LEGO1 0x100338a0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0154
+		return "Act1State";
+	};
+
+	// FUNCTION: LEGO1 0x100338b0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Act1State::ClassName()) || LegoState::IsA(p_name);
+	};
+
+	inline void SetUnknown18(MxU32 p_unk0x18) { m_unk0x18 = p_unk0x18; }
+	inline MxU32 GetUnknown18() { return m_unk0x18; }
+
+protected:
+	undefined m_unk0x8[0x10]; // 0x8
+	MxU32 m_unk0x18;          // 0x18
+};
+
+#endif // ACT1STATE_H

LEGO1/lego/legoomni/include/act2brick.h

@@ -0,0 +1,30 @@
+#ifndef ACT2BRICK_H
+#define ACT2BRICK_H
+
+#include "legopathactor.h"
+
+// VTABLE: LEGO1 0x100d9b60
+// SIZE 0x194
+class Act2Brick : public LegoPathActor {
+public:
+	Act2Brick();
+	virtual ~Act2Brick() override; // vtable+0x0
+
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+0x4
+	virtual MxResult Tickle() override;               // vtable+0x08
+
+	// FUNCTION: LEGO1 0x1007a360
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0438
+		return "Act2Brick";
+	}
+
+	// FUNCTION: LEGO1 0x1007a370
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Act2Brick::ClassName()) || LegoEntity::IsA(p_name);
+	}
+};
+
+#endif // ACT2BRICK_H

LEGO1/lego/legoomni/include/act2policestation.h

@@ -0,0 +1,26 @@
+#ifndef ACT2POLICESTATION_H
+#define ACT2POLICESTATION_H
+
+#include "legoentity.h"
+
+// VTABLE: LEGO1 0x100d53a8
+// SIZE 0x68
+class Act2PoliceStation : public LegoEntity {
+public:
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+0x4
+
+	// FUNCTION: LEGO1 0x1000e200
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f03fc
+		return "Act2PoliceStation";
+	}
+
+	// FUNCTION: LEGO1 0x1000e210
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Act2PoliceStation::ClassName()) || LegoEntity::IsA(p_name);
+	}
+};
+
+#endif // ACT2POLICESTATION_H

LEGO1/lego/legoomni/include/act3.h

@@ -0,0 +1,37 @@
+#ifndef ACT3_H
+#define ACT3_H
+
+#include "legoworld.h"
+
+// VTABLE: LEGO1 0x100d9628
+// SIZE 0x4274
+class Act3 : public LegoWorld {
+public:
+	Act3();
+
+	virtual ~Act3() override; // vtable+00
+
+	// FUNCTION: LEGO1 0x10072510
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f013c
+		return "Act3";
+	}
+
+	// FUNCTION: LEGO1 0x10072520
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Act3::ClassName()) || LegoWorld::IsA(p_name);
+	}
+
+	inline void SetUnkown420c(MxEntity* p_entity) { m_unk0x420c = p_entity; }
+	inline void SetUnkown4270(MxU32 p_unk0x4270) { m_unk0x4270 = p_unk0x4270; }
+
+protected:
+	undefined m_unk0xf8[0x4114]; // 0xf8
+	MxEntity* m_unk0x420c;       // 0x420c
+	undefined m_unk0x4210[0x60]; // 0x4210
+	MxU32 m_unk0x4270;           // 0x4270
+};
+
+#endif // ACT3_H

LEGO1/lego/legoomni/include/act3actor.h

@@ -0,0 +1,18 @@
+#ifndef ACT3ACTOR_H
+#define ACT3ACTOR_H
+
+#include "mxcore.h"
+
+// FIXME: Uncertain location. There are three vtables which eventually call this
+//        class' ClassName() function, but none of them call it directly.
+class Act3Actor : public MxCore {
+public:
+	// FUNCTION: LEGO1 0x100431b0
+	inline virtual const char* ClassName() const override
+	{
+		// STRING: LEGO1 0x100f03ac
+		return "Act3Actor";
+	}
+};
+
+#endif // ACT3ACTOR_H

LEGO1/lego/legoomni/include/act3shark.h

@@ -0,0 +1,17 @@
+#ifndef ACT3SHARK_H
+#define ACT3SHARK_H
+
+#include "legoanimactor.h"
+
+// VTABLE: LEGO1 0x100d7920
+class Act3Shark : public LegoAnimActor {
+public:
+	// FUNCTION: LEGO1 0x100430c0
+	inline virtual const char* ClassName() const override
+	{
+		// STRING: LEGO1 0x100f03a0
+		return "Act3Shark";
+	}
+};
+
+#endif // ACT3SHARK_H

LEGO1/lego/legoomni/include/act3state.h

@@ -0,0 +1,32 @@
+#ifndef ACT3STATE_H
+#define ACT3STATE_H
+
+#include "legostate.h"
+
+// VTABLE: LEGO1 0x100d4fc8
+// SIZE 0xc
+class Act3State : public LegoState {
+public:
+	inline Act3State() { m_unk0x08 = 0; }
+
+	// FUNCTION: LEGO1 0x1000e300
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f03f0
+		return "Act3State";
+	}
+
+	// FUNCTION: LEGO1 0x1000e310
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Act3State::ClassName()) || LegoState::IsA(p_name);
+	}
+
+	virtual MxBool VTable0x14() override;
+
+private:
+	// FIXME: May be part of LegoState? Uncertain...
+	MxU32 m_unk0x08;
+};
+
+#endif // ACT3STATE_H

LEGO1/lego/legoomni/include/ambulance.h

@@ -0,0 +1,41 @@
+#ifndef AMBULANCE_H
+#define AMBULANCE_H
+
+#include "islepathactor.h"
+
+// VTABLE: LEGO1 0x100d71a8
+// SIZE 0x184
+class Ambulance : public IslePathActor {
+public:
+	Ambulance();
+
+	// FUNCTION: LEGO1 0x10035fa0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f03c4
+		return "Ambulance";
+	}
+
+	// FUNCTION: LEGO1 0x10035fb0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Ambulance::ClassName()) || IslePathActor::IsA(p_name);
+	}
+
+private:
+	// TODO: Ambulance fields
+	undefined m_unk0x160[4];
+	MxS32 m_unk0x164;
+	MxS16 m_unk0x168;
+	MxS16 m_unk0x16a;
+	MxS16 m_unk0x16c;
+	MxS16 m_unk0x16e;
+	MxS16 m_unk0x170;
+	MxS16 m_unk0x172;
+	MxS32 m_unk0x174;
+	MxS32 m_unk0x178;
+	MxFloat m_unk0x17c;
+	undefined m_unk0x180[4];
+};
+
+#endif // AMBULANCE_H

LEGO1/lego/legoomni/include/ambulancemissionstate.h

@@ -0,0 +1,58 @@
+#ifndef AMBULANCEMISSIONSTATE_H
+#define AMBULANCEMISSIONSTATE_H
+
+#include "legostate.h"
+
+// VTABLE: LEGO1 0x100d72a0
+// SIZE 0x24
+class AmbulanceMissionState : public LegoState {
+public:
+	AmbulanceMissionState();
+
+	// FUNCTION: LEGO1 0x10037600
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f00e8
+		return "AmbulanceMissionState";
+	}
+
+	// FUNCTION: LEGO1 0x10037610
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, AmbulanceMissionState::ClassName()) || LegoState::IsA(p_name);
+	}
+
+	inline MxU16 GetColor(MxU8 p_id)
+	{
+		switch (p_id) {
+		case 1:
+			return m_color1;
+		case 2:
+			return m_color2;
+		case 3:
+			return m_color3;
+		case 4:
+			return m_color4;
+		case 5:
+			return m_color5;
+		default:
+			return 0;
+		}
+	}
+
+protected:
+	undefined4 m_unk0x8; // 0x08
+	undefined4 m_unk0xc; // 0x0c
+	MxU16 m_unk0x10;     // 0x10
+	MxU16 m_unk0x12;     // 0x12
+	MxU16 m_unk0x14;     // 0x14
+	MxU16 m_unk0x16;     // 0x16
+	MxU16 m_unk0x18;     // 0x18
+	MxU16 m_color1;      // 0x1a
+	MxU16 m_color2;      // 0x1c
+	MxU16 m_color3;      // 0x1e
+	MxU16 m_color4;      // 0x20
+	MxU16 m_color5;      // 0x22
+};
+
+#endif // AMBULANCEMISSIONSTATE_H

LEGO1/lego/legoomni/include/animstate.h

@@ -0,0 +1,37 @@
+#ifndef ANIMSTATE_H
+#define ANIMSTATE_H
+
+#include "legostate.h"
+
+// VTABLE: LEGO1 0x100d8d80
+// SIZE 0x1c
+class AnimState : public LegoState {
+public:
+	AnimState();
+	virtual ~AnimState() override; // vtable+0x0
+
+	// FUNCTION: LEGO1 0x10065070
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0460
+		return "AnimState";
+	}
+
+	// FUNCTION: LEGO1 0x10065080
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, AnimState::ClassName()) || LegoState::IsA(p_name);
+	}
+
+	virtual MxBool SetFlag() override;                                      // vtable+0x18
+	virtual MxResult VTable0x1c(LegoFileStream* p_legoFileStream) override; // vtable+0x1C
+
+private:
+	undefined4 m_unk0x8;
+	undefined4 m_unk0xc;
+	void* m_unk0x10;
+	undefined4 m_unk0x14;
+	void* m_unk0x18;
+};
+
+#endif // ANIMSTATE_H

LEGO1/lego/legoomni/include/beachhouseentity.h

@@ -0,0 +1,26 @@
+#ifndef BEACHHOUSEENTITY_H
+#define BEACHHOUSEENTITY_H
+
+#include "buildingentity.h"
+
+// VTABLE: LEGO1 0x100d4a18
+// SIZE 0x68
+class BeachHouseEntity : public BuildingEntity {
+public:
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+04
+
+	// FUNCTION: LEGO1 0x1000ee80
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0314
+		return "BeachHouseEntity";
+	}
+
+	// FUNCTION: LEGO1 0x1000ee90
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, BeachHouseEntity::ClassName()) || BuildingEntity::IsA(p_name);
+	}
+};
+
+#endif // BEACHHOUSEENTITY_H

LEGO1/lego/legoomni/include/bike.h

@@ -0,0 +1,31 @@
+#ifndef BIKE_H
+#define BIKE_H
+
+#include "decomp.h"
+#include "islepathactor.h"
+
+// VTABLE: LEGO1 0x100d9808
+// SIZE 0x164
+class Bike : public IslePathActor {
+public:
+	Bike();
+
+	// FUNCTION: LEGO1 0x100766f0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f03d0
+		return "Bike";
+	}
+
+	// FUNCTION: LEGO1 0x10076700
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Bike::ClassName()) || IslePathActor::IsA(p_name);
+	}
+
+private:
+	// TODO: Bike fields
+	undefined m_unk0x160[4];
+};
+
+#endif // BIKE_H

LEGO1/lego/legoomni/include/buildingentity.h

@@ -0,0 +1,27 @@
+#ifndef BUILDINGENTITY_H
+#define BUILDINGENTITY_H
+
+#include "legoentity.h"
+
+// VTABLE: LEGO1 0x100d5c88
+// SIZE <= 0x68, hard to tell because it's always constructed as a derivative
+class BuildingEntity : public LegoEntity {
+public:
+	BuildingEntity();
+	virtual ~BuildingEntity() override; // vtable+0x0
+
+	// FUNCTION: LEGO1 0x10014f20
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f07e8
+		return "BuildingEntity";
+	}
+
+	// FUNCTION: LEGO1 0x10014f30
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, BuildingEntity::ClassName()) || LegoEntity::IsA(p_name);
+	}
+};
+
+#endif // BUILDINGENTITY_H

LEGO1/lego/legoomni/include/bumpbouy.h

@@ -0,0 +1,24 @@
+#ifndef BUMPBOUY_H
+#define BUMPBOUY_H
+
+#include "legoanimactor.h"
+#include "mxtypes.h"
+
+// VTABLE: LEGO1 0x100d6790
+class BumpBouy : public LegoAnimActor {
+public:
+	// FUNCTION: LEGO1 0x100274e0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0394
+		return "BumpBouy";
+	}
+
+	// FUNCTION: LEGO1 0x10027500
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, BumpBouy::ClassName()) || LegoAnimActor::IsA(p_name);
+	}
+};
+
+#endif // BUMPBOUY_H

LEGO1/lego/legoomni/include/carrace.h

@@ -0,0 +1,31 @@
+#ifndef CARRACE_H
+#define CARRACE_H
+
+#include "decomp.h"
+#include "legorace.h"
+
+// VTABLE: LEGO1 0x100d5e50
+// SIZE 0x154
+class CarRace : public LegoRace {
+public:
+	CarRace();
+
+	// FUNCTION: LEGO1 0x10016b20
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0528
+		return "CarRace";
+	}
+
+	// FUNCTION: LEGO1 0x10016b30
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, CarRace::ClassName()) || LegoRace::IsA(p_name);
+	}
+
+private:
+	undefined m_unk0x144[12]; // 0x144
+	undefined4 m_unk0x150;    // 0x150
+};
+
+#endif // CARRACE_H

LEGO1/lego/legoomni/include/carracestate.h

@@ -0,0 +1,24 @@
+#ifndef CARRACESTATE_H
+#define CARRACESTATE_H
+
+#include "racestate.h"
+
+// VTABLE: LEGO1 0x100d4b70
+// SIZE 0x2c
+class CarRaceState : public RaceState {
+public:
+	// FUNCTION: LEGO1 0x1000dd30
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f009c
+		return "CarRaceState";
+	}
+
+	// FUNCTION: LEGO1 0x1000dd40
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, CarRaceState::ClassName()) || RaceState::IsA(p_name);
+	}
+};
+
+#endif // CARRACESTATE_H

LEGO1/lego/legoomni/include/doors.h

@@ -0,0 +1,24 @@
+#ifndef DOORS_H
+#define DOORS_H
+
+#include "legopathactor.h"
+
+// VTABLE: LEGO1 0x100d4788
+// SIZE 0x1f8
+class Doors : public LegoPathActor {
+public:
+	// FUNCTION: LEGO1 0x1000e430
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f03e8
+		return "Doors";
+	}
+
+	// FUNCTION: LEGO1 0x1000e440
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Doors::ClassName()) || LegoPathActor::IsA(p_name);
+	}
+};
+
+#endif // DOORS_H

LEGO1/lego/legoomni/include/dunebuggy.h

@@ -0,0 +1,33 @@
+#ifndef DUNEBUGGY_H
+#define DUNEBUGGY_H
+
+#include "decomp.h"
+#include "islepathactor.h"
+
+// VTABLE: LEGO1 0x100d8f98
+// SIZE 0x16c
+class DuneBuggy : public IslePathActor {
+public:
+	DuneBuggy();
+
+	// FUNCTION: LEGO1 0x10067c30
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0410
+		return "DuneBuggy";
+	}
+
+	// FUNCTION: LEGO1 0x10067c40
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, DuneBuggy::ClassName()) || IslePathActor::IsA(p_name);
+	}
+
+private:
+	// TODO: Double check DuneBuggy field types
+	undefined4 m_unk0x160;
+	MxFloat m_unk0x164;
+	undefined4 m_unk0x168;
+};
+
+#endif // DUNEBUGGY_H

LEGO1/lego/legoomni/include/elevatorbottom.h

@@ -0,0 +1,28 @@
+#ifndef ELEVATORBOTTOM_H
+#define ELEVATORBOTTOM_H
+
+#include "legoworld.h"
+
+// VTABLE: LEGO1 0x100d5f20
+class ElevatorBottom : public LegoWorld {
+public:
+	ElevatorBottom();
+	virtual ~ElevatorBottom() override; // vtable+0x0
+
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+0x4
+
+	// FUNCTION: LEGO1 0x10017f20
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f04ac
+		return "ElevatorBottom";
+	}
+
+	// FUNCTION: LEGO1 0x10017f30
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, ElevatorBottom::ClassName()) || LegoWorld::IsA(p_name);
+	}
+};
+
+#endif // ELEVATORBOTTOM_H

LEGO1/lego/legoomni/include/extra.h

@@ -0,0 +1,21 @@
+#ifndef EXTRA_H
+#define EXTRA_H
+
+// Items related to the Extra string of key-value pairs found in MxOb
+
+enum ExtraActionType {
+	ExtraActionType_none = 0,
+	ExtraActionType_opendisk = 1,
+	ExtraActionType_openram = 2,
+	ExtraActionType_close = 3,
+	ExtraActionType_start = 4,
+	ExtraActionType_stop = 5,
+	ExtraActionType_run = 6,
+	ExtraActionType_exit = 7,
+	ExtraActionType_enable = 8,
+	ExtraActionType_disable = 9,
+	ExtraActionType_notify = 10,
+	ExtraActionType_unknown = 11,
+};
+
+#endif // EXTRA_H

LEGO1/lego/legoomni/include/gasstation.h

@@ -0,0 +1,31 @@
+#ifndef GASSTATION_H
+#define GASSTATION_H
+
+#include "legoworld.h"
+
+// VTABLE: LEGO1 0x100d4650
+// SIZE 0x128
+// Radio variable at 0x46, in constructor
+class GasStation : public LegoWorld {
+public:
+	GasStation();
+	virtual ~GasStation() override; // vtable+0x0
+
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+0x4
+	virtual MxResult Tickle() override;               // vtable+0x8
+
+	// FUNCTION: LEGO1 0x10004780
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0168
+		return "GasStation";
+	}
+
+	// FUNCTION: LEGO1 0x10004790
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, GasStation::ClassName()) || LegoWorld::IsA(p_name);
+	}
+};
+
+#endif // GASSTATION_H

LEGO1/lego/legoomni/include/gasstationentity.h

@@ -0,0 +1,24 @@
+#ifndef GASSTATIONENTITY_H
+#define GASSTATIONENTITY_H
+
+#include "buildingentity.h"
+
+// VTABLE: LEGO1 0x100d5258
+// SIZE 0x68
+class GasStationEntity : public BuildingEntity {
+public:
+	// FUNCTION: LEGO1 0x1000eb20
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0348
+		return "GasStationEntity";
+	}
+
+	// FUNCTION: LEGO1 0x1000eb30
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, GasStationEntity::ClassName()) || BuildingEntity::IsA(p_name);
+	}
+};
+
+#endif // GASSTATIONENTITY_H

LEGO1/lego/legoomni/include/gasstationstate.h

@@ -0,0 +1,35 @@
+#ifndef GASSTATIONSTATE_H
+#define GASSTATIONSTATE_H
+
+#include "legostate.h"
+
+// VTABLE: LEGO1 0x100d46e0
+// SIZE 0x24
+class GasStationState : public LegoState {
+public:
+	GasStationState();
+
+	// FUNCTION: LEGO1 0x100061d0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0174
+		return "GasStationState";
+	}
+
+	// FUNCTION: LEGO1 0x100061e0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, GasStationState::ClassName()) || LegoState::IsA(p_name);
+	}
+
+private:
+	undefined4 m_unk0x08[3];
+	undefined4 m_unk0x14;
+	undefined2 m_unk0x18;
+	undefined2 m_unk0x1a;
+	undefined2 m_unk0x1c;
+	undefined2 m_unk0x1e;
+	undefined2 m_unk0x20;
+};
+
+#endif // GASSTATIONSTATE_H

LEGO1/lego/legoomni/include/gifmanager.h

@@ -0,0 +1,69 @@
+#ifndef GIFMANAGER_H
+#define GIFMANAGER_H
+
+#include "decomp.h"
+#include "mxtypes.h"
+
+#include <d3drmobj.h>
+#include <ddraw.h>
+
+struct GifData {
+public:
+	const char* m_name;
+	LPDIRECTDRAWSURFACE m_surface;
+	LPDIRECTDRAWPALETTE m_palette;
+	LPDIRECT3DRMTEXTURE2 m_texture;
+	MxU8* m_data;
+};
+
+struct GifMapEntry {
+public:
+	GifMapEntry* m_right;
+	GifMapEntry* m_parent;
+	GifMapEntry* m_left;
+	const char* m_key;
+	GifData* m_value;
+};
+
+class GifMap {
+public:
+	GifMapEntry* FindNode(const char*& p_string);
+
+	inline GifData* Get(const char* p_string)
+	{
+		GifData* ret = NULL;
+		GifMapEntry* entry = FindNode(p_string);
+		if (((m_unk0x4 == entry || strcmp(p_string, entry->m_key) > 0) ? m_unk0x4 : entry) != entry)
+			ret = entry->m_value;
+		return ret;
+	}
+
+	undefined4 m_unk0x0;
+	GifMapEntry* m_unk0x4;
+};
+
+// VTABLE: LEGO1 0x100d86d4
+class GifManagerBase {
+public:
+	// STUB: LEGO1 0x1005a310
+	virtual ~GifManagerBase() {} // vtable+00
+
+	inline GifData* Get(const char* p_name) { return m_unk0x8.Get(p_name); }
+
+protected:
+	undefined4 m_unk0x0;
+	undefined4 m_unk0x4;
+	GifMap m_unk0x8;
+};
+
+// VTABLE: LEGO1 0x100d86fc
+class GifManager : public GifManagerBase {
+public:
+	// STUB: LEGO1 0x1005a580
+	virtual ~GifManager() {} // vtable+00
+
+protected:
+	undefined m_unk0x14[0x1c];
+};
+
+#endif // GIFMANAGER_H

LEGO1/lego/legoomni/include/helicopter.h

@@ -0,0 +1,63 @@
+#ifndef HELICOPTER_H
+#define HELICOPTER_H
+
+#include "helicopterstate.h"
+#include "islepathactor.h"
+#include "realtime/matrix.h"
+
+// SIZE 0x34
+class HelicopterSubclass {
+public:
+	inline HelicopterSubclass() : m_unk0x30(0) {}
+	MxResult FUN_100040a0(Vector4Impl& p_v, float p_f);
+
+private:
+	Vector4Data m_unk0x0;  // 0x0
+	Vector4Data m_unk0x18; // 0x18
+	undefined4 m_unk0x30;  // 0x30
+};
+
+// 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
+	{
+		// STRING: LEGO1 0x100f0130
+		return "Helicopter";
+	}
+
+	// FUNCTION: LEGO1 0x10003080
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Helicopter::ClassName()) || IslePathActor::IsA(p_name);
+	}
+
+	virtual MxResult Create(MxDSObject& p_dsObject) override;              // vtable+0x18
+	void VTable0x70(float p_float) override;                               // vtable+0x70
+	void VTable0x74(Matrix4Impl& p_transform) override;                    // vtable+0x74
+	virtual MxU32 VTable0xcc() override;                                   // vtable+0xcc
+	virtual MxU32 VTable0xd4(MxType17NotificationParam& p_param) override; // vtable+0xd4
+	virtual MxU32 VTable0xd8(MxType18NotificationParam& p_param) override; // vtable+0xd8
+	virtual void VTable0xe4() override;                                    // vtable+0xe4
+
+	// SYNTHETIC: LEGO1 0x10003210
+	// Helicopter::`scalar deleting destructor'
+
+protected:
+	Matrix4Data m_unk0x160;        // 0x160
+	Matrix4Data m_unk0x1a8;        // 0x1a8
+	float m_unk0x1f0;              // 0x1f0
+	HelicopterSubclass m_unk0x1f4; // 0x1f4
+	HelicopterState* m_state;      // 0x228
+	MxAtomId m_script;             // 0x22c
+
+private:
+	void GetState();
+};
+
+#endif // HELICOPTER_H

LEGO1/lego/legoomni/include/helicopterstate.h

@@ -0,0 +1,31 @@
+#ifndef HELICOPTERSTATE_H
+#define HELICOPTERSTATE_H
+
+#include "decomp.h"
+#include "legostate.h"
+
+// VTABLE: LEGO1 0x100d5418
+// SIZE 0xc
+class HelicopterState : public LegoState {
+public:
+	// FUNCTION: LEGO1 0x1000e0d0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0144
+		return "HelicopterState";
+	}
+
+	// FUNCTION: LEGO1 0x1000e0e0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, HelicopterState::ClassName()) || LegoState::IsA(p_name);
+	}
+
+	inline void SetUnknown8(MxU32 p_unk0x8) { m_unk0x8 = p_unk0x8; }
+	inline MxU32 GetUnkown8() { return m_unk0x8; }
+
+protected:
+	MxU32 m_unk0x8; // 0x8
+};
+
+#endif // HELICOPTERSTATE_H

LEGO1/lego/legoomni/include/historybook.h

@@ -0,0 +1,29 @@
+#ifndef HISTORYBOOK_H
+#define HISTORYBOOK_H
+
+#include "legoworld.h"
+
+// VTABLE: LEGO1 0x100da328
+// SIZE 0x3e4
+class HistoryBook : public LegoWorld {
+public:
+	HistoryBook();
+	virtual ~HistoryBook() override; // vtable+0x0
+
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+0x4
+
+	// FUNCTION: LEGO1 0x10082390
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f04bc
+		return "HistoryBook";
+	}
+
+	// FUNCTION: LEGO1 0x100823a0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, HistoryBook::ClassName()) || LegoWorld::IsA(p_name);
+	}
+};
+
+#endif // HISTORYBOOK_H

LEGO1/lego/legoomni/include/hospital.h

@@ -0,0 +1,45 @@
+#ifndef HOSPITAL_H
+#define HOSPITAL_H
+
+#include "decomp.h"
+#include "legoworld.h"
+
+// VTABLE: LEGO1 0x100d9730
+// SIZE 0x12c
+class Hospital : public LegoWorld {
+public:
+	Hospital();
+	virtual ~Hospital() override; // vtable+0x0
+
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+0x04
+
+	// FUNCTION: LEGO1 0x100746b0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0490
+		return "Hospital";
+	}
+
+	// FUNCTION: LEGO1 0x100746c0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Hospital::ClassName()) || LegoWorld::IsA(p_name);
+	}
+
+private:
+	undefined2 m_unk0xf8;    // 0xf8
+	undefined4 m_unk0xfc;    // 0xfc
+	undefined2 m_unk0x100;   // 0x100
+	undefined4 m_unk0x104;   // 0x104 - VTable0x18 suggests this may be pointer to a LegoGameState
+	undefined2 m_unk0x108;   // 0x108
+	undefined4 m_unk0x10c;   // 0x10c
+	undefined4 m_unk0x110;   // 0x110
+	undefined4 m_unk0x114;   // 0x114
+	undefined m_unk0x118;    // 0x118
+	undefined4 m_unk0x11c;   // 0x11c
+	undefined4 m_unk0x120;   // 0x120
+	undefined m_unk0x124[4]; // 0x124
+	undefined m_unk0x128;    // 0x128
+};
+
+#endif // HOSPITAL_H

LEGO1/lego/legoomni/include/hospitalentity.h

@@ -0,0 +1,24 @@
+#ifndef HOSPITALENTITY_H
+#define HOSPITALENTITY_H
+
+#include "buildingentity.h"
+
+// VTABLE: LEGO1 0x100d5068
+// SIZE 0x68
+class HospitalEntity : public BuildingEntity {
+public:
+	// FUNCTION: LEGO1 0x1000ec40
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0338
+		return "HospitalEntity";
+	}
+
+	// FUNCTION: LEGO1 0x1000ec50
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, HospitalEntity::ClassName()) || BuildingEntity::IsA(p_name);
+	}
+};
+
+#endif // HOSPITALENTITY_H

LEGO1/lego/legoomni/include/hospitalstate.h

@@ -0,0 +1,36 @@
+#ifndef HOSPITALSTATE_H
+#define HOSPITALSTATE_H
+
+#include "decomp.h"
+#include "legostate.h"
+
+// VTABLE: LEGO1 0x100d97a0
+// SIZE 0x18
+class HospitalState : public LegoState {
+public:
+	HospitalState();
+
+	// FUNCTION: LEGO1 0x10076400
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0480
+		return "HospitalState";
+	}
+
+	// FUNCTION: LEGO1 0x10076410
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, HospitalState::ClassName()) || LegoState::IsA(p_name);
+	}
+
+private:
+	undefined m_unk0x8[4]; // 0x8
+	undefined2 m_unk0xc;   // 0xc
+	undefined2 m_unk0xe;   // 0xe
+	undefined2 m_unk0x10;  // 0x10
+	undefined2 m_unk0x12;  // 0x12
+	undefined2 m_unk0x14;  // 0x14
+	undefined2 m_unk0x16;  // 0x16
+};
+
+#endif // HOSPITALSTATE_H

LEGO1/lego/legoomni/include/infocenter.h

@@ -0,0 +1,36 @@
+#ifndef INFOCENTER_H
+#define INFOCENTER_H
+
+#include "legoworld.h"
+
+// VTABLE: LEGO1 0x100d9338
+// SIZE 0x1d8
+class Infocenter : public LegoWorld {
+public:
+	Infocenter();
+	virtual ~Infocenter() override;
+
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+0x4
+	virtual MxResult Tickle() override;               // vtable+0x8
+
+	// FUNCTION: LEGO1 0x1006eb40
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f04ec
+		return "Infocenter";
+	}
+
+	// FUNCTION: LEGO1 0x1006eb50
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Infocenter::ClassName()) || LegoWorld::IsA(p_name);
+	}
+
+	virtual MxResult Create(MxDSObject& p_dsObject) override; // vtable+0x18
+	virtual void Stop() override;                             // vtable+0x50
+	virtual MxBool VTable0x5c() override;                     // vtable+0x5c
+	virtual MxBool VTable0x64() override;                     // vtable+0x64
+	virtual void VTable0x68(MxBool p_add) override;           // vtable+0x68
+};
+
+#endif // INFOCENTER_H

LEGO1/lego/legoomni/include/infocenterdoor.h

@@ -0,0 +1,29 @@
+#ifndef INFOCENTERDOOR_H
+#define INFOCENTERDOOR_H
+
+#include "legoworld.h"
+
+// VTABLE: LEGO1 0x100d72d8
+// SIZE 0xfc
+class InfocenterDoor : public LegoWorld {
+public:
+	InfocenterDoor();
+	virtual ~InfocenterDoor(); // vtable+0x0
+
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+0x4
+
+	// FUNCTION: LEGO1 0x100377b0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f049c
+		return "InfocenterDoor";
+	}
+
+	// FUNCTION: LEGO1 0x100377c0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, InfocenterDoor::ClassName()) || LegoWorld::IsA(p_name);
+	}
+};
+
+#endif // INFOCENTERDOOR_H

LEGO1/lego/legoomni/include/infocenterentity.h

@@ -0,0 +1,24 @@
+#ifndef INFOCENTERENTITY_H
+#define INFOCENTERENTITY_H
+
+#include "buildingentity.h"
+
+// VTABLE: LEGO1 0x100d4b90
+// SIZE 0x68
+class InfoCenterEntity : public BuildingEntity {
+public:
+	// FUNCTION: LEGO1 0x1000ea00
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f035c
+		return "InfoCenterEntity";
+	}
+
+	// FUNCTION: LEGO1 0x1000ea10
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, InfoCenterEntity::ClassName()) || BuildingEntity::IsA(p_name);
+	}
+};
+
+#endif // INFOCENTERENTITY_H

LEGO1/lego/legoomni/include/infocenterstate.h

@@ -0,0 +1,62 @@
+#ifndef INFOCENTERSTATE_H
+#define INFOCENTERSTATE_H
+
+#include "decomp.h"
+#include "legostate.h"
+
+// VTABLE: LEGO1 0x100d93a8
+// SIZE 0x94
+class InfocenterState : public LegoState {
+public:
+	InfocenterState();
+	virtual ~InfocenterState();
+
+	// FUNCTION: LEGO1 0x10071840
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f04dc
+		return "InfocenterState";
+	}
+
+	// FUNCTION: LEGO1 0x10071850
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, InfocenterState::ClassName()) || LegoState::IsA(p_name);
+	}
+
+	inline MxU32 GetInfocenterBufferElement(MxS32 p_index) { return m_buffer[p_index]; }
+
+private:
+	// Members should be renamed with their offsets before use
+	/*
+	  struct UnkStruct
+	  {
+		undefined4 unk1;
+		undefined2 unk2;
+		undefined2 unk3;
+		undefined2 unk4;
+	  };
+
+	  undefined2 unk1;
+	  undefined2 unk2;
+	  undefined4 unk3;
+	  undefined4 padding1;
+	  void *unk4;
+	  undefined2 unk5;
+	  undefined2 unk6;
+	  undefined2 unk7;
+	  undefined2 padding2;
+	  void *unk8;
+	  undefined2 unk9;
+	  undefined2 unk10;
+	  undefined2 unk11;
+	  undefined2 padding3;
+	  UnkStruct unk12[6];
+	  undefined4 unk13;
+	*/
+
+	undefined m_pad[0x70];
+	MxU32 m_buffer[7]; // 0x78
+};
+
+#endif // INFOCENTERSTATE_H

LEGO1/lego/legoomni/include/isle.h

@@ -0,0 +1,79 @@
+#ifndef ISLE_H
+#define ISLE_H
+
+#include "legoworld.h"
+#include "radio.h"
+
+class Pizza;
+class Pizzeria;
+class TowTrack;
+class Ambulance;
+class JukeBoxEntity;
+class Helicopter;
+class Bike;
+class DuneBuggy;
+class Motorcycle;
+class SkateBoard;
+class RaceCar;
+class Jetski;
+class Act1State;
+
+// VTABLE: LEGO1 0x100d6fb8
+// SIZE 0x140
+// Radio at 0x12c
+class Isle : public LegoWorld {
+public:
+	Isle();
+	virtual ~Isle() override;
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+0x4
+
+	// FUNCTION: LEGO1 0x10030910
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0458
+		return "Isle";
+	}
+
+	// FUNCTION: LEGO1 0x10030920
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Isle::ClassName()) || LegoWorld::IsA(p_name);
+	}
+
+	virtual MxResult Create(MxDSObject& p_dsObject) override; // vtable+0x18
+	virtual void Stop() override;                             // vtable+50
+	virtual void VTable0x58(MxCore* p_object) override;       // vtable+58
+	// FUNCTION: LEGO1 0x10030900
+	virtual MxBool VTable0x5c() override { return TRUE; } // vtable+5c
+	// FUNCTION: LEGO1 0x10033170
+	virtual void VTable0x60() override {}            // vtable+60
+	virtual MxBool VTable0x64() override;            // vtable+64
+	virtual void VTable0x68(MxBool p_add) override;  // vtable+68
+	virtual void VTable0x6c(IslePathActor* p_actor); // vtable+6c
+
+	inline void SetUnknown13c(MxU32 p_unk0x13c) { m_unk0x13c = p_unk0x13c; }
+
+	MxLong StopAction(MxParam& p_param);
+	MxLong HandleType17Notification(MxParam& p_param);
+	MxLong HandleType19Notification(MxParam& p_param);
+	MxLong HandleTransitionEnd();
+
+protected:
+	Act1State* m_act1state;   // 0xf8
+	Pizza* m_pizza;           // 0xfc
+	Pizzeria* m_pizzeria;     // 0x100
+	TowTrack* m_towtrack;     // 0x104
+	Ambulance* m_ambulance;   // 0x108
+	JukeBoxEntity* m_jukebox; // 0x10c
+	Helicopter* m_helicopter; // 0x110
+	Bike* m_bike;             // 0x114
+	DuneBuggy* m_dunebuggy;   // 0x118
+	Motorcycle* m_motorcycle; // 0x11c
+	SkateBoard* m_skateboard; // 0x120
+	RaceCar* m_racecar;       // 0x124
+	Jetski* m_jetski;         // 0x128
+	Radio m_radio;            // 0x12c
+	MxU32 m_unk0x13c;         // 0x13c
+};
+
+#endif // ISLE_H

LEGO1/lego/legoomni/include/isleactor.h

@@ -0,0 +1,23 @@
+#ifndef ISLEACTOR_H
+#define ISLEACTOR_H
+
+#include "legoactor.h"
+
+// VTABLE: LEGO1 0x100d5178
+class IsleActor : public LegoActor {
+public:
+	// FUNCTION: LEGO1 0x1000e660
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f07dc
+		return "IsleActor";
+	}
+
+	// FUNCTION: LEGO1 0x1000e670
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, IsleActor::ClassName()) || LegoActor::IsA(p_name);
+	}
+};
+
+#endif // ISLEACTOR_H

LEGO1/lego/legoomni/include/islepathactor.h

@@ -0,0 +1,59 @@
+#ifndef ISLEPATHACTOR_H
+#define ISLEPATHACTOR_H
+
+#include "legopathactor.h"
+#include "legoworld.h"
+#include "mxtype17notificationparam.h"
+#include "mxtype18notificationparam.h"
+#include "mxtype19notificationparam.h"
+#include "mxtypes.h"
+
+// VTABLE: LEGO1 0x100d4398
+// SIZE 0x160
+class IslePathActor : public LegoPathActor {
+public:
+	IslePathActor();
+	inline virtual ~IslePathActor() override { IslePathActor::Destroy(TRUE); } // vtable+0x0
+
+	// FUNCTION: LEGO1 0x10002ea0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0104
+		return "IslePathActor";
+	}
+
+	// FUNCTION: LEGO1 0x10002eb0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, IslePathActor::ClassName()) || LegoPathActor::IsA(p_name);
+	}
+
+	virtual MxResult Create(MxDSObject& p_dsObject) override; // vtable+0x18
+	// FUNCTION: LEGO1 0x10002e70
+	virtual MxU32 VTable0xcc() { return 0; } // vtable+0xcc
+	// FUNCTION: LEGO1 0x10002df0
+	virtual MxU32 VTable0xd0() { return 0; } // vtable+0xd0
+	// FUNCTION: LEGO1 0x10002e80
+	virtual MxU32 VTable0xd4(MxType17NotificationParam&) { return 0; } // vtable+0xd4
+	// FUNCTION: LEGO1 0x10002e90
+	virtual MxU32 VTable0xd8(MxType18NotificationParam&) { return 0; } // vtable+0xd8
+	// FUNCTION: LEGO1 0x10002e00
+	virtual MxU32 VTable0xdc(MxType19NotificationParam&) { return 0; } // vtable+0xdc
+	virtual void VTable0xe0();                                         // vtable+0xe0
+	virtual void VTable0xe4();                                         // vtable+0xe4
+	virtual void VTable0xe8(MxU32, MxBool, MxU8);                      // vtable+0xe8
+	virtual void VTable0xec();                                         // vtable+0xec
+
+	// SYNTHETIC: LEGO1 0x10002ff0
+	// IslePathActor::`scalar deleting destructor'
+
+	inline void SetWorld(LegoWorld* p_world) { m_world = p_world; }
+	inline LegoWorld* GetWorld() { return m_world; }
+
+protected:
+	LegoWorld* m_world; // 0x154
+	MxFloat m_unk0x158; // 0x158
+	MxFloat m_unk0x15c; // 0x15c
+};
+
+#endif // ISLEPATHACTOR_H

LEGO1/lego/legoomni/include/jetski.h

@@ -0,0 +1,31 @@
+#ifndef JETSKI_H
+#define JETSKI_H
+
+#include "decomp.h"
+#include "islepathactor.h"
+
+// VTABLE: LEGO1 0x100d9ec8
+// SIZE 0x164
+class Jetski : public IslePathActor {
+public:
+	Jetski();
+
+	// FUNCTION: LEGO1 0x1007e430
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f03d8
+		return "Jetski";
+	}
+
+	// FUNCTION: LEGO1 0x1007e440
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Jetski::ClassName()) || IslePathActor::IsA(p_name);
+	}
+
+private:
+	// TODO: Jetski fields
+	undefined m_unk0x160[4];
+};
+
+#endif // JETSKI_H

LEGO1/lego/legoomni/include/jetskirace.h

@@ -0,0 +1,24 @@
+#ifndef JETSKIRACE_H
+#define JETSKIRACE_H
+
+#include "legorace.h"
+
+// VTABLE: LEGO1 0x100d4fe8
+// SIZE 0x144
+class JetskiRace : public LegoRace {
+public:
+	// FUNCTION: LEGO1 0x1000daf0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0530
+		return "JetskiRace";
+	}
+
+	// FUNCTION: LEGO1 0x1000db00
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, JetskiRace::ClassName()) || LegoRace::IsA(p_name);
+	}
+};
+
+#endif // JETSKIRACE_H

LEGO1/lego/legoomni/include/jetskiracestate.h

@@ -0,0 +1,24 @@
+#ifndef JETSKIRACESTATE_H
+#define JETSKIRACESTATE_H
+
+#include "racestate.h"
+
+// VTABLE: LEGO1 0x100d4fa8
+// SIZE 0x2c
+class JetskiRaceState : public RaceState {
+public:
+	// FUNCTION: LEGO1 0x1000dc40
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f00ac
+		return "JetskiRaceState";
+	}
+
+	// FUNCTION: LEGO1 0x1000dc50
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, JetskiRaceState::ClassName()) || RaceState::IsA(p_name);
+	}
+};
+
+#endif // JETSKIRACESTATE_H

LEGO1/lego/legoomni/include/jukebox.h

@@ -0,0 +1,32 @@
+#ifndef JUKEBOX_H
+#define JUKEBOX_H
+
+#include "decomp.h"
+#include "legoworld.h"
+
+// VTABLE: LEGO1 0x100d8958
+// SIZE 0x104
+class JukeBox : public LegoWorld {
+public:
+	JukeBox();
+
+	// FUNCTION: LEGO1 0x1005d6f0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f02cc
+		return "JukeBox";
+	}
+
+	// FUNCTION: LEGO1 0x1005d700
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, JukeBox::ClassName()) || LegoWorld::IsA(p_name);
+	}
+
+private:
+	undefined m_unk0xf8[4]; // 0xf8
+	undefined4 m_unk0xfc;   // 0xfc
+	undefined2 m_unk0x100;  // 0x100
+};
+
+#endif // JUKEBOX_H

LEGO1/lego/legoomni/include/jukeboxentity.h

@@ -0,0 +1,27 @@
+#ifndef JUKEBOXENTITY_H
+#define JUKEBOXENTITY_H
+
+#include "legoentity.h"
+
+// VTABLE: LEGO1 0x100da8a0
+// SIZE 0x6c
+class JukeBoxEntity : public LegoEntity {
+public:
+	JukeBoxEntity();
+	virtual ~JukeBoxEntity() override; // vtable+0x0
+
+	// FUNCTION: LEGO1 0x10085cc0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f02f0
+		return "JukeBoxEntity";
+	}
+
+	// FUNCTION: LEGO1 0x10085cd0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, JukeBoxEntity::ClassName()) || LegoEntity::IsA(p_name);
+	}
+};
+
+#endif // JUKEBOXENTITY_H

LEGO1/lego/legoomni/include/jukeboxstate.h

@@ -0,0 +1,26 @@
+#ifndef JUKEBOXSTATE_H
+#define JUKEBOXSTATE_H
+
+#include "legostate.h"
+
+// VTABLE: LEGO1 0x100d4a90
+// SIZE 0x10
+class JukeBoxState : public LegoState {
+public:
+	// FUNCTION: LEGO1 0x1000f310
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f02bc
+		return "JukeBoxState";
+	}
+
+	// FUNCTION: LEGO1 0x1000f320
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, JukeBoxState::ClassName()) || LegoState::IsA(p_name);
+	}
+
+	virtual MxBool VTable0x14() override; // vtable+0x14
+};
+
+#endif // JUKEBOXSTATE_H

LEGO1/lego/legoomni/include/lego3dwavepresenter.h

@@ -0,0 +1,24 @@
+#ifndef LEGO3DWAVEPRESENTER_H
+#define LEGO3DWAVEPRESENTER_H
+
+#include "mxwavepresenter.h"
+
+// VTABLE: LEGO1 0x100d52b0
+// SIZE 0xa0
+class Lego3DWavePresenter : public MxWavePresenter {
+public:
+	// FUNCTION: LEGO1 0x1000d890
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f058c
+		return "Lego3DWavePresenter";
+	}
+
+	// FUNCTION: LEGO1 0x1000d8a0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Lego3DWavePresenter::ClassName()) || MxWavePresenter::IsA(p_name);
+	}
+};
+
+#endif // LEGO3DWAVEPRESENTER_H

LEGO1/lego/legoomni/include/legoact2.h

@@ -0,0 +1,11 @@
+#ifndef LEGOACT2_H
+#define LEGOACT2_H
+
+#include "legocarraceactor.h"
+#include "legopathactor.h"
+
+// VTABLE: LEGO1 0x100d82e0
+// SIZE 0x1154
+class LegoAct2 : public LegoWorld {};
+
+#endif // LEGOACT2_H

LEGO1/lego/legoomni/include/legoact2state.h

@@ -0,0 +1,24 @@
+#ifndef LEGOACT2STATE_H
+#define LEGOACT2STATE_H
+
+#include "legostate.h"
+
+// VTABLE: LEGO1 0x100d4a70
+// SIZE 0x10
+class LegoAct2State : public LegoState {
+public:
+	// FUNCTION: LEGO1 0x1000df80
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0428
+		return "LegoAct2State";
+	}
+
+	// FUNCTION: LEGO1 0x1000df90
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoAct2State::ClassName()) || LegoState::IsA(p_name);
+	}
+};
+
+#endif // LEGOACT2STATE_H

LEGO1/lego/legoomni/include/legoactioncontrolpresenter.h

@@ -0,0 +1,43 @@
+#ifndef LEGOACTIONCONTROLPRESENTER_H
+#define LEGOACTIONCONTROLPRESENTER_H
+
+#include "decomp.h"
+#include "legoutil.h"
+#include "mxmediapresenter.h"
+
+// VTABLE: LEGO1 0x100d5118
+// SIZE 0x68
+class LegoActionControlPresenter : public MxMediaPresenter {
+public:
+	inline LegoActionControlPresenter() { m_unk0x50 = ExtraActionType_none; }
+	virtual ~LegoActionControlPresenter() override { Destroy(TRUE); }; // vtable+0x00
+
+	// FUNCTION: LEGO1 0x1000d0e0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f05bc
+		return "LegoActionControlPresenter";
+	}
+
+	// FUNCTION: LEGO1 0x1000d0f0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoActionControlPresenter::ClassName()) || MxMediaPresenter::IsA(p_name);
+	}
+
+	virtual void ReadyTickle() override;           // vtable+0x18
+	virtual void RepeatingTickle() override;       // vtable+0x24
+	virtual void ParseExtra() override;            // vtable+0x30
+	virtual MxResult AddToManager() override;      // vtable+0x34
+	virtual void Destroy(MxBool p_fromDestructor); // vtable+0x5c
+
+private:
+	ExtraActionType m_unk0x50; // 0x50
+	MxString m_unk0x54;        // 0x54
+	undefined4 m_unk0x64;      // 0x64
+};
+
+// SYNTHETIC: LEGO1 0x1000d1d0
+// LegoActionControlPresenter::`scalar deleting destructor'
+
+#endif // LEGOACTIONCONTROLPRESENTER_H

LEGO1/lego/legoomni/include/legoactor.h

@@ -0,0 +1,46 @@
+#ifndef LEGOACTOR_H
+#define LEGOACTOR_H
+
+#include "decomp.h"
+#include "legoentity.h"
+
+// VTABLE: LEGO1 0x100d6d68
+// SIZE 0x78
+class LegoActor : public LegoEntity {
+public:
+	LegoActor();
+
+	// FUNCTION: LEGO1 0x1002d210
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0124
+		return "LegoActor";
+	}
+
+	// FUNCTION: LEGO1 0x1002d220
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoActor::ClassName()) || LegoEntity::IsA(p_name);
+	}
+
+	// FUNCTION: LEGO1 0x10002cc0
+	virtual MxFloat VTable0x50() { return m_unk0x68; } // vtable+0x50
+	// FUNCTION: LEGO1 0x10002cd0
+	virtual void VTable0x54(MxFloat p_unk0x68) { m_unk0x68 = p_unk0x68; } // vtable+0x54
+	// FUNCTION: LEGO1 0x10002ce0
+	virtual void VTable0x58(MxFloat p_unk0x70) { m_unk0x70 = p_unk0x70; } // vtable+0x58
+	// FUNCTION: LEGO1 0x10002cf0
+	virtual MxFloat VTable0x5c() { return m_unk0x70; } // vtable+0x5c
+	// FUNCTION: LEGO1 0x10002d00
+	virtual MxU8 VTable0x60() { return m_unk0x74; } // vtable+0x60
+	// FUNCTION: LEGO1 0x10002d10
+	virtual void VTable0x64(MxU8 p_unk0x74) { m_unk0x74 = p_unk0x74; } // vtable+0x64
+
+private:
+	MxFloat m_unk0x68;    // 0x68
+	undefined4 m_unk0x6c; // 0x6c
+	MxFloat m_unk0x70;    // 0x70
+	MxU8 m_unk0x74;       // 0x74
+};
+
+#endif // LEGOACTOR_H

LEGO1/lego/legoomni/include/legoactorpresenter.h

@@ -0,0 +1,24 @@
+#ifndef LEGOACTORPRESENTER_H
+#define LEGOACTORPRESENTER_H
+
+#include "legoentitypresenter.h"
+
+// VTABLE: LEGO1 0x100d5320
+// SIZE 0x50
+class LegoActorPresenter : public LegoEntityPresenter {
+public:
+	// FUNCTION: LEGO1 0x1000cb10
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f06a4
+		return "LegoActorPresenter";
+	}
+
+	// FUNCTION: LEGO1 0x1000cb20
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoActorPresenter::ClassName()) || LegoEntityPresenter::IsA(p_name);
+	}
+};
+
+#endif // LEGOACTORPRESENTER_H

LEGO1/lego/legoomni/include/legoanimactor.h

@@ -0,0 +1,10 @@
+#ifndef LEGOANIMACTOR_H
+#define LEGOANIMACTOR_H
+
+#include "legopathactor.h"
+
+class LegoAnimActor : public LegoPathActor {
+public:
+};
+
+#endif // LEGOANIMACTOR_H

LEGO1/lego/legoomni/include/legoanimationmanager.h

@@ -0,0 +1,38 @@
+#ifndef LEGOANIMATIONMANAGER_H
+#define LEGOANIMATIONMANAGER_H
+
+#include "mxcore.h"
+
+// VTABLE: LEGO1 0x100d8c18
+// SIZE 0x500
+class LegoAnimationManager : public MxCore {
+public:
+	LegoAnimationManager();
+	virtual ~LegoAnimationManager() override; // vtable+0x0
+
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+0x4
+	virtual MxResult Tickle() override;               // vtable+0x8
+
+	// FUNCTION: LEGO1 0x1005ec80
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f7508
+		return "LegoAnimationManager";
+	}
+
+	// FUNCTION: LEGO1 0x1005ec90
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, ClassName()) || MxCore::IsA(p_name);
+	}
+
+	void FUN_1005f6d0(MxBool);
+	void FUN_10064670(MxBool);
+
+	__declspec(dllexport) static void configureLegoAnimationManager(MxS32 p_legoAnimationManagerConfig);
+
+private:
+	void Init();
+};
+
+#endif // LEGOANIMATIONMANAGER_H

LEGO1/lego/legoomni/include/legoanimmmpresenter.h

@@ -0,0 +1,26 @@
+#ifndef LEGOANIMMMPRESENTER_H
+#define LEGOANIMMMPRESENTER_H
+
+#include "mxcompositepresenter.h"
+
+// VTABLE: LEGO1 0x100d7de8
+// SIZE 0x74
+class LegoAnimMMPresenter : public MxCompositePresenter {
+public:
+	LegoAnimMMPresenter();
+
+	// FUNCTION: LEGO1 0x1004a950
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f046c
+		return "LegoAnimMMPresenter";
+	}
+
+	// FUNCTION: LEGO1 0x1004a960
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoAnimMMPresenter::ClassName()) || MxCompositePresenter::IsA(p_name);
+	}
+};
+
+#endif // LEGOANIMMMPRESENTER_H

LEGO1/lego/legoomni/include/legoanimpresenter.h

@@ -0,0 +1,28 @@
+#ifndef LEGOANIMPRESENTER_H
+#define LEGOANIMPRESENTER_H
+
+#include "mxvideopresenter.h"
+
+// VTABLE: LEGO1 0x100d90c8
+class LegoAnimPresenter : public MxVideoPresenter {
+public:
+	LegoAnimPresenter();
+
+	// FUNCTION: LEGO1 0x10068530
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f071c
+		return "LegoAnimPresenter";
+	}
+
+	// FUNCTION: LEGO1 0x10068540
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoAnimPresenter::ClassName()) || MxVideoPresenter::IsA(p_name);
+	}
+
+private:
+	void Init();
+};
+
+#endif // LEGOANIMPRESENTER_H

LEGO1/lego/legoomni/include/legobackgroundcolor.h

@@ -0,0 +1,19 @@
+#ifndef LEGOBACKGROUNDCOLOR_H
+#define LEGOBACKGROUNDCOLOR_H
+
+#include "mxvariable.h"
+
+// VTABLE: LEGO1 0x100d74a8
+// SIZE 0x30
+class LegoBackgroundColor : public MxVariable {
+public:
+	__declspec(dllexport) LegoBackgroundColor(const char* p_key, const char* p_value);
+	virtual void SetValue(const char* p_colorString) override;
+
+private:
+	float m_h;
+	float m_s;
+	float m_v;
+};
+
+#endif // LEGOBACKGROUNDCOLOR_H

LEGO1/lego/legoomni/include/legobuildingmanager.h

@@ -0,0 +1,26 @@
+#ifndef LEGOBUILDINGMANAGER_H
+#define LEGOBUILDINGMANAGER_H
+
+#include "mxcore.h"
+
+// VTABLE: LEGO1 0x100d6f50
+// SIZE 0x30
+class LegoBuildingManager : public MxCore {
+public:
+	LegoBuildingManager();
+	virtual ~LegoBuildingManager() override;
+
+	// FUNCTION: LEGO1 0x1002f930
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f37d0
+		return "LegoBuildingManager";
+	}
+
+	__declspec(dllexport) static void configureLegoBuildingManager(MxS32);
+
+private:
+	void Init();
+};
+
+#endif // LEGOBUILDINGMANAGER_H

LEGO1/lego/legoomni/include/legocachesound.h

@@ -0,0 +1,30 @@
+#ifndef LEGOCACHESOUND_H
+#define LEGOCACHESOUND_H
+
+#include "mxcore.h"
+
+// VTABLE: LEGO1 0x100d4718
+// SIZE 0x88
+class LegoCacheSound : public MxCore {
+public:
+	LegoCacheSound();
+	virtual ~LegoCacheSound() override; // vtable+0x0
+
+	// FUNCTION: LEGO1 0x10006580
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f01c4
+		return "LegoCacheSound";
+	}
+
+	// FUNCTION: LEGO1 0x10006590
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoCacheSound::ClassName()) || MxCore::IsA(p_name);
+	}
+
+private:
+	void Init();
+};
+
+#endif // LEGOCACHESOUND_H

LEGO1/lego/legoomni/include/legocameracontroller.h

@@ -0,0 +1,35 @@
+#ifndef LEGOCAMERACONTROLLER_H
+#define LEGOCAMERACONTROLLER_H
+
+#include "mxcore.h"
+#include "realtime/matrix.h"
+#include "realtime/vector.h"
+
+// VTABLE: LEGO1 0x100d57b0
+// SIZE 0xc8
+class LegoCameraController : public MxCore {
+public:
+	LegoCameraController();
+	virtual ~LegoCameraController() override; // vtable+0x0
+
+	// FUNCTION: LEGO1 0x10011ec0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0850
+		return "LegoCameraController";
+	}
+
+	// FUNCTION: LEGO1 0x10011ed0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, ClassName()) || MxCore::IsA(p_name);
+	}
+
+	void LookAt(Vector3Impl& p_at, Vector3Impl& p_dir, Vector3Impl& p_up);
+	void FUN_100123e0(Matrix4Data& p_transform, MxU32);
+	Vector3Data& FUN_10012740();
+	Vector3Data& FUN_100127f0();
+	Vector3Data& FUN_100128a0();
+};
+
+#endif // LEGOCAMERACONTROLLER_H

LEGO1/lego/legoomni/include/legocarbuild.h

@@ -0,0 +1,30 @@
+#ifndef LEGOCARBUILD_H
+#define LEGOCARBUILD_H
+
+#include "legoworld.h"
+
+// VTABLE: LEGO1 0x100d6658
+// SIZE 0x34c
+class LegoCarBuild : public LegoWorld {
+public:
+	LegoCarBuild();
+	virtual ~LegoCarBuild() override;
+
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+0x4
+	virtual MxResult Tickle() override;               // vtable+0x8
+
+	// FUNCTION: LEGO1 0x10022940
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0504
+		return "LegoCarBuild";
+	}
+
+	// FUNCTION: LEGO1 0x10022950
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoCarBuild::ClassName()) || LegoWorld::IsA(p_name);
+	}
+};
+
+#endif // LEGOCARBUILD_H

LEGO1/lego/legoomni/include/legocarbuildanimpresenter.h

@@ -0,0 +1,27 @@
+#ifndef LEGOCARBUILDANIMPRESENTER_H
+#define LEGOCARBUILDANIMPRESENTER_H
+
+#include "legoanimpresenter.h"
+
+// VTABLE: LEGO1 0x100d99e0
+// SIZE 0x150
+class LegoCarBuildAnimPresenter : public LegoAnimPresenter {
+public:
+	LegoCarBuildAnimPresenter();
+	virtual ~LegoCarBuildAnimPresenter() override; // vtable+0x0
+
+	// FUNCTION: LEGO1 0x10078510
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f05ec
+		return "LegoCarBuildAnimPresenter";
+	}
+
+	// FUNCTION: LEGO1 0x10078520
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoCarBuildAnimPresenter::ClassName()) || LegoAnimPresenter::IsA(p_name);
+	}
+};
+
+#endif // LEGOCARBUILDANIMPRESENTER_H

LEGO1/lego/legoomni/include/legocarraceactor.h

@@ -0,0 +1,23 @@
+#ifndef LEGOCARRACEACTOR_H
+#define LEGOCARRACEACTOR_H
+
+#include "legoraceactor.h"
+
+// VTABLE: LEGO1 0x100da0d8
+class LegoCarRaceActor : public LegoRaceActor {
+public:
+	// FUNCTION: LEGO1 0x10081650
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0568
+		return "LegoCarRaceActor";
+	}
+
+	// FUNCTION: LEGO1 0x10081670
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoCarRaceActor::ClassName()) || LegoRaceActor::IsA(p_name);
+	}
+};
+
+#endif // LEGOCARRACEACTOR_H

LEGO1/lego/legoomni/include/legocontrolmanager.h

@@ -0,0 +1,31 @@
+#ifndef LEGOCONTROLMANAGER_H
+#define LEGOCONTROLMANAGER_H
+
+#include "mxcore.h"
+
+// VTABLE: LEGO1 0x100d6a80
+class LegoControlManager : public MxCore {
+public:
+	LegoControlManager();
+	virtual ~LegoControlManager() override; // vtable+0x0
+
+	virtual MxResult Tickle() override; // vtable+0x8
+
+	// FUNCTION: LEGO1 0x10028cb0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f31b8
+		return "LegoControlManager";
+	}
+
+	// FUNCTION: LEGO1 0x10028cc0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoControlManager::ClassName()) || MxCore::IsA(p_name);
+	}
+
+	void Register(MxCore* p_listener);
+	void Unregister(MxCore* p_listener);
+};
+
+#endif // LEGOCONTROLMANAGER_H

LEGO1/lego/legoomni/include/legoentity.h

@@ -0,0 +1,74 @@
+#ifndef LEGOENTITY_H
+#define LEGOENTITY_H
+
+#include "decomp.h"
+#include "extra.h"
+#include "mxdsobject.h"
+#include "mxentity.h"
+#include "realtime/vector.h"
+#include "roi/legoroi.h"
+
+// VTABLE: LEGO1 0x100d4858
+// SIZE 0x68 (probably)
+class LegoEntity : public MxEntity {
+public:
+	// Inlined at 0x100853f7
+	inline LegoEntity() { Init(); }
+
+	__declspec(dllexport) virtual ~LegoEntity() override; // vtable+0x0
+
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+0x4
+
+	// FUNCTION: LEGO1 0x1000c2f0
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f0064
+		return "LegoEntity";
+	}
+
+	// FUNCTION: LEGO1 0x1000c300
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoEntity::ClassName()) || MxEntity::IsA(p_name);
+	}
+
+	virtual MxResult Create(MxDSObject& p_dsObject);                                           // vtable+0x18
+	virtual void Destroy(MxBool p_fromDestructor);                                             // vtable+0x1c
+	virtual void ParseAction(char*);                                                           // vtable+0x20
+	virtual void SetROI(LegoROI* p_roi, MxBool p_bool1, MxBool p_bool2);                       // vtable+0x24
+	virtual void SetWorldTransform(Vector3Impl& p_loc, Vector3Impl& p_dir, Vector3Impl& p_up); // vtable+0x28
+	virtual void ResetWorldTransform(MxBool p_inVehicle);                                      // vtable+0x2c
+	// FUNCTION: LEGO1 0x10001090
+	virtual void SetWorldSpeed(MxFloat p_worldSpeed) { m_worldSpeed = p_worldSpeed; } // vtable+0x30
+	virtual void VTable0x34();                                                        // vtable+0x34
+	virtual void VTable0x38();                                                        // vtable+0x38
+	virtual void VTable0x3c();                                                        // vtable+0x3c
+	virtual void VTable0x40();                                                        // vtable+0x40
+	virtual void VTable0x44();                                                        // vtable+0x44
+	virtual void VTable0x48();                                                        // vtable+0x48
+	virtual void VTable0x4c();                                                        // vtable+0x4c
+
+	void FUN_10010c30();
+	void SetLocation(Vector3Data& p_location, Vector3Data& p_direction, Vector3Data& p_up, MxBool);
+
+protected:
+	void Init();
+	void SetWorld();
+
+	undefined m_unk0x10;
+	undefined m_unk0x11;
+	Vector3Data m_worldLocation;  // 0x14
+	Vector3Data m_worldDirection; // 0x28
+	Vector3Data m_worldUp;        // 0x3c
+	MxFloat m_worldSpeed;         // 0x50
+	LegoROI* m_roi;               // 0x54
+	MxBool m_cameraFlag;          // 0x58
+	undefined m_unk0x59;
+	// For tokens from the extra string that look like this:
+	// "Action:openram;\lego\scripts\Race\CarRaceR;0"
+	ExtraActionType m_actionType; // 0x5c
+	char* m_actionArgString;      // 0x60
+	MxS32 m_actionArgNumber;      // 0x64
+};
+
+#endif // LEGOENTITY_H

LEGO1/lego/legoomni/include/legoentitypresenter.h

@@ -0,0 +1,45 @@
+#ifndef LEGOENTITYPRESENTER_H
+#define LEGOENTITYPRESENTER_H
+
+#include "mxcompositepresenter.h"
+
+class LegoEntity;
+
+// VTABLE: LEGO1 0x100d8398
+// SIZE 0x50
+class LegoEntityPresenter : public MxCompositePresenter {
+public:
+	LegoEntityPresenter();
+	virtual ~LegoEntityPresenter() override; // vtable+0x0
+
+	// FUNCTION: LEGO1 0x100534b0
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f06b8
+		return "LegoEntityPresenter";
+	}
+
+	// FUNCTION: LEGO1 0x100534c0
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoEntityPresenter::ClassName()) || MxCompositePresenter::IsA(p_name);
+	}
+
+	virtual void ReadyTickle() override;                                                           // vtable+0x18
+	virtual void RepeatingTickle();                                                                // vtable+0x24
+	virtual void ParseExtra();                                                                     // vtable+0x30
+	virtual void Destroy() override;                                                               // vtable+0x38
+	virtual MxResult StartAction(MxStreamController* p_controller, MxDSAction* p_action) override; // vtable+0x3c
+	virtual void Init();                                                                           // vtable+0x68
+	virtual undefined4 SetBackend(LegoEntity* p_unk0x4c);                                          // vtable+0x6c
+
+	void SetBackendLocation(Vector3Data& p_location, Vector3Data& p_direction, Vector3Data& p_up);
+
+private:
+	void Destroy(MxBool p_fromDestructor);
+
+protected:
+	LegoEntity* m_objectBackend; // 0x4c
+};
+
+#endif // LEGOENTITYPRESENTER_H

LEGO1/lego/legoomni/include/legoeventnotificationparam.h

@@ -0,0 +1,36 @@
+#ifndef LEGOEVENTNOTIFICATIONPARAM_H
+#define LEGOEVENTNOTIFICATIONPARAM_H
+
+#include "mxnotificationparam.h"
+#include "mxtypes.h"
+
+#include <stdlib.h>
+
+// VTABLE: LEGO1 0x100d6aa0
+class LegoEventNotificationParam : public MxNotificationParam {
+public:
+	inline LegoEventNotificationParam() : MxNotificationParam(PARAM_NONE, NULL) {}
+	inline LegoEventNotificationParam(
+		NotificationId p_type,
+		MxCore* p_sender,
+		MxU8 p_modifier,
+		MxS32 p_x,
+		MxS32 p_y,
+		MxU8 p_key
+	)
+		: MxNotificationParam(p_type, p_sender), m_modifier(p_modifier), m_x(p_x), m_y(p_y), m_key(p_key), m_unk0x1c(0)
+	{
+	}
+
+	virtual ~LegoEventNotificationParam() override {} // vtable+0x0 (scalar deleting destructor)
+	inline MxU8 GetKey() const { return m_key; }
+
+protected:
+	MxU8 m_modifier; // 0x0c
+	MxS32 m_x;       // 0x10
+	MxS32 m_y;       // 0x14
+	MxU8 m_key;      // 0x18
+	MxU32 m_unk0x1c; // 0x1c
+};
+
+#endif // LEGOEVENTNOTIFICATIONPARAM_H

LEGO1/lego/legoomni/include/legoextraactor.h

@@ -0,0 +1,23 @@
+#ifndef LEGOEXTRAACTOR_H
+#define LEGOEXTRAACTOR_H
+
+#include "legoanimactor.h"
+
+// VTABLE: LEGO1 0x100d6c10
+class LegoExtraActor : public LegoAnimActor {
+public:
+	// FUNCTION: LEGO1 0x1002b7a0
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f3204
+		return "LegoExtraActor";
+	}
+
+	// FUNCTION: LEGO1 0x1002b7c0
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoExtraActor::ClassName()) || LegoAnimActor::IsA(p_name);
+	}
+};
+
+#endif // LEGOEXTRAACTOR_H

LEGO1/lego/legoomni/include/legoflctexturepresenter.h

@@ -0,0 +1,27 @@
+#ifndef LEGOFLCTEXTUREPRESENTER_H
+#define LEGOFLCTEXTUREPRESENTER_H
+
+#include "decomp.h"
+#include "mxflcpresenter.h"
+
+// VTABLE: LEGO1 0x100d89e0
+// SIZE 0x70
+class LegoFlcTexturePresenter : public MxFlcPresenter {
+public:
+	LegoFlcTexturePresenter();
+
+	// FUNCTION: LEGO1 0x1005def0
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f0634
+		return "LegoFlcTexturePresenter";
+	}
+
+private:
+	void Init();
+
+	undefined4 m_unk0x68; // 0x68
+	undefined4 m_unk0x6c; // 0x6c
+};
+
+#endif // LEGOFLCTEXTUREPRESENTER_H

LEGO1/lego/legoomni/include/legofullscreenmovie.h

@@ -0,0 +1,14 @@
+#ifndef LEGOFULLSCREENMOVIE_H
+#define LEGOFULLSCREENMOVIE_H
+
+#include "mxvariable.h"
+
+// VTABLE: LEGO1 0x100d74b8
+// SIZE 0x24
+class LegoFullScreenMovie : public MxVariable {
+public:
+	LegoFullScreenMovie(const char* p_key, const char* p_value);
+	virtual void SetValue(const char* p_option) override;
+};
+
+#endif // LEGOFULLSCREENMOVIE_H

LEGO1/lego/legoomni/include/legogamestate.h

@@ -0,0 +1,81 @@
+#ifndef LEGOGAMESTATE_H
+#define LEGOGAMESTATE_H
+
+#include "decomp.h"
+#include "legobackgroundcolor.h"
+#include "legofullscreenmovie.h"
+#include "legostream.h"
+#include "mxtypes.h"
+
+class LegoState;
+class MxVariable;
+class MxString;
+
+struct ColorStringStruct {
+	const char* m_targetName;
+	const char* m_colorName;
+};
+
+// SIZE 0x430
+class LegoGameState {
+public:
+	__declspec(dllexport) LegoGameState();
+	__declspec(dllexport) ~LegoGameState();
+	__declspec(dllexport) MxResult Load(MxULong);
+	__declspec(dllexport) MxResult Save(MxULong);
+	__declspec(dllexport) void SerializePlayersInfo(MxS16);
+	__declspec(dllexport) void SerializeScoreHistory(MxS16 p_flags);
+	__declspec(dllexport) void SetSavePath(char*);
+
+	LegoState* GetState(const char* p_stateName);
+	LegoState* CreateState(const char* p_stateName);
+
+	void GetFileSavePath(MxString* p_outPath, MxULong p_slotn);
+	void FUN_1003a720(MxU32);
+	void HandleAction(MxU32);
+
+	inline MxU8 GetUnknownC() { return m_unk0xc; }
+	inline MxU32 GetUnknown10() { return m_unk0x10; }
+	inline MxS32 GetCurrentAct() { return m_currentAct; }
+	inline undefined4 GetUnknown424() { return m_unk0x424; }
+	inline void SetDirty(MxBool p_dirty) { m_isDirty = p_dirty; }
+	inline void SetUnknown424(undefined4 p_unk0x424) { m_unk0x424 = p_unk0x424; }
+
+	void SetSomeEnumState(undefined4 p_state);
+	void FUN_1003ceb0();
+
+	struct ScoreStruct {
+		void WriteScoreHistory();
+		void FUN_1003ccf0(LegoFileStream&);
+
+		MxU16 m_unk0x00;
+		undefined m_unk0x02[0x2c][20];
+	};
+
+private:
+	void RegisterState(LegoState* p_state);
+	MxResult WriteEndOfVariables(LegoStream* p_stream);
+	void SetROIHandlerFunction();
+
+	char* m_savePath;                           // 0x0
+	MxS16 m_stateCount;                         // 0x4
+	LegoState** m_stateArray;                   // 0x8
+	MxU8 m_unk0xc;                              // 0xc
+	MxU32 m_unk0x10;                            // 0x10
+	MxS32 m_currentAct;                         // 0x14
+	LegoBackgroundColor* m_backgroundColor;     // 0x18
+	LegoBackgroundColor* m_tempBackgroundColor; // 0x1c
+	LegoFullScreenMovie* m_fullScreenMovie;     // 0x20
+	MxU16 m_unk0x24;                            // 0x24
+	undefined m_unk0x28[128];                   // 0x28
+	ScoreStruct m_unk0xa6;                      // 0xa6
+	undefined m_unk0x41a[8];                    // 0x41a - might be part of the structure at 0xa6
+	MxBool m_isDirty;                           // 0x420
+	undefined4 m_unk0x424;                      // 0x424
+	undefined4 m_unk0x428;                      // 0x428
+	undefined4 m_unk0x42c;                      // 0x42c
+};
+
+MxBool ROIHandlerFunction(char* p_input, char* p_output, MxU32 p_copyLen);
+
+#endif // LEGOGAMESTATE_H

LEGO1/lego/legoomni/include/legohideanimpresenter.h

@@ -0,0 +1,29 @@
+#ifndef LEGOHIDEANIMPRESENTER_H
+#define LEGOHIDEANIMPRESENTER_H
+
+#include "legoloopinganimpresenter.h"
+
+// VTABLE: LEGO1 0x100d9278
+// SIZE 0xc4
+class LegoHideAnimPresenter : public LegoLoopingAnimPresenter {
+public:
+	LegoHideAnimPresenter();
+
+	// FUNCTION: LEGO1 0x1006d880
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f06cc
+		return "LegoHideAnimPresenter";
+	}
+
+	// FUNCTION: LEGO1 0x1006d890
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, ClassName()) || LegoAnimPresenter::IsA(p_name);
+	}
+
+private:
+	void Init();
+};
+
+#endif // LEGOHIDEANIMPRESENTER_H

LEGO1/lego/legoomni/include/legoinputmanager.h

@@ -0,0 +1,117 @@
+#ifndef LEGOINPUTMANAGER_H
+#define LEGOINPUTMANAGER_H
+
+#include "decomp.h"
+#include "legoeventnotificationparam.h"
+#include "legoworld.h"
+#include "mxlist.h"
+#include "mxpresenter.h"
+#include "mxqueue.h"
+
+#include <dinput.h>
+
+class LegoControlManager;
+
+// VTABLE: LEGO1 0x100d87b8
+// class MxCollection<LegoEventNotificationParam>
+
+// VTABLE: LEGO1 0x100d87d0
+// class MxList<LegoEventNotificationParam>
+
+// VTABLE: LEGO1 0x100d87e8
+// class MxQueue<LegoEventNotificationParam>
+
+// VTABLE: LEGO1 0x100d8800
+// SIZE 0x18
+class LegoEventQueue : public MxQueue<LegoEventNotificationParam> {};
+
+// VTABLE: LEGO1 0x100d8760
+// SIZE 0x338
+class LegoInputManager : public MxPresenter {
+public:
+	LegoInputManager();
+	virtual ~LegoInputManager() override;
+
+	__declspec(dllexport) void QueueEvent(NotificationId p_id, MxU8 p_modifier, MxLong p_x, MxLong p_y, MxU8 p_key);
+	__declspec(dllexport) void Register(MxCore*);
+	__declspec(dllexport) void UnRegister(MxCore*);
+
+	virtual MxResult Tickle() override; // vtable+0x8
+
+	MxResult Create(HWND p_hwnd);
+	void Destroy();
+	void CreateAndAcquireKeyboard(HWND p_hwnd);
+	void ReleaseDX();
+	MxResult GetJoystickId();
+	MxResult GetJoystickState(MxU32* p_joystickX, MxU32* p_joystickY, DWORD* p_buttonsState, MxU32* p_povPosition);
+	void SetTimer();
+	void KillTimer();
+	void SetCamera(LegoCameraController* p_camera);
+	void ClearCamera();
+	void SetWorld(LegoWorld* p_world);
+	void ClearWorld();
+
+	inline void SetUnknown88(MxBool p_unk0x88) { m_unk0x88 = p_unk0x88; }
+	inline void SetUnknown336(MxBool p_unk0x336) { m_unk0x336 = p_unk0x336; }
+
+	inline LegoControlManager* GetControlManager() { return m_controlManager; }
+	inline LegoWorld* GetWorld() { return m_world; }
+
+	void ProcessEvents();
+	MxBool ProcessOneEvent(LegoEventNotificationParam& p_param);
+
+	// private:
+	MxCriticalSection m_criticalSection;
+	MxList<undefined4>* m_unk0x5c; // list or hash table
+	LegoCameraController* m_camera;
+	LegoWorld* m_world;
+	LegoEventQueue* m_eventQueue; // +0x68
+	undefined4 m_unk0x6c;
+	undefined4 m_unk0x70;
+	undefined4 m_unk0x74;
+	UINT m_timer;
+	UINT m_timeout;
+	undefined m_unk0x80;
+	undefined m_unk0x81;
+	LegoControlManager* m_controlManager;
+	MxBool m_unk0x88;
+	IDirectInput* m_directInput;
+	IDirectInputDevice* m_directInputDevice;
+	undefined m_unk0x94;
+	undefined4 m_unk0x98;
+	undefined m_unk0x9c[0xF8];
+	undefined m_unk0x194;
+	MxBool m_unk0x195;
+	MxS32 m_joyid;
+	MxS32 m_joystickIndex;
+	JOYCAPS m_joyCaps;
+	MxBool m_useJoystick;
+	MxBool m_unk0x335;
+	MxBool m_unk0x336;
+};
+
+// TEMPLATE: LEGO1 0x1005bb80
+// MxCollection<LegoEventNotificationParam>::Compare
+
+// TEMPLATE: LEGO1 0x1005bc30
+// MxCollection<LegoEventNotificationParam>::Destroy
+
+// TEMPLATE: LEGO1 0x1005bc80
+// MxList<LegoEventNotificationParam>::~MxList<LegoEventNotificationParam>
+
+// SYNTHETIC: LEGO1 0x1005bd50
+// MxCollection<LegoEventNotificationParam>::`scalar deleting destructor'
+
+// SYNTHETIC: LEGO1 0x1005bdc0
+// MxList<LegoEventNotificationParam>::`scalar deleting destructor'
+
+// SYNTHETIC: LEGO1 0x1005beb0
+// LegoEventQueue::`scalar deleting destructor'
+
+// SYNTHETIC: LEGO1 0x1005bf70
+// MxQueue<LegoEventNotificationParam>::`scalar deleting destructor'
+
+// TEMPLATE: LEGO1 0x1005d010
+// MxListEntry<LegoEventNotificationParam>::GetValue
+
+#endif // LEGOINPUTMANAGER_H

LEGO1/lego/legoomni/include/legojetski.h

@@ -0,0 +1,23 @@
+#ifndef LEGOJETSKI_H
+#define LEGOJETSKI_H
+
+#include "legojetskiraceactor.h"
+
+// VTABLE: LEGO1 0x100d5a40
+class LegoJetski : public LegoJetskiRaceActor {
+public:
+	// FUNCTION: LEGO1 0x10013e80
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f053c
+		return "LegoJetski";
+	}
+
+	// FUNCTION: LEGO1 0x10013ea0
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoJetski::ClassName()) || LegoJetskiRaceActor::IsA(p_name);
+	}
+};
+
+#endif // LEGOJETSKI_H

LEGO1/lego/legoomni/include/legojetskiraceactor.h

@@ -0,0 +1,23 @@
+#ifndef LEGOJETSKIRACEACTOR_H
+#define LEGOJETSKIRACEACTOR_H
+
+#include "legocarraceactor.h"
+
+// VTABLE: LEGO1 0x100da240
+class LegoJetskiRaceActor : public LegoCarRaceActor {
+public:
+	// FUNCTION: LEGO1 0x10081d80
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f0554
+		return "LegoJetskiRaceActor";
+	}
+
+	// FUNCTION: LEGO1 0x10081da0
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoJetskiRaceActor::ClassName()) || LegoCarRaceActor::IsA(p_name);
+	}
+};
+
+#endif // LEGOJETSKIRACEACTOR_H

LEGO1/lego/legoomni/include/legoloadcachesoundpresenter.h

@@ -0,0 +1,36 @@
+#ifndef LEGOLOADCACHESOUNDPRESENTER_H
+#define LEGOLOADCACHESOUNDPRESENTER_H
+
+#include "decomp.h"
+#include "mxwavepresenter.h"
+
+// VTABLE: LEGO1 0x100d5fa8
+// SIZE 0x90
+class LegoLoadCacheSoundPresenter : public MxWavePresenter {
+public:
+	LegoLoadCacheSoundPresenter();
+	virtual ~LegoLoadCacheSoundPresenter() override;
+
+	// FUNCTION: LEGO1 0x10018450
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f05a0
+		return "LegoLoadCacheSoundPresenter";
+	}
+
+private:
+	void Init();
+	void Destroy(MxBool p_fromDestructor);
+
+	undefined4* m_unk0x6c;   // 0x6c
+	undefined4* m_unk0x70;   // 0x70
+	undefined4 m_unk0x74;    // 0x74
+	undefined4 m_unk0x78;    // 0x78
+	undefined m_unk0x7c;     // 0x7c
+	undefined4 m_unk0x80[4]; // 0x80
+};
+
+// SYNTHETIC: LEGO1 0x10018460
+// LegoLoadCacheSoundPresenter::`scalar deleting destructor'
+
+#endif // LEGOLOADCACHESOUNDPRESENTER_H

LEGO1/lego/legoomni/include/legolocomotionanimpresenter.h

@@ -0,0 +1,28 @@
+#ifndef LEGOLOCOMOTIONANIMPRESENTER_H
+#define LEGOLOCOMOTIONANIMPRESENTER_H
+
+#include "legoloopinganimpresenter.h"
+
+// VTABLE: LEGO1 0x100d9170
+class LegoLocomotionAnimPresenter : public LegoLoopingAnimPresenter {
+public:
+	LegoLocomotionAnimPresenter();
+
+	// FUNCTION: LEGO1 0x1006ce50
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f06e4
+		return "LegoLocomotionAnimPresenter";
+	}
+
+	// FUNCTION: LEGO1 0x1006ce60
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, ClassName()) || LegoLoopingAnimPresenter::IsA(p_name);
+	}
+
+private:
+	void Init();
+};
+
+#endif // LEGOLOCOMOTIONANIMPRESENTER_H

LEGO1/lego/legoomni/include/legoloopinganimpresenter.h

@@ -0,0 +1,24 @@
+#ifndef LEGOLOOPINGANIMPRESENTER_H
+#define LEGOLOOPINGANIMPRESENTER_H
+
+#include "legoanimpresenter.h"
+
+// VTABLE: LEGO1 0x100d4900
+// SIZE 0xc0 (discovered through inlined constructor at 0x10009ecd)
+class LegoLoopingAnimPresenter : public LegoAnimPresenter {
+public:
+	// FUNCTION: LEGO1 0x1000c9a0
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f0700
+		return "LegoLoopingAnimPresenter";
+	}
+
+	// FUNCTION: LEGO1 0x1000c9b0
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, ClassName()) || LegoAnimPresenter::IsA(p_name);
+	}
+};
+
+#endif // LEGOLOOPINGANIMPRESENTER_H

LEGO1/lego/legoomni/include/legometerpresenter.h

@@ -0,0 +1,13 @@
+#ifndef LEGOMETERPRESENTER_H
+#define LEGOMETERPRESENTER_H
+
+#include "mxstillpresenter.h"
+
+// VTABLE: LEGO1 0x100d7ac8
+// SIZE 0x94 (from 0x1000a163)
+class LegoMeterPresenter : public MxStillPresenter {
+public:
+	// MxStillPresenter's `::ClassName` and `::IsA` are used.
+};
+
+#endif // LEGOMETERPRESENTER_H

LEGO1/lego/legoomni/include/legomodelpresenter.h

@@ -0,0 +1,33 @@
+#ifndef LEGOMODELPRESENTER_H
+#define LEGOMODELPRESENTER_H
+
+#include "mxvideopresenter.h"
+
+// VTABLE: LEGO1 0x100d4e50
+// SIZE 0x6c (discovered through inline constructor at 0x10009ae6)
+class LegoModelPresenter : public MxVideoPresenter {
+public:
+	__declspec(dllexport) static void configureLegoModelPresenter(MxS32 p_modelPresenterConfig);
+
+	// FUNCTION: LEGO1 0x1000ccb0
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f067c
+		return "LegoModelPresenter";
+	}
+
+	// FUNCTION: LEGO1 0x1000ccc0
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, ClassName()) || MxVideoPresenter::IsA(p_name);
+	}
+
+	virtual void ReadyTickle() override; // vtable+0x18
+	virtual void ParseExtra() override;  // vtable+0x30
+	virtual void Destroy() override;     // vtable+0x38
+
+protected:
+	void Destroy(MxBool p_fromDestructor);
+};
+
+#endif // LEGOMODELPRESENTER_H

LEGO1/lego/legoomni/include/legonavcontroller.h

@@ -0,0 +1,93 @@
+#ifndef LEGONAVCONTROLLER_H
+#define LEGONAVCONTROLLER_H
+
+#include "mxcore.h"
+#include "mxtimer.h"
+#include "mxtypes.h"
+
+// VTABLE: LEGO1 0x100d85b8
+// SIZE 0x70
+class LegoNavController : public MxCore {
+public:
+	__declspec(dllexport) static void GetDefaults(
+		int* p_mouseDeadzone,
+		float* p_movementMaxSpeed,
+		float* p_turnMaxSpeed,
+		float* p_movementMaxAccel,
+		float* p_turnMaxAccel,
+		float* p_movementDecel,
+		float* p_turnDecel,
+		float* p_movementMinAccel,
+		float* p_turnMinAccel,
+		float* p_rotationSensitivity,
+		MxBool* p_turnUseVelocity
+	);
+	__declspec(dllexport) static void SetDefaults(
+		int p_mouseDeadzone,
+		float p_movementMaxSpeed,
+		float p_turnMaxSpeed,
+		float p_movementMaxAccel,
+		float p_turnMaxAccel,
+		float p_movementDecel,
+		float p_turnDecel,
+		float p_movementMinAccel,
+		float p_turnMinAccel,
+		float p_rotationSensitivity,
+		MxBool p_turnUseVelocity
+	);
+
+	LegoNavController();
+	virtual ~LegoNavController() override; // vtable+0x0
+
+	// FUNCTION: LEGO1 0x10054b80
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f66d8
+		return "LegoNavController";
+	}
+
+	// FUNCTION: LEGO1 0x10054b90
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, ClassName()) || MxCore::IsA(p_name);
+	}
+
+	void SetControlMax(int p_hMax, int p_vMax);
+	void ResetToDefault();
+	void SetTargets(int p_hPos, int p_vPos, MxBool p_accel);
+	float CalculateNewTargetSpeed(int p_pos, int p_center, float p_maxSpeed);
+	float CalculateNewAccel(int p_pos, int p_center, float p_maxAccel, int p_minAccel);
+	float CalculateNewVel(float p_targetVel, float p_currentVel, float p_accel, float p_time);
+
+private:
+	int m_hMax;
+	int m_vMax;
+	int m_mouseDeadzone;
+	float m_zeroThreshold;
+	float m_unk0x18;
+	float m_unk0x1c;
+	float m_targetMovementSpeed;
+	float m_targetTurnSpeed;
+	float m_movementMaxSpeed;
+	float m_turnMaxSpeed;
+	float m_movementAccel;
+	float m_turnAccel;
+	float m_movementMaxAccel;
+	float m_turnMaxAccel;
+	float m_movementMinAccel;
+	float m_turnMinAccel;
+	float m_movementDecel;
+	float m_turnDecel;
+	float m_turnSensitivity;
+	MxBool m_turnUseVelocity;
+	int m_time;
+	MxBool m_trackDefault;
+	MxBool m_unk0x5d;
+	char m_unk0x5e[2];
+	int m_unk0x60;
+	int m_unk0x64;
+	int m_unk0x68;
+	MxBool m_unk0x6c;
+};
+
+#endif // LEGONAVCONTROLLER_H

LEGO1/lego/legoomni/include/legoobjectfactory.h

@@ -0,0 +1,117 @@
+#ifndef LEGOOBJECTFACTORY_H
+#define LEGOOBJECTFACTORY_H
+
+#include "mxobjectfactory.h"
+
+#define FOR_LEGOOBJECTFACTORY_OBJECTS(X)                                                                               \
+	X(LegoModelPresenter)                                                                                              \
+	X(LegoTexturePresenter)                                                                                            \
+	X(LegoPhonemePresenter)                                                                                            \
+	X(LegoFlcTexturePresenter)                                                                                         \
+	X(LegoEntityPresenter)                                                                                             \
+	X(LegoActorPresenter)                                                                                              \
+	X(LegoWorldPresenter)                                                                                              \
+	X(LegoWorld)                                                                                                       \
+	X(LegoPalettePresenter)                                                                                            \
+	X(LegoPathPresenter)                                                                                               \
+	X(LegoAnimPresenter)                                                                                               \
+	X(LegoLoopingAnimPresenter)                                                                                        \
+	X(LegoLocomotionAnimPresenter)                                                                                     \
+	X(LegoHideAnimPresenter)                                                                                           \
+	X(LegoPartPresenter)                                                                                               \
+	X(LegoCarBuildAnimPresenter)                                                                                       \
+	X(LegoActionControlPresenter)                                                                                      \
+	X(MxVideoPresenter)                                                                                                \
+	X(LegoLoadCacheSoundPresenter)                                                                                     \
+	X(Lego3DWavePresenter)                                                                                             \
+	X(LegoActor)                                                                                                       \
+	X(LegoPathActor)                                                                                                   \
+	X(LegoRaceCar)                                                                                                     \
+	X(LegoJetski)                                                                                                      \
+	/*X(JetskiRace) \*/                                                                                                \
+	X(LegoEntity)                                                                                                      \
+	X(LegoCarRaceActor)                                                                                                \
+	X(LegoJetskiRaceActor)                                                                                             \
+	X(LegoCarBuild)                                                                                                    \
+	X(Infocenter)                                                                                                      \
+	X(LegoAnimActor)                                                                                                   \
+	X(MxControlPresenter)                                                                                              \
+	X(RegistrationBook)                                                                                                \
+	X(HistoryBook)                                                                                                     \
+	X(ElevatorBottom)                                                                                                  \
+	X(InfocenterDoor)                                                                                                  \
+	X(Score)                                                                                                           \
+	X(ScoreState)                                                                                                      \
+	X(Hospital)                                                                                                        \
+	X(Isle)                                                                                                            \
+	X(Police)                                                                                                          \
+	X(GasStation)                                                                                                      \
+	X(LegoAct2)                                                                                                        \
+	X(LegoAct2State)                                                                                                   \
+	/*X(CarRace)*/                                                                                                     \
+	X(HospitalState)                                                                                                   \
+	X(InfocenterState)                                                                                                 \
+	X(PoliceState)                                                                                                     \
+	X(GasStationState)                                                                                                 \
+	X(SkateBoard)                                                                                                      \
+	X(Helicopter)                                                                                                      \
+	X(HelicopterState)                                                                                                 \
+	X(DuneBuggy)                                                                                                       \
+	X(Pizza)                                                                                                           \
+	X(PizzaMissionState)                                                                                               \
+	/*X(Act2Actor)*/                                                                                                   \
+	/*X(Act2Brick)*/                                                                                                   \
+	/*X(Act2GenActor)*/                                                                                                \
+	X(Act2PoliceStation)                                                                                               \
+	X(Act3)                                                                                                            \
+	X(Act3State)                                                                                                       \
+	X(Doors)                                                                                                           \
+	X(LegoAnimMMPresenter)                                                                                             \
+	X(RaceCar)                                                                                                         \
+	X(Jetski)                                                                                                          \
+	X(Bike)                                                                                                            \
+	X(Motorcycle)                                                                                                      \
+	X(Ambulance)                                                                                                       \
+	X(AmbulanceMissionState)                                                                                           \
+	X(TowTrack)                                                                                                        \
+	X(TowTrackMissionState)                                                                                            \
+	/*X(Act3Cop)*/                                                                                                     \
+	/*X(Act3Brickster)*/                                                                                               \
+	X(Act3Shark)                                                                                                       \
+	X(BumpBouy)                                                                                                        \
+	X(Act3Actor)                                                                                                       \
+	X(JetskiRaceState)                                                                                                 \
+	X(CarRaceState)                                                                                                    \
+	X(Act1State)                                                                                                       \
+	X(Pizzeria)                                                                                                        \
+	X(PizzeriaState)                                                                                                   \
+	X(InfoCenterEntity)                                                                                                \
+	X(HospitalEntity)                                                                                                  \
+	X(GasStationEntity)                                                                                                \
+	X(PoliceEntity)                                                                                                    \
+	X(BeachHouseEntity)                                                                                                \
+	X(RaceStandsEntity)                                                                                                \
+	X(JukeBoxEntity)                                                                                                   \
+	X(RadioState)                                                                                                      \
+	/*X(CaveEntity)*/                                                                                                  \
+	/*X(JailEntity)*/                                                                                                  \
+	X(MxCompositeMediaPresenter)                                                                                       \
+	X(JukeBox)                                                                                                         \
+	X(JukeBoxState)                                                                                                    \
+	/*X(RaceSkel)*/                                                                                                    \
+	X(AnimState)
+
+// VTABLE: LEGO1 0x100d4768
+class LegoObjectFactory : public MxObjectFactory {
+public:
+	LegoObjectFactory();
+	virtual MxCore* Create(const char* p_name) override; // vtable 0x14
+	virtual void Destroy(MxCore* p_object) override;     // vtable 0x18
+
+private:
+#define X(V) MxAtomId m_id##V;
+	FOR_LEGOOBJECTFACTORY_OBJECTS(X)
+#undef X
+};
+
+#endif // LEGOOBJECTFACTORY_H

LEGO1/lego/legoomni/include/legoomni.h

@@ -0,0 +1,187 @@
+#ifndef LEGOOMNI_H
+#define LEGOOMNI_H
+
+#include "compat.h"
+#include "mxdsaction.h"
+#include "mxomni.h"
+
+class GifManager;
+class Isle;
+class IslePathActor;
+class LegoAnimationManager;
+class LegoBuildingManager;
+class LegoControlManager;
+class LegoEntity;
+class LegoGameState;
+class LegoInputManager;
+class LegoNavController;
+class LegoPathBoundary;
+class LegoPlantManager;
+class LegoROI;
+class LegoSoundManager;
+class LegoUnkSaveDataWriter;
+class LegoVideoManager;
+class LegoWorld;
+class LegoWorldList;
+class MxAtomId;
+class MxBackgroundAudioManager;
+class MxDSFile;
+class MxTransitionManager;
+class ViewLODListManager;
+
+extern MxAtomId* g_copterScript;
+extern MxAtomId* g_dunecarScript;
+extern MxAtomId* g_jetskiScript;
+extern MxAtomId* g_racecarScript;
+extern MxAtomId* g_carraceScript;
+extern MxAtomId* g_carracerScript;
+extern MxAtomId* g_jetraceScript;
+extern MxAtomId* g_jetracerScript;
+extern MxAtomId* g_isleScript;
+extern MxAtomId* g_elevbottScript;
+extern MxAtomId* g_infodoorScript;
+extern MxAtomId* g_infomainScript;
+extern MxAtomId* g_infoscorScript;
+extern MxAtomId* g_regbookScript;
+extern MxAtomId* g_histbookScript;
+extern MxAtomId* g_hospitalScript;
+extern MxAtomId* g_policeScript;
+extern MxAtomId* g_garageScript;
+extern MxAtomId* g_act2mainScript;
+extern MxAtomId* g_act3Script;
+extern MxAtomId* g_jukeboxScript;
+extern MxAtomId* g_pz5Script;
+extern MxAtomId* g_introScript;
+extern MxAtomId* g_testScript;
+extern MxAtomId* g_jukeboxwScript;
+extern MxAtomId* g_sndAnimScript;
+extern MxAtomId* g_creditsScript;
+extern MxAtomId* g_nocdSourceName;
+
+// VTABLE: LEGO1 0x100d8638
+// SIZE 0x140
+class LegoOmni : public MxOmni {
+public:
+	__declspec(dllexport) void CreateBackgroundAudio();
+	__declspec(dllexport) void RemoveWorld(const MxAtomId&, MxLong);
+	__declspec(dllexport) static int GetCurrPathInfo(LegoPathBoundary**, MxS32&);
+	__declspec(dllexport) static void CreateInstance();
+	__declspec(dllexport) static LegoOmni* GetInstance();
+
+	LegoOmni();
+	virtual ~LegoOmni(); // vtable+00
+
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+04
+
+	// FUNCTION: LEGO1 0x10058aa0
+	inline virtual const char* ClassName() const override // vtable+0c
+	{
+		// STRING: LEGO1 0x100f671c
+		return "LegoOmni";
+	}
+
+	// FUNCTION: LEGO1 0x10058ab0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+10
+	{
+		return !strcmp(p_name, LegoOmni::ClassName()) || MxOmni::IsA(p_name);
+	}
+
+	virtual void Init() override;                                                                       // vtable+14
+	virtual MxResult Create(MxOmniCreateParam& p_param) override;                                       // vtable+18
+	virtual void Destroy() override;                                                                    // vtable+1c
+	virtual MxResult Start(MxDSAction* p_dsAction) override;                                            // vtable+20
+	virtual void DeleteObject(MxDSAction& p_dsAction) override;                                         // vtable+24
+	virtual MxBool DoesEntityExist(MxDSAction& p_dsAction) override;                                    // vtable+28
+	virtual MxEntity* FindWorld(const char* p_id, MxS32 p_entityId, MxPresenter* p_presenter) override; // vtable+30
+	virtual void NotifyCurrentEntity(MxNotificationParam* p_param) override;                            // vtable+34
+	virtual void StartTimer() override;                                                                 // vtable+38
+	virtual void StopTimer() override;                                                                  // vtable+3c
+
+	LegoEntity* FindByEntityIdOrAtomId(const MxAtomId& p_atom, MxS32 p_entityid);
+	void AddWorld(LegoWorld* p_world);
+
+	LegoVideoManager* GetVideoManager() { return (LegoVideoManager*) m_videoManager; }
+	LegoSoundManager* GetSoundManager() { return (LegoSoundManager*) m_soundManager; }
+
+	LegoInputManager* GetInputManager() { return m_inputMgr; }
+	GifManager* GetGifManager() { return m_gifManager; }
+	LegoWorld* GetCurrentOmniWorld() { return m_currentWorld; }
+	LegoNavController* GetNavController() { return m_navController; }
+	IslePathActor* GetCurrentVehicle() { return m_currentVehicle; }
+	LegoPlantManager* GetLegoPlantManager() { return m_plantManager; }
+	LegoAnimationManager* GetAnimationManager() { return m_animationManager; }
+	LegoBuildingManager* GetLegoBuildingManager() { return m_buildingManager; }
+	LegoGameState* GetGameState() { return m_gameState; }
+	MxBackgroundAudioManager* GetBackgroundAudioManager() { return m_bkgAudioManager; }
+	MxTransitionManager* GetTransitionManager() { return m_transitionManager; }
+	MxDSAction& GetCurrentAction() { return m_action; }
+
+	inline void SetExit(MxBool p_exit) { m_exit = p_exit; };
+
+private:
+	undefined4* m_unk0x68;                       // 0x68
+	ViewLODListManager* m_viewLODListManager;    // 0x6c
+	LegoInputManager* m_inputMgr;                // 0x70
+	GifManager* m_gifManager;                    // 0x74
+	LegoWorldList* m_worldList;                  // 0x78
+	LegoWorld* m_currentWorld;                   // 0x7c
+	MxBool m_exit;                               // 0x80
+	LegoNavController* m_navController;          // 0x84
+	IslePathActor* m_currentVehicle;             // 0x88
+	LegoUnkSaveDataWriter* m_saveDataWriter;     // 0x8c
+	LegoPlantManager* m_plantManager;            // 0x90
+	LegoAnimationManager* m_animationManager;    // 0x94
+	LegoBuildingManager* m_buildingManager;      // 0x98
+	LegoGameState* m_gameState;                  // 0x9c
+	MxDSAction m_action;                         // 0xa0
+	MxBackgroundAudioManager* m_bkgAudioManager; // 0x134
+	MxTransitionManager* m_transitionManager;    // 0x138
+	MxBool m_unk0x13c;                           // 0x13c
+};
+
+__declspec(dllexport) MxBackgroundAudioManager* BackgroundAudioManager();
+__declspec(dllexport) MxDSObject* CreateStreamObject(MxDSFile*, MxS16);
+__declspec(dllexport) LegoGameState* GameState();
+__declspec(dllexport) const char* GetNoCD_SourceName();
+__declspec(dllexport) LegoInputManager* InputManager();
+__declspec(dllexport) LegoOmni* Lego();
+__declspec(dllexport) void MakeSourceName(char*, const char*);
+__declspec(dllexport) LegoEntity* PickEntity(MxLong, MxLong);
+__declspec(dllexport) LegoROI* PickROI(MxLong, MxLong);
+__declspec(dllexport) void SetOmniUserMessage(void (*)(const char*, int));
+__declspec(dllexport) LegoSoundManager* SoundManager();
+__declspec(dllexport) MxResult Start(MxDSAction*);
+__declspec(dllexport) MxTransitionManager* TransitionManager();
+__declspec(dllexport) LegoVideoManager* VideoManager();
+
+LegoAnimationManager* AnimationManager();
+LegoBuildingManager* BuildingManager();
+LegoControlManager* ControlManager();
+IslePathActor* GetCurrentVehicle();
+LegoPlantManager* PlantManager();
+MxBool KeyValueStringParse(char*, const char*, const char*);
+LegoWorld* GetCurrentWorld();
+GifManager* GetGifManager();
+void FUN_10015820(MxU32, MxU32);
+LegoEntity* FindEntityByAtomIdOrEntityId(const MxAtomId& p_atom, MxS32 p_entityid);
+MxDSAction& GetCurrentAction();
+
+MxBool FUN_100b6e10(
+	MxS32 p_bitmapWidth,
+	MxS32 p_bitmapHeight,
+	MxS32 p_videoParamWidth,
+	MxS32 p_videoParamHeight,
+	MxS32* p_left,
+	MxS32* p_top,
+	MxS32* p_right,
+	MxS32* p_bottom,
+	MxS32* p_width,
+	MxS32* p_height
+);
+
+void PlayMusic(MxU32 p_index);
+void SetIsWorldActive(MxBool p_isWorldActive);
+void RegisterScripts();
+void UnregisterScripts();
+
+#endif // LEGOOMNI_H

LEGO1/lego/legoomni/include/legopalettepresenter.h

@@ -0,0 +1,40 @@
+#ifndef LEGOPALETTEPRESENTER_H
+#define LEGOPALETTEPRESENTER_H
+
+#include "decomp.h"
+#include "mxpalette.h"
+#include "mxvideopresenter.h"
+
+// VTABLE: LEGO1 0x100d9aa0
+// SIZE 0x68
+class LegoPalettePresenter : public MxVideoPresenter {
+public:
+	LegoPalettePresenter();
+	virtual ~LegoPalettePresenter() override; // vtable+0x0
+
+	// FUNCTION: LEGO1 0x10079f30
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f061c
+		return "LegoPalettePresenter";
+	}
+
+	// FUNCTION: LEGO1 0x10079f40
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, ClassName()) || MxVideoPresenter::IsA(p_name);
+	}
+
+	virtual void ReadyTickle() override; // vtable+0x18
+	virtual void Destroy() override;     // vtable+0x38
+
+	MxResult ParsePallete(MxStreamChunk* p_chunk);
+
+private:
+	void Init();
+	void Destroy(MxBool p_fromDestructor);
+
+	MxPalette* m_palette; // 0x64
+};
+
+#endif // LEGOPALETTEPRESENTER_H

LEGO1/lego/legoomni/include/legopartpresenter.h

@@ -0,0 +1,26 @@
+#ifndef LEGOPARTPRESENTER_H
+#define LEGOPARTPRESENTER_H
+
+#include "mxmediapresenter.h"
+
+// VTABLE: LEGO1 0x100d4df0
+// SIZE 0x54 (from inlined construction at 0x10009fac)
+class LegoPartPresenter : public MxMediaPresenter {
+public:
+	// FUNCTION: LEGO1 0x1000cf70
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f05d8
+		return "LegoPartPresenter";
+	}
+
+	// FUNCTION: LEGO1 0x1000cf80
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoPartPresenter::ClassName()) || MxMediaPresenter::IsA(p_name);
+	}
+
+	__declspec(dllexport) static void configureLegoPartPresenter(MxS32, MxS32);
+};
+
+#endif // LEGOPARTPRESENTER_H

LEGO1/lego/legoomni/include/legopathactor.h

@@ -0,0 +1,84 @@
+#ifndef LEGOPATHACTOR_H
+#define LEGOPATHACTOR_H
+
+#include "legoactor.h"
+#include "mxtypes.h"
+#include "realtime/matrix.h"
+
+// VTABLE: LEGO1 0x100d6e28
+// SIZE 0x154 (from inlined construction at 0x1000a346)
+class LegoPathActor : public LegoActor {
+public:
+	LegoPathActor();
+	virtual ~LegoPathActor() override;
+
+	// FUNCTION: LEGO1 0x1000c430
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f0114
+		return "LegoPathActor";
+	}
+
+	// FUNCTION: LEGO1 0x1000c440
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoPathActor::ClassName()) || LegoActor::IsA(p_name);
+	}
+
+	virtual void VTable0x68();                         // vtable+0x68
+	virtual void VTable0x6c();                         // vtable+0x6c
+	virtual void VTable0x70(float p_float);            // vtable+0x70
+	virtual void VTable0x74(Matrix4Impl& p_transform); // vtable+0x74
+	// FUNCTION: LEGO1 0x10002d20
+	virtual void VTable0x78(MxU8 p_unk0xea) { m_unk0xea = p_unk0xea; } // vtable+0x78
+	// FUNCTION: LEGO1 0x10002d30
+	virtual MxU8 VTable0x7c() { return m_unk0xea; } // 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_unk0x13c) { m_unk0x13c = p_unk0x13c; } // vtable+0xac
+	// FUNCTION: LEGO1 0x10002d80
+	virtual MxFloat VTable0xb0() { return m_unk0x13c; } // vtable+0xb0
+	// FUNCTION: LEGO1 0x10002d90
+	virtual MxFloat VTable0xb4() { return m_unk0x140; } // vtable+0xb4
+	// FUNCTION: LEGO1 0x10002da0
+	virtual MxFloat VTable0xb8() { return m_unk0x144; } // vtable+0xb8
+	// FUNCTION: LEGO1 0x10002db0
+	virtual void VTable0xbc(MxFloat p_unk0x140) { m_unk0x140 = p_unk0x140; } // vtable+0xbc
+	// FUNCTION: LEGO1 0x10002dc0
+	virtual void VTable0xc0(MxFloat p_unk0x144) { m_unk0x144 = p_unk0x144; } // vtable+0xc0
+	// FUNCTION: LEGO1 0x10002dd0
+	virtual void VTable0xc4() {} // vtable+0xc4
+	// FUNCTION: LEGO1 0x10002de0
+	virtual void VTable0xc8(MxU8 p_unk0x148) { m_unk0x148 = p_unk0x148; } // vtable+0xc8
+
+	inline void SetUnknownDC(MxU32 p_unk0xdc) { m_unk0xdc = p_unk0xdc; }
+
+protected:
+	undefined m_unk0x78[0x64]; // 0x78
+	MxU32 m_unk0xdc;           // 0xdc
+	undefined m_unk0xe0[0xa];  // 0xe0
+	MxU8 m_unk0xea;            // 0xea
+	undefined m_unk0xef[0x4d]; // 0xef
+	MxU32 m_unk0x138;          // 0x138
+	MxFloat m_unk0x13c;        // 0x13c
+	MxFloat m_unk0x140;        // 0x140
+	MxFloat m_unk0x144;        // 0x144
+	MxU8 m_unk0x148;           // 0x148
+	MxS32 m_unk0x14c;          // 0x14c
+	MxFloat m_unk0x150;        // 0x150
+};
+
+#endif // LEGOPATHACTOR_H

LEGO1/lego/legoomni/include/legopathboundary.h

@@ -0,0 +1,6 @@
+#ifndef LEGOPATHBOUNDARH_H
+#define LEGOPATHBOUNDARH_H
+
+class LegoPathBoundary {};
+
+#endif // LEGOPATHBOUNDARH_H

LEGO1/lego/legoomni/include/legopathcontroller.h

@@ -0,0 +1,29 @@
+#ifndef LEGOPATHCONTROLLER_H
+#define LEGOPATHCONTROLLER_H
+
+#include "mxcore.h"
+
+// VTABLE: LEGO1 0x100d7d60
+// SIZE 0x40
+class LegoPathController : public MxCore {
+public:
+	LegoPathController();
+	virtual ~LegoPathController() override;
+
+	virtual MxResult Tickle() override; // vtable+08
+
+	// FUNCTION: LEGO1 0x10045110
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f11b8
+		return "LegoPathController";
+	}
+
+	// FUNCTION: LEGO1 0x10045120
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoPathController::ClassName()) || MxCore::IsA(p_name);
+	}
+};
+
+#endif // LEGOPATHCONTROLLER_H

LEGO1/lego/legoomni/include/legopathcontrollerlist.h

@@ -0,0 +1,57 @@
+#ifndef LEGOPATHCONTROLLERLIST_H
+#define LEGOPATHCONTROLLERLIST_H
+
+#include "legopathcontroller.h"
+#include "mxlist.h"
+#include "mxtypes.h"
+
+// VTABLE: LEGO1 0x100d6320
+// class MxPtrList<LegoPathController>
+
+// VTABLE: LEGO1 0x100d6338
+// SIZE 0x18
+class LegoPathControllerList : public MxPtrList<LegoPathController> {
+public:
+	LegoPathControllerList(MxBool p_ownership = FALSE) : MxPtrList<LegoPathController>(p_ownership) {}
+
+	// FUNCTION: LEGO1 0x1001d210
+	virtual MxS8 Compare(LegoPathController* p_a, LegoPathController* p_b) override
+	{
+		return p_a == p_b ? 0 : p_a < p_b ? -1 : 1;
+	} // vtable+0x14
+};
+
+// VTABLE: LEGO1 0x100d6380
+// class MxCollection<LegoPathController *>
+
+// VTABLE: LEGO1 0x100d6398
+// class MxList<LegoPathController *>
+
+// TEMPLATE: LEGO1 0x1001d230
+// MxCollection<LegoPathController *>::Compare
+
+// TEMPLATE: LEGO1 0x1001d240
+// MxList<LegoPathController *>::MxList<LegoPathController *>
+
+// TEMPLATE: LEGO1 0x1001d2d0
+// MxCollection<LegoPathController *>::~MxCollection<LegoPathController *>
+
+// TEMPLATE: LEGO1 0x1001d320
+// MxCollection<LegoPathController *>::Destroy
+
+// TEMPLATE: LEGO1 0x1001d330
+// MxList<LegoPathController *>::~MxList<LegoPathController *>
+
+// TEMPLATE: LEGO1 0x1001d3c0
+// MxPtrList<LegoPathController>::Destroy
+
+// SYNTHETIC: LEGO1 0x1001d490
+// MxCollection<LegoPathController *>::`scalar deleting destructor'
+
+// SYNTHETIC: LEGO1 0x1001d500
+// MxList<LegoPathController *>::`scalar deleting destructor'
+
+// SYNTHETIC: LEGO1 0x1001d5b0
+// MxPtrList<LegoPathController>::`scalar deleting destructor'
+
+#endif // LEGOPATHCONTROLLERLIST_H

LEGO1/lego/legoomni/include/legopathpresenter.h

@@ -0,0 +1,39 @@
+#ifndef LEGOPATHPRESENTER_H
+#define LEGOPATHPRESENTER_H
+
+#include "mxmediapresenter.h"
+
+// VTABLE: LEGO1 0x100d7c10
+// SIZE 0x54
+class LegoPathPresenter : public MxMediaPresenter {
+public:
+	LegoPathPresenter();
+
+	// FUNCTION: LEGO1 0x100449a0
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f0690
+		return "LegoPathPresenter";
+	}
+
+	// FUNCTION: LEGO1 0x100449b0
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoPathPresenter::ClassName()) || MxMediaPresenter::IsA(p_name);
+	}
+
+	virtual void RepeatingTickle() override;  // vtable+0x24
+	virtual void ParseExtra() override;       // vtable+0x30
+	virtual MxResult AddToManager() override; // vtable+0x34
+	virtual void Destroy() override;          // vtable+0x38
+
+private:
+	void Init();
+
+protected:
+	void Destroy(MxBool p_fromDestructor);
+
+	MxAtomId m_atomId; // 0x50
+};
+
+#endif // LEGOPATHPRESENTER_H

LEGO1/lego/legoomni/include/legophonemepresenter.h

@@ -0,0 +1,32 @@
+#ifndef LEGOPHONEMEPRESENTER_H
+#define LEGOPHONEMEPRESENTER_H
+
+#include "decomp.h"
+#include "mxflcpresenter.h"
+#include "mxstring.h"
+#include "mxtypes.h"
+
+// VTABLE: LEGO1 0x100d8040
+// SIZE 0x88
+class LegoPhonemePresenter : public MxFlcPresenter {
+public:
+	LegoPhonemePresenter();
+	virtual ~LegoPhonemePresenter() override; // vtable+0x0
+
+	// FUNCTION: LEGO1 0x1004e310
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f064c
+		return "LegoPhonemePresenter";
+	}
+
+private:
+	void Init();
+	int m_unk0x68;
+	int m_unk0x6c;
+	undefined m_unk0x70;
+	MxString m_string; // 0x74
+	undefined m_unk0x84;
+};
+
+#endif // LEGOPHONEMEPRESENTER_H

LEGO1/lego/legoomni/include/legoplantmanager.h

@@ -0,0 +1,26 @@
+#ifndef LEGOPLANTMANAGER_H
+#define LEGOPLANTMANAGER_H
+
+#include "mxcore.h"
+
+// VTABLE: LEGO1 0x100d6758
+// SIZE 0x2c
+class LegoPlantManager : public MxCore {
+public:
+	LegoPlantManager();
+	virtual ~LegoPlantManager() override; // vtable+0x0
+
+	virtual MxResult Tickle() override; // vtable+0x8
+
+	// FUNCTION: LEGO1 0x10026290
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f318c
+		return "LegoPlantManager";
+	}
+
+private:
+	void Init();
+};
+
+#endif // LEGOPLANTMANAGER_H

LEGO1/lego/legoomni/include/legorace.h

@@ -0,0 +1,64 @@
+#ifndef LEGORACE_H
+#define LEGORACE_H
+
+#include "decomp.h"
+#include "legoworld.h"
+#include "mxrect32.h"
+#include "mxtypes.h"
+
+// VTABLE: LEGO1 0x100d5db0
+// SIZE 0x144
+class LegoRace : public LegoWorld {
+public:
+	LegoRace();
+	virtual ~LegoRace() override; // vtable+0x0
+
+	virtual MxLong Notify(MxParam& p_param) override; // vtable+0x4
+
+	// FUNCTION: LEGO1 0x10015ba0
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f07c4
+		return "LegoRace";
+	}
+
+	// FUNCTION: LEGO1 0x10015bb0
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoRace::ClassName()) || LegoWorld::IsA(p_name);
+	}
+
+	virtual MxResult Create(MxDSObject& p_dsObject) override; // vtable+0x18
+	virtual MxBool VTable0x5c() override;                     // vtable+0x5c
+	virtual MxBool VTable0x64() override;                     // vtable+0x64
+	virtual void VTable0x68(MxBool p_add) override;           // vtable+0x68
+	virtual undefined4 VTable0x6c(undefined4) = 0;            // vtable+0x6c
+	virtual undefined4 VTable0x70(undefined4);                // vtable+0x70
+	virtual undefined4 VTable0x74(undefined4);                // vtable+0x74
+	virtual undefined4 VTable0x78(undefined4);                // vtable+0x78
+	virtual void VTable0x7c(undefined4, undefined4);          // vtable+0x7c
+
+private:
+	undefined4 m_unk0xf8;  // 0xf8
+	undefined4 m_unk0xfc;  // 0xfc
+	undefined4 m_unk0x100; // 0x100
+	undefined4 m_unk0x104; // 0x104
+	undefined4 m_unk0x108; // 0x108
+	undefined4 m_unk0x10c; // 0x10c
+	undefined4 m_unk0x110; // 0x110
+	undefined4 m_unk0x114; // 0x114
+	undefined4 m_unk0x118; // 0x118
+	undefined4 m_unk0x11c; // 0x11c
+	undefined4 m_unk0x120; // 0x120
+	undefined4 m_unk0x124; // 0x124
+	undefined4 m_unk0x128; // 0x128
+	undefined4 m_unk0x12c; // 0x12c
+
+protected:
+	MxRect32 m_unk0x130; // 0x130
+
+private:
+	undefined4 m_unk0x140; // 0x140
+};
+
+#endif // LEGORACE_H

LEGO1/lego/legoomni/include/legoraceactor.h

@@ -0,0 +1,23 @@
+#ifndef LEGORACEACTOR_H
+#define LEGORACEACTOR_H
+
+#include "legoanimactor.h"
+
+// VTABLE: LEGO1 0x100d5b88
+class LegoRaceActor : public LegoAnimActor {
+public:
+	// FUNCTION: LEGO1 0x10014af0
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f0bf4
+		return "LegoRaceActor";
+	}
+
+	// FUNCTION: LEGO1 0x10014b10
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoRaceActor::ClassName()) || LegoAnimActor::IsA(p_name);
+	}
+};
+
+#endif // LEGORACEACTOR_H

LEGO1/lego/legoomni/include/legoracecar.h

@@ -0,0 +1,25 @@
+#ifndef LEGOCARRACE_H
+#define LEGOCARRACE_H
+
+#include "legocarraceactor.h"
+#include "legopathactor.h"
+
+// VTABLE: LEGO1 0x100d58b8
+// SIZE 0x200
+class LegoRaceCar : public LegoCarRaceActor {
+public:
+	// FUNCTION: LEGO1 0x10014290
+	inline const char* ClassName() const override // vtable+0xc
+	{
+		// STRING: LEGO1 0x100f0548
+		return "LegoRaceCar";
+	}
+
+	// FUNCTION: LEGO1 0x100142b0
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoCarRaceActor::ClassName()) || LegoCarRaceActor::IsA(p_name);
+	}
+};
+
+#endif // LEGOCARRACE_H

LEGO1/lego/legoomni/include/legosoundmanager.h

@@ -0,0 +1,25 @@
+#ifndef LEGOSOUNDMANAGER_H
+#define LEGOSOUNDMANAGER_H
+
+#include "mxsoundmanager.h"
+
+// VTABLE: LEGO1 0x100d6b10
+// SIZE 0x44
+class LegoSoundManager : public MxSoundManager {
+public:
+	LegoSoundManager();
+	virtual ~LegoSoundManager() override;
+
+	virtual MxResult Tickle() override;                                           // vtable+08
+	virtual void Destroy() override;                                              // vtable+18
+	virtual MxResult Create(MxU32 p_frequencyMS, MxBool p_createThread) override; // vtable+0x30
+
+private:
+	void Init();
+	void Destroy(MxBool p_fromDestructor);
+
+	undefined4 m_unk0x3c;
+	undefined4 m_unk0x40;
+};
+
+#endif // LEGOSOUNDMANAGER_H

LEGO1/lego/legoomni/include/legostate.h

@@ -0,0 +1,32 @@
+#ifndef LEGOSTATE_H
+#define LEGOSTATE_H
+
+#include "decomp.h"
+#include "legostream.h"
+#include "mxcore.h"
+#include "mxstring.h"
+
+// VTABLE: LEGO1 0x100d46c0
+class LegoState : public MxCore {
+public:
+	virtual ~LegoState() override; // vtable+0x00
+
+	// FUNCTION: LEGO1 0x100060d0
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f01b8
+		return "LegoState";
+	}
+
+	// FUNCTION: LEGO1 0x100060e0
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoState::ClassName()) || MxCore::IsA(p_name);
+	}
+
+	virtual MxBool VTable0x14();                                   // vtable+0x14
+	virtual MxBool SetFlag();                                      // vtable+0x18
+	virtual MxResult VTable0x1c(LegoFileStream* p_legoFileStream); // vtable+0x1C
+};
+
+#endif // LEGOSTATE_H

LEGO1/lego/legoomni/include/legostream.h

@@ -0,0 +1,79 @@
+#ifndef LEGOSTREAM_H
+#define LEGOSTREAM_H
+
+#include "compat.h"
+#include "decomp.h"
+#include "mxstring.h"
+#include "mxtypes.h"
+
+#pragma warning(disable : 4237)
+#include <iosfwd>
+
+#define LEGOSTREAM_MODE_READ 1
+#define LEGOSTREAM_MODE_WRITE 2
+
+class MxVariableTable;
+
+// VTABLE: LEGO1 0x100d7d80
+class LegoStream {
+public:
+	LegoStream() : m_mode(0) {}
+	inline virtual ~LegoStream(){};
+
+	virtual MxResult Read(void* p_buffer, MxU32 p_size) = 0;
+	virtual MxResult Write(const void* p_buffer, MxU32 p_size) = 0;
+	virtual MxResult Tell(MxU32* p_offset) = 0;
+	virtual MxResult Seek(MxU32 p_offset) = 0;
+
+	virtual MxBool IsWriteMode();
+	virtual MxBool IsReadMode();
+
+	enum OpenFlags {
+		ReadBit = 1,
+		WriteBit = 2,
+		BinaryBit = 4,
+	};
+
+	static MxResult __stdcall WriteVariable(LegoStream* p_stream, MxVariableTable* p_from, const char* p_variableName);
+	static MxS32 __stdcall ReadVariable(LegoStream* p_stream, MxVariableTable* p_to);
+
+protected:
+	MxU8 m_mode;
+};
+
+// VTABLE: LEGO1 0x100db730
+class LegoFileStream : public LegoStream {
+public:
+	LegoFileStream();
+	virtual ~LegoFileStream();
+
+	MxResult Read(void* p_buffer, MxU32 p_size) override;
+	MxResult Write(const void* p_buffer, MxU32 p_size) override;
+	MxResult Tell(MxU32* p_offset) override;
+	MxResult Seek(MxU32 p_offset) override;
+
+	MxResult Open(const char* p_filename, OpenFlags p_mode);
+
+	LegoFileStream* FUN_10006030(MxString p_str);
+
+private:
+	FILE* m_hFile;
+};
+
+// VTABLE: LEGO1 0x100db710
+class LegoMemoryStream : public LegoStream {
+public:
+	LegoMemoryStream(char* p_buffer);
+	~LegoMemoryStream() {}
+
+	MxResult Read(void* p_buffer, MxU32 p_size) override;
+	MxResult Write(const void* p_buffer, MxU32 p_size) override;
+	MxResult Tell(MxU32* p_offset) override;
+	MxResult Seek(MxU32 p_offset) override;
+
+private:
+	char* m_buffer;
+	MxU32 m_offset;
+};
+
+#endif // LEGOSTREAM_H

LEGO1/lego/legoomni/include/legotexturepresenter.h

@@ -0,0 +1,30 @@
+#ifndef LEGOTEXTUREPRESENTER_H
+#define LEGOTEXTUREPRESENTER_H
+
+#include "mxmediapresenter.h"
+
+// VTABLE: LEGO1 0x100d4d90
+// SIZE 0x54 (from inlined construction at 0x10009bb5)
+class LegoTexturePresenter : public MxMediaPresenter {
+public:
+	virtual ~LegoTexturePresenter() override;
+
+	// FUNCTION: LEGO1 0x1000ce50
+	inline virtual const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0664
+		return "LegoTexturePresenter";
+	}
+
+	// FUNCTION: LEGO1 0x1000ce60
+	inline virtual MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, LegoTexturePresenter::ClassName()) || MxMediaPresenter::IsA(p_name);
+	}
+
+	virtual void DoneTickle() override;       // vtable+0x2c
+	virtual MxResult AddToManager() override; // vtable+0x34
+	virtual MxResult PutData() override;      // vtable+0x4c
+};
+
+#endif // LEGOTEXTUREPRESENTER_H

LEGO1/lego/legoomni/include/legounknown100d7c88.h

@@ -0,0 +1,19 @@
+#ifndef LEGOUNKNOWN100D7C88_H
+#define LEGOUNKNOWN100D7C88_H
+
+#include "decomp.h"
+#include "mxstring.h"
+
+class LegoUnknown100d7c88 {
+public:
+	~LegoUnknown100d7c88();
+
+	virtual undefined4 VTable0x00(); // vtable+0x00
+									 // More virtual functions
+
+private:
+	MxString m_unk0x04;   // 0x04
+	undefined4 m_unk0x14; // 0x14
+};
+
+#endif // LEGOUNKNOWN100D7C88_H

LEGO1/lego/legoomni/include/legounknown100d9d00.h

@@ -0,0 +1,42 @@
+#ifndef LEGOUNKNOWN100D9D00_H
+#define LEGOUNKNOWN100D9D00_H
+
+#include "decomp.h"
+#include "legounknown100d7c88.h"
+#include "mxlist.h"
+
+// VTABLE: LEGO1 0x100d9cd0
+// class MxCollection<LegoUnknown100d7c88 *>
+
+// VTABLE: LEGO1 0x100d9ce8
+// class MxList<LegoUnknown100d7c88 *>
+
+// VTABLE: LEGO1 0x100d9d00
+// SIZE 0x18
+class LegoUnknown100d9d00 : public MxList<LegoUnknown100d7c88*> {
+public:
+	LegoUnknown100d9d00() { SetDestroy(Destroy); }
+
+	// STUB: LEGO1 0x1007b210
+	virtual MxS8 Compare(LegoUnknown100d7c88* p_a, LegoUnknown100d7c88* p_b) override { return -1; } // vtable+0x14
+
+	// FUNCTION: LEGO1 0x1007b2e0
+	static void Destroy(LegoUnknown100d7c88* p_element) { delete p_element; }
+};
+
+// TEMPLATE: LEGO1 0x1007b300
+// MxCollection<LegoUnknown100d7c88 *>::Compare
+
+// TEMPLATE: LEGO1 0x1007b360
+// MxCollection<LegoUnknown100d7c88 *>::Destroy
+
+// SYNTHETIC: LEGO1 0x1007b400
+// LegoUnknown100d9d00::`scalar deleting destructor'
+
+// SYNTHETIC: LEGO1 0x1007b470
+// MxCollection<LegoUnknown100d7c88 *>::`scalar deleting destructor'
+
+// SYNTHETIC: LEGO1 0x1007b4e0
+// MxList<LegoUnknown100d7c88 *>::`scalar deleting destructor'
+
+#endif // LEGOUNKNOWN100D9D00_H

LEGO1/lego/legoomni/include/legounksavedatawriter.h

@@ -0,0 +1,38 @@
+#ifndef LEGOUNKSAVEDATAWRITER_H
+#define LEGOUNKSAVEDATAWRITER_H
+
+#include "decomp.h"
+#include "mxtypes.h"
+
+class LegoStream;
+
+struct LegoSaveDataEntry3 {
+	char* m_name;
+	void* m_unk0x04;
+	void* m_unk0x08;
+	MxS32 m_savePart1;
+	MxS32 m_savePart2;
+	MxU8 m_savePart3;
+	undefined4 m_unk0x18[6];
+	MxU8 m_frameOffsetInDwords; // 0x30
+	MxS32* m_pFrameData;
+	MxU8 m_currentFrame;
+	undefined4 m_unk0x3c[2];
+	MxU8 m_savePart5; // 0x44
+	undefined4 m_unk0x48[5];
+	MxU8 m_savePart6; // 0x5c
+	undefined4 m_unk0x60[11];
+	MxU8 m_savePart7; // 0x8c
+	undefined4 m_unk0x90[5];
+	MxU8 m_savePart8; // 0xa4
+	undefined4 m_unk0xa8[17];
+	MxU8 m_savePart9; // 0xec
+	undefined4 m_unk0xf0[5];
+	MxU8 m_savePart10; // 0x104
+};
+
+class LegoUnkSaveDataWriter {
+	MxResult WriteSaveData3(LegoStream* p_stream);
+};
+
+#endif // LEGOUNKSAVEDATAWRITER_H

LEGO1/lego/legoomni/include/legoutil.h

@@ -0,0 +1,66 @@
+#ifndef LEGOUTIL_H
+#define LEGOUTIL_H
+
+#include "extra.h"
+#include "legoentity.h"
+#include "mxatomid.h"
+#include "mxtypes.h"
+
+#include <windows.h>
+
+template <class T>
+inline T Abs(T p_t)
+{
+	return p_t < 0 ? -p_t : p_t;
+}
+
+template <class T>
+inline T Min(T p_t1, T p_t2)
+{
+	return p_t1 < p_t2 ? p_t1 : p_t2;
+}
+
+template <class T>
+inline T Max(T p_t1, T p_t2)
+{
+	return p_t1 > p_t2 ? p_t1 : p_t2;
+}
+
+template <class T>
+inline void GetScalar(MxU8** p_source, T& p_dest)
+{
+	p_dest = *(T*) *p_source;
+	*p_source += sizeof(T);
+}
+
+template <class T>
+inline T GetScalar(T** p_source)
+{
+	T val = **p_source;
+	*p_source += 1;
+	return val;
+}
+
+template <class T>
+inline void GetDouble(MxU8** p_source, T& p_dest)
+{
+	p_dest = *(double*) *p_source;
+	*p_source += sizeof(double);
+}
+
+template <class T>
+inline void GetString(MxU8** p_source, char** p_dest, T* p_obj, void (T::*p_setter)(const char*))
+{
+	(p_obj->*p_setter)((char*) *p_source);
+	*p_source += strlen(*p_dest) + 1;
+}
+
+ExtraActionType MatchActionString(const char*);
+void InvokeAction(ExtraActionType p_actionId, MxAtomId& p_pAtom, int p_targetEntityId, LegoEntity* p_sender);
+void ConvertHSVToRGB(float p_h, float p_s, float p_v, float* p_rOut, float* p_bOut, float* p_gOut);
+MxBool FUN_1003ee00(MxAtomId& p_atomId, MxS32 p_id);
+void FUN_1003ef00(MxBool);
+void SetAppCursor(WPARAM p_wparam);
+MxBool FUN_1003ef60();
+
+#endif // LEGOUTIL_H