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

Merge remote-tracking branch 'upstream/master'

Browse Source
This commit is contained in:
Ramen2X 2023-10-05 18:06:38 -04:00
commit 06dcf3e9aa
36 changed files with 1063 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@ -140,6 +140,7 @@ add_library(lego1 SHARED
LEGO1/mxmatrix.cpp
LEGO1/mxmediamanager.cpp
LEGO1/mxmediapresenter.cpp
LEGO1/mxmidimanager.cpp
LEGO1/mxmidipresenter.cpp
LEGO1/mxmusicpresenter.cpp
LEGO1/mxnotificationmanager.cpp
@ -213,7 +214,7 @@ if (ISLE_USE_DX5)
endif()
# Link libraries
target_link_libraries(lego1 PRIVATE ddraw dsound dxguid winmm)
target_link_libraries(lego1 PRIVATE ddraw dsound dxguid dinput winmm)
# Make sure filenames are ALL CAPS
set_property(TARGET lego1 PROPERTY OUTPUT_NAME LEGO1)

190
LEGO1/legoinputmanager.cpp
View File

@ -1,25 +1,175 @@
#include "legoinputmanager.h"
#include "legocontrolmanager.h"
#include "legoomni.h"
#include "decomp.h"
#include "mxautolocker.h"
DECOMP_SIZE_ASSERT(LegoInputManager, 0x338); // 0x10059085
DECOMP_SIZE_ASSERT(LegoInputManager, 0x338);
// OFFSET: LEGO1 0x1005b790 STUB
// OFFSET: LEGO1 0x1005b790
LegoInputManager::LegoInputManager()
{
// TODO
m_unk0x5c = NULL;
m_unk0x64 = 0;
m_unk0x60 = 0;
m_unk0x68 = NULL;
m_unk0x80 = 0;
m_timer = 0;
m_unk0x6c = 0;
m_unk0x70 = 0;
m_controlManager = NULL;
m_unk0x81 = 0;
m_unk0x88 = FALSE;
m_directInput = NULL;
m_directInputDevice = NULL;
m_unk0x94 = 0;
m_unk0x195 = 0;
m_joyid = -1;
m_joystickIndex = -1;
m_useJoystick = FALSE;
m_unk0x335 = FALSE;
m_unk0x336 = FALSE;
m_unk0x74 = 0x19;
m_timeout = 1000;
}
// OFFSET: LEGO1 0x1005b8f0 STUB
// OFFSET: LEGO1 0x1005b8b0 STUB
MxResult LegoInputManager::Tickle()
{
// TODO
return SUCCESS;
}
// OFFSET: LEGO1 0x1005b8f0
LegoInputManager::~LegoInputManager()
{
// TODO
Destroy();
}
// OFFSET: LEGO1 0x1005c740 STUB
void LegoInputManager::QueueEvent(NotificationId id, unsigned char p2, MxLong p3, MxLong p4, unsigned char p5)
// OFFSET: LEGO1 0x1005bfe0
void LegoInputManager::Destroy()
{
// TODO
ReleaseDX();
if (m_unk0x5c)
delete m_unk0x5c;
m_unk0x5c = NULL;
if (m_unk0x68)
delete m_unk0x68;
m_unk0x68 = NULL;
if (m_controlManager)
delete m_controlManager;
}
// OFFSET: LEGO1 0x1005c030
void LegoInputManager::CreateAndAcquireKeyboard(HWND hwnd)
{
HINSTANCE hinstance = (HINSTANCE) GetWindowLong(hwnd, GWL_HINSTANCE);
HRESULT hresult = DirectInputCreate(hinstance, 0x500, &m_directInput, NULL); // 0x500 for DX5
if (hresult == DI_OK) {
HRESULT createdeviceresult = m_directInput->CreateDevice(GUID_SysKeyboard, &m_directInputDevice, NULL);
if (createdeviceresult == DI_OK) {
m_directInputDevice->SetCooperativeLevel(hwnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
m_directInputDevice->SetDataFormat(&c_dfDIKeyboard);
m_directInputDevice->Acquire();
}
}
}
// OFFSET: LEGO1 0x1005c0a0
void LegoInputManager::ReleaseDX()
{
if (m_directInputDevice != NULL) {
m_directInputDevice->Unacquire();
m_directInputDevice->Release();
m_directInputDevice = NULL;
}
if (m_directInput != NULL) {
m_directInput->Release();
m_directInput = NULL;
}
}
// OFFSET: LEGO1 0x1005c240
MxResult LegoInputManager::GetJoystickId()
{
JOYINFOEX joyinfoex;
if (m_useJoystick != FALSE) {
MxS32 joyid = m_joystickIndex;
if (joyid >= 0) {
joyinfoex.dwSize = 0x34;
joyinfoex.dwFlags = 0xFF;
if (joyGetPosEx(joyid, &joyinfoex) == JOYERR_NOERROR && joyGetDevCaps(joyid, &m_joyCaps, 0x194) == JOYERR_NOERROR) {
m_joyid = joyid;
return SUCCESS;
}
}
for (joyid = JOYSTICKID1; joyid < 16; joyid++) {
joyinfoex.dwSize = 0x34;
joyinfoex.dwFlags = 0xFF;
if (joyGetPosEx(joyid, &joyinfoex) == JOYERR_NOERROR && joyGetDevCaps(joyid, &m_joyCaps, 0x194) == JOYERR_NOERROR) {
m_joyid = joyid;
return SUCCESS;
}
}
}
return FAILURE;
}
// OFFSET: LEGO1 0x1005c320
MxResult LegoInputManager::GetJoystickState(MxU32 *joystick_x, MxU32 *joystick_y, DWORD *buttons_state, MxU32 *pov_position)
{
if (m_useJoystick != FALSE) {
if (m_joyid < 0 && GetJoystickId() == -1) {
m_useJoystick = FALSE;
return FAILURE;
}
JOYINFOEX joyinfoex;
joyinfoex.dwSize = 0x34;
joyinfoex.dwFlags = JOY_RETURNX | JOY_RETURNY | JOY_RETURNBUTTONS;
MxU32 capabilities = m_joyCaps.wCaps;
if ((capabilities & JOYCAPS_HASPOV) != 0) {
joyinfoex.dwFlags = JOY_RETURNX | JOY_RETURNY | JOY_RETURNPOV | JOY_RETURNBUTTONS;
if ((capabilities & JOYCAPS_POVCTS) != 0)
joyinfoex.dwFlags = JOY_RETURNX | JOY_RETURNY | JOY_RETURNPOV | JOY_RETURNBUTTONS | JOY_RETURNPOVCTS;
}
MMRESULT mmresult = joyGetPosEx(m_joyid, &joyinfoex);
if (mmresult == MMSYSERR_NOERROR) {
*buttons_state = joyinfoex.dwButtons;
MxU32 xmin = m_joyCaps.wXmin;
MxU32 ymax = m_joyCaps.wYmax;
MxU32 ymin = m_joyCaps.wYmin;
MxS32 ydiff = ymax - ymin;
*joystick_x = ((joyinfoex.dwXpos - xmin) * 100) / (m_joyCaps.wXmax - xmin);
*joystick_y = ((joyinfoex.dwYpos - m_joyCaps.wYmin) * 100) / ydiff;
if ((m_joyCaps.wCaps & (JOYCAPS_POV4DIR | JOYCAPS_POVCTS)) != 0) {
if (joyinfoex.dwPOV == JOY_POVCENTERED) {
*pov_position = (MxU32) -1;
return SUCCESS;
}
*pov_position = joyinfoex.dwPOV / 100;
return SUCCESS;
}
else {
*pov_position = (MxU32) -1;
return SUCCESS;
}
}
}
return FAILURE;
}
// OFFSET: LEGO1 0x1005c470 STUB
@ -34,11 +184,25 @@ void LegoInputManager::UnRegister(MxCore *)
// TODO
}
// OFFSET: LEGO1 0x1005b8b0 STUB
MxResult LegoInputManager::Tickle()
// OFFSET: LEGO1 0x1005c740 STUB
void LegoInputManager::QueueEvent(NotificationId id, unsigned char p2, MxLong p3, MxLong p4, unsigned char p5)
{
// TODO
return 0;
}
// OFFSET: LEGO1 0x1005cfb0
void LegoInputManager::SetTimer()
{
LegoOmni* omni = LegoOmni::GetInstance();
UINT timer = ::SetTimer(omni->GetWindowHandle(), 1, m_timeout, NULL);
m_timer = timer;
}
// OFFSET: LEGO1 0x1005cfd0
void LegoInputManager::KillTimer()
{
if (m_timer != 0) {
LegoOmni* omni = LegoOmni::GetInstance();
::KillTimer(omni->GetWindowHandle(), m_timer);
}
}

53
LEGO1/legoinputmanager.h
View File

@ -3,6 +3,9 @@
#include "decomp.h"
#include "mxpresenter.h"
#include "mxlist.h"
#include <dinput.h>
enum NotificationId
{
@ -14,6 +17,8 @@ enum NotificationId
TIMER = 15
};
class LegoControlManager;
// VTABLE 0x100d8760
// SIZE 0x338
class LegoInputManager : public MxPresenter
@ -28,22 +33,42 @@ class LegoInputManager : public MxPresenter
virtual MxResult Tickle() override; // vtable+0x8
undefined m_pad40[0x48];
void Destroy();
void CreateAndAcquireKeyboard(HWND hwnd);
void ReleaseDX();
MxResult GetJoystickId();
MxResult GetJoystickState(MxU32 *joystick_x, MxU32 *joystick_y, DWORD *buttons_state, MxU32 *pov_position);
void SetTimer();
void KillTimer();
MxBool m_unk88;
undefined m_unk89[0x113];
// 0x19C
int m_joystickIndex;
undefined m_pad1a0[0x194];
// 0x334
//private:
MxCriticalSection m_criticalSection;
MxList<undefined4> *m_unk0x5c; // list or hash table
undefined4 m_unk0x60;
undefined4 m_unk0x64;
MxList<undefined4> *m_unk0x68; // list or hash table
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;
undefined m_unk335;
MxBool m_unk336;
undefined m_unk337;
MxBool m_unk0x335;
MxBool m_unk0x336;
};
#endif // LEGOINPUTMANAGER_H

6
LEGO1/legoomni.cpp
View File

@ -312,3 +312,9 @@ MxBool LegoOmni::vtable40()
// FIXME: Stub
return 0;
}
// OFFSET: LEGO1 0x100157a0
LegoWorld *GetCurrentWorld()
{
return LegoOmni::GetInstance()->GetCurrentWorld();
}

7
LEGO1/legoomni.h
View File

@ -75,12 +75,16 @@ class LegoOmni : public MxOmni
LegoGameState *GetGameState() { return m_gameState; }
LegoNavController *GetNavController() { return m_navController; }
MxTransitionManager *GetTransitionManager() { return m_transitionManager; }
LegoWorld *GetCurrentWorld() { return m_currentWorld; }
private:
int m_unk68;
int m_unk6c;
LegoInputManager *m_inputMgr; // 0x70
char m_unk74[0x10];
undefined4 m_unk74;
undefined4 m_unk78;
LegoWorld *m_currentWorld;
undefined4 m_unk80;
LegoNavController *m_navController; // 0x84
Isle* m_isle; // 0x88
char m_unk8c[0x4];
@ -115,5 +119,6 @@ LegoBuildingManager* BuildingManager();
Isle* GetIsle();
LegoPlantManager* PlantManager();
MxBool KeyValueStringParse(char *, const char *, const char *);
LegoWorld *GetCurrentWorld();
#endif // LEGOOMNI_H

9
LEGO1/motorcycle.cpp
View File

@ -1,7 +1,12 @@
#include "motorcycle.h"
// OFFSET: LEGO1 0x100357b0 STUB
DECOMP_SIZE_ASSERT(Motorcycle, 0x16c);
// OFFSET: LEGO1 0x100357b0
Motorcycle::Motorcycle()
{
// TODO
this->m_unk13c = 40.0;
this->m_unk150 = 1.75;
this->m_unk148 = 1;
this->m_unk164 = 1.0;
}

6
LEGO1/motorcycle.h
View File

@ -1,6 +1,7 @@
#ifndef MOTORCYCLE_H
#define MOTORCYCLE_H
#include "decomp.h"
#include "islepathactor.h"
// VTABLE 0x100d7090
@ -22,7 +23,10 @@ class Motorcycle : public IslePathActor
{
return !strcmp(name, Motorcycle::ClassName()) || IslePathActor::IsA(name);
}
private:
undefined m_unk160[4];
MxFloat m_unk164;
undefined m_unk168[4];
};
#endif // MOTORCYCLE_H

16
LEGO1/mxaudiomanager.cpp
View File

@ -20,7 +20,21 @@ MxAudioManager::~MxAudioManager()
// OFFSET: LEGO1 0x100b8df0
void MxAudioManager::Init()
{
this->m_unk2c = 100;
this->m_volume = 100;
}
// OFFSET: LEGO1 0x10029910
MxS32 MxAudioManager::GetVolume()
{
return this->m_volume;
}
// OFFSET: LEGO1 0x100b8ea0
void MxAudioManager::SetVolume(MxS32 p_volume)
{
this->m_criticalSection.Enter();
this->m_volume = p_volume;
this->m_criticalSection.Leave();
}
// OFFSET: LEGO1 0x100b8e00

10
LEGO1/mxaudiomanager.h
View File

@ -11,18 +11,20 @@ class MxAudioManager : public MxMediaManager
MxAudioManager();
virtual ~MxAudioManager() override;
virtual MxResult InitPresenters(); // vtable+14
virtual void Destroy(); // vtable+18
virtual MxResult InitPresenters() override; // vtable+14
virtual void Destroy() override; // vtable+18
virtual MxS32 GetVolume(); // vtable+28
virtual void SetVolume(MxS32 p_volume); // vtable+2c
private:
void LockedReinitialize(MxBool);
void LockedReinitialize(MxBool p_skipDestroy);
static MxS32 g_unkCount;
protected:
void Init();
undefined4 m_unk2c;
MxS32 m_volume; // 0x2c
};
#endif // MXAUDIOMANAGER_H

4
LEGO1/mxdisplaysurface.cpp
View File

@ -174,7 +174,7 @@ void MxDisplaySurface::SetPalette(MxPalette *p_palette)
}
// OFFSET: LEGO1 0x100bc200 STUB
void MxDisplaySurface::vtable24(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4)
void MxDisplaySurface::vtable24(LPDDSURFACEDESC, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4)
{
}
@ -186,7 +186,7 @@ MxBool MxDisplaySurface::vtable28(undefined4, undefined4, undefined4, undefined4
}
// OFFSET: LEGO1 0x100bc630 STUB
MxBool MxDisplaySurface::vtable2c(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, MxBool)
MxBool MxDisplaySurface::vtable2c(LPDDSURFACEDESC, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, MxBool)
{
return 0;
}

5
LEGO1/mxdisplaysurface.h
View File

@ -25,9 +25,9 @@ class MxDisplaySurface : public MxCore
virtual MxResult Create(MxVideoParam &p_videoParam);
virtual void Clear();
virtual void SetPalette(MxPalette *p_palette);
virtual void vtable24(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4);
virtual void vtable24(LPDDSURFACEDESC, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4);
virtual MxBool vtable28(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4);
virtual MxBool vtable2c(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, MxBool);
virtual MxBool vtable2c(LPDDSURFACEDESC, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, MxBool);
virtual MxBool vtable30(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, MxBool);
virtual undefined4 vtable34(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4);
virtual void Display(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4);
@ -35,6 +35,7 @@ class MxDisplaySurface : public MxCore
virtual void ReleaseDC(HDC p_hdc);
virtual undefined4 vtable44(undefined4, undefined4*, undefined4, undefined4);
inline LPDIRECTDRAWSURFACE GetDirectDrawSurface1() { return this->m_ddSurface1; }
inline LPDIRECTDRAWSURFACE GetDirectDrawSurface2() { return this->m_ddSurface2; }
private:

12
LEGO1/mxdsaction.h
View File

@ -16,8 +16,10 @@ class MxDSAction : public MxDSObject
{
Flag_Looping = 0x01,
Flag_Bit3 = 0x04,
Flag_Bit5 = 0x10,
Flag_Enabled = 0x20,
Flag_Parsed = 0x80,
Flag_Bit9 = 0x200,
};
__declspec(dllexport) MxDSAction();
@ -52,16 +54,18 @@ class MxDSAction : public MxDSObject
void AppendData(MxU16 p_extraLength, const char *p_extraData);
inline MxU32 GetFlags() { return this->m_flags; }
inline void SetFlags(MxU32 m_flags) { this->m_flags = m_flags; }
inline MxU32 GetFlags() { return m_flags; }
inline void SetFlags(MxU32 p_flags) { m_flags = p_flags; }
inline char *GetExtraData() { return m_extraData; }
inline MxU16 GetExtraLength() const { return m_extraLength; }
inline MxLong GetStartTime() const { return m_startTime; }
inline MxS32 GetLoopCount() { return m_loopCount; }
inline void SetLoopCount(MxS32 p_loopCount) { m_loopCount = p_loopCount; }
inline const MxVector3Data &GetLocation() const { return m_location; }
inline void SetOmni(MxOmni *p_omni) { m_omni = p_omni; }
inline MxBool IsLooping() const { return this->m_flags & Flag_Looping; }
inline MxBool IsBit3() const { return this->m_flags & Flag_Bit3; }
inline MxBool IsLooping() const { return m_flags & Flag_Looping; }
inline MxBool IsBit3() const { return m_flags & Flag_Bit3; }
private:
MxU32 m_sizeOnDisk;

14
LEGO1/mxdsactionlist.h
View File

@ -8,7 +8,7 @@ class MxDSAction;
// VTABLE 0x100dced8
// SIZE 0x1c
class MxDSActionList : public MxList<MxDSAction>
class MxDSActionList : public MxList<MxDSAction*>
{
public:
MxDSActionList() {
@ -23,15 +23,15 @@ class MxDSActionList : public MxList<MxDSAction>
undefined m_unk18;
};
typedef MxListCursorChild<MxDSAction> MxDSActionListCursor;
typedef MxListCursorChild<MxDSAction*> MxDSActionListCursor;
// OFFSET: LEGO1 0x100c9cc0 TEMPLATE
// MxListParent<MxDSAction *>::Compare
// OFFSET: LEGO1 0x100c9d20 TEMPLATE
// MxListParent<MxDSAction>::Destroy
// OFFSET: LEGO1 0x100c9cd0 TEMPLATE
// MxListParent<MxDSAction>::~MxListParent<MxDSAction>
// MxListParent<MxDSAction *>::Destroy
// OFFSET: LEGO1 0x100c9d30 TEMPLATE
// MxList<MxDSAction>::~MxList<MxDSAction>
// MxList<MxDSAction *>::~MxList<MxDSAction *>
#endif // MXDSACTIONLIST_H

7
LEGO1/mxdsselectaction.cpp
View File

@ -5,12 +5,13 @@ DECOMP_SIZE_ASSERT(MxDSSelectAction, 0xb0)
// OFFSET: LEGO1 0x100cb2b0
MxDSSelectAction::MxDSSelectAction()
{
// TODO
this->SetType(MxDSType_SelectAction);
this->m_unk0xac = new MxStringList;
}
// OFFSET: LEGO1 0x100cb8d0 STUB
// OFFSET: LEGO1 0x100cb8d0
MxDSSelectAction::~MxDSSelectAction()
{
// TODO
if (this->m_unk0xac)
delete this->m_unk0xac;
}

10
LEGO1/mxdsselectaction.h
View File

@ -2,6 +2,7 @@
#define MXDSSELECTACTION_H
#include "mxdsparallelaction.h"
#include "mxstringlist.h"
#include "decomp.h"
// VTABLE 0x100dcfc8
@ -25,12 +26,9 @@ class MxDSSelectAction : public MxDSParallelAction
return !strcmp(name, MxDSSelectAction::ClassName()) || MxDSParallelAction::IsA(name);
}
undefined4 m_unk0x9c;
undefined4 m_unk0xa0;
undefined4 m_unk0xa4;
undefined4 m_unk0xa8;
undefined4 m_unk0xac;
private:
MxString m_unk0x9c;
MxStringList *m_unk0xac;
};
#endif // MXDSSELECTACTION_H

38
LEGO1/mxlist.h
View File

@ -4,19 +4,24 @@
#include "mxtypes.h"
#include "mxcore.h"
template <class T>
// SIZE 0xc
template <class T>
class MxListEntry
{
public:
MxListEntry() {}
MxListEntry(T *p_obj, MxListEntry *p_prev) {
MxListEntry(T p_obj, MxListEntry *p_prev) {
m_obj = p_obj;
m_prev = p_prev;
m_next = NULL;
}
T *m_obj;
T GetValue() { return this->m_obj; }
friend class MxList<T>;
friend class MxListCursor<T>;
private:
T m_obj;
MxListEntry *m_prev;
MxListEntry *m_next;
};
@ -33,12 +38,12 @@ class MxListParent : public MxCore
}
virtual ~MxListParent() {}
virtual MxS8 Compare(T *, T *) = 0;
virtual MxS8 Compare(T, T) { return 0; };
static void Destroy(T *) {};
static void Destroy(T) {};
protected:
MxU32 m_count; // +0x8
void (*m_customDestructor)(T *); // +0xc
void (*m_customDestructor)(T); // +0xc
};
// VTABLE 0x100d6368
@ -54,13 +59,12 @@ class MxList : protected MxListParent<T>
virtual ~MxList();
void Append(T*);
void Append(T);
void DeleteAll();
MxU32 GetCount() { return m_count; }
void SetDestroy(void (*p_customDestructor)(T *)) { this->m_customDestructor = p_customDestructor; }
void SetDestroy(void (*p_customDestructor)(T)) { this->m_customDestructor = p_customDestructor; }
friend class MxListCursor<T>;
protected:
MxListEntry<T> *m_first; // +0x10
MxListEntry<T> *m_last; // +0x14
@ -79,10 +83,10 @@ class MxListCursor : public MxCore
m_match = NULL;
}
MxBool Find(T *p_obj);
MxBool Find(T p_obj);
void Detach();
MxBool Next(T*& p_obj);
void SetValue(T *p_obj);
MxBool Next(T& p_obj);
void SetValue(T p_obj);
void Head() { m_match = m_list->m_first; }
void Reset() { m_match = NULL; }
@ -123,7 +127,7 @@ inline void MxList<T>::DeleteAll()
break;
MxListEntry<T> *next = t->m_next;
m_customDestructor(t->m_obj);
m_customDestructor(t->GetValue());
delete t;
t = next;
}
@ -134,7 +138,7 @@ inline void MxList<T>::DeleteAll()
}
template <class T>
inline void MxList<T>::Append(T *p_newobj)
inline void MxList<T>::Append(T p_newobj)
{
MxListEntry<T> *currentLast = this->m_last;
MxListEntry<T> *newEntry = new MxListEntry<T>(p_newobj, currentLast);
@ -169,7 +173,7 @@ inline void MxList<T>::_DeleteEntry(MxListEntry<T> *match)
}
template <class T>
inline MxBool MxListCursor<T>::Find(T *p_obj)
inline MxBool MxListCursor<T>::Find(T p_obj)
{
for (m_match = m_list->m_first;
m_match && m_list->Compare(m_match->m_obj, p_obj);
@ -186,7 +190,7 @@ inline void MxListCursor<T>::Detach()
}
template <class T>
inline MxBool MxListCursor<T>::Next(T*& p_obj)
inline MxBool MxListCursor<T>::Next(T& p_obj)
{
if (!m_match)
m_match = m_list->m_first;
@ -200,7 +204,7 @@ inline MxBool MxListCursor<T>::Next(T*& p_obj)
}
template <class T>
inline void MxListCursor<T>::SetValue(T *p_obj)
inline void MxListCursor<T>::SetValue(T p_obj)
{
if (m_match)
m_match->m_obj = p_obj;

18
LEGO1/mxloopingflcpresenter.cpp
View File

@ -4,20 +4,28 @@
DECOMP_SIZE_ASSERT(MxLoopingFlcPresenter, 0x6c);
// OFFSET: LEGO1 0x100b4310 STUB
// OFFSET: LEGO1 0x100b4310
MxLoopingFlcPresenter::MxLoopingFlcPresenter()
{
// TODO
Init();
}
// OFFSET: LEGO1 0x100b43b0 STUB
MxLoopingFlcPresenter::~MxLoopingFlcPresenter()
{
// TODO
Destroy(TRUE);
}
// OFFSET: LEGO1 0x100b4410 STUB
// OFFSET: LEGO1 0x100b4410
void MxLoopingFlcPresenter::Init()
{
// TODO
this->m_unk68 = 0;
this->m_flags &= 0xfd;
this->m_flags &= 0xfb;
}
// OFFSET: LEGO1 0x100b4432 STUB
void MxLoopingFlcPresenter::Destroy(MxBool p_param)
{
// TODO
}

2
LEGO1/mxloopingflcpresenter.h
View File

@ -22,6 +22,8 @@ class MxLoopingFlcPresenter : public MxFlcPresenter
private:
void Init();
void Destroy(MxBool);
undefined4 m_unk68;
};

16
LEGO1/mxloopingsmkpresenter.cpp
View File

@ -10,14 +10,22 @@ MxLoopingSmkPresenter::MxLoopingSmkPresenter()
Init();
}
// OFFSET: LEGO1 0x100b4950 STUB
// OFFSET: LEGO1 0x100b4950
MxLoopingSmkPresenter::~MxLoopingSmkPresenter()
{
// TODO
Destroy(TRUE);
}
// OFFSET: LEGO1 0x100b49b0 STUB
// OFFSET: LEGO1 0x100b49b0
void MxLoopingSmkPresenter::Init()
{
// TODO
this->m_unk720 = 0;
this->m_flags &= 0xfd;
this->m_flags &= 0xfb;
}
// OFFSET: LEGO1 0x100b49d0 STUB
void MxLoopingSmkPresenter::Destroy(MxBool p_bool)
{
// TODO - theres a chain of destroy and free function calls here (FUN_100b4300 -> FUN_100b3900 -> FUN_100c5d40 -> function at 0x100b27b0)
}

2
LEGO1/mxloopingsmkpresenter.h
View File

@ -22,6 +22,8 @@ class MxLoopingSmkPresenter : public MxSmkPresenter
private:
void Init();
void Destroy(MxBool);
undefined4 m_unk720;
};

6
LEGO1/mxmediapresenter.cpp
View File

@ -17,3 +17,9 @@ void MxMediaPresenter::Init()
this->m_unk48 = NULL;
this->m_unk4c = NULL;
}
// OFFSET: LEGO1 0x100b5f10 STUB
void MxMediaPresenter::VTable0x58()
{
// TODO
}

2
LEGO1/mxmediapresenter.h
View File

@ -29,6 +29,8 @@ class MxMediaPresenter : public MxPresenter
return !strcmp(name, MxMediaPresenter::ClassName()) || MxPresenter::IsA(name);
}
virtual void VTable0x58(); // vtable+0x58
undefined4 m_unk40;
undefined4 m_unk44;
undefined4 m_unk48;

161
LEGO1/mxmidimanager.cpp Normal file
View File

@ -0,0 +1,161 @@
#include "mxmidimanager.h"
#include "mxomni.h"
#include <windows.h>
DECOMP_SIZE_ASSERT(MxMIDIManager, 0x58);
// OFFSET: LEGO1 0x100c05a0
MxMIDIManager::MxMIDIManager()
{
Init();
}
// OFFSET: LEGO1 0x100c0630
MxMIDIManager::~MxMIDIManager()
{
LockedReinitialize(TRUE);
}
// OFFSET: LEGO1 0x100c0b20
void MxMIDIManager::DeinitializeMIDI()
{
m_criticalSection.Enter();
if (this->m_MIDIInitialized)
{
this->m_MIDIInitialized = FALSE;
midiStreamStop(this->m_MIDIStreamH);
midiOutUnprepareHeader(this->m_MIDIStreamH, this->m_MIDIHdrP, sizeof(MIDIHDR));
midiOutSetVolume(this->m_MIDIStreamH, this->m_MIDIVolume);
midiStreamClose(this->m_MIDIStreamH);
delete this->m_MIDIHdrP;
this->InitData();
}
this->m_criticalSection.Leave();
}
// OFFSET: LEGO1 0x100c0690
void MxMIDIManager::Init()
{
this->m_multiplier = 100;
InitData();
}
// OFFSET: LEGO1 0x100c06a0
void MxMIDIManager::InitData()
{
this->m_MIDIStreamH = 0;
this->m_MIDIInitialized = FALSE;
this->m_unk38 = 0;
this->m_unk3c = 0;
this->m_unk40 = 0;
this->m_unk44 = 0;
this->m_unk48 = 0;
this->m_MIDIHdrP = NULL;
}
// OFFSET: LEGO1 0x100c06c0
void MxMIDIManager::LockedReinitialize(MxBool p_skipDestroy)
{
if (this->m_thread)
{
this->m_thread->Terminate();
if (this->m_thread)
{
delete m_thread;
}
}
else
{
TickleManager()->UnregisterClient(this);
}
this->m_criticalSection.Enter();
DeinitializeMIDI();
Init();
this->m_criticalSection.Leave();
if (!p_skipDestroy)
{
MxAudioManager::Destroy();
}
}
// OFFSET: LEGO1 0x100c0930
void MxMIDIManager::Destroy()
{
LockedReinitialize(FALSE);
}
// OFFSET: LEGO1 0x100c09a0
MxS32 MxMIDIManager::CalculateVolume(MxS32 p_volume)
{
MxS32 result = (p_volume * 0xffff) / 100;
return (result << 0x10) | result;
}
// OFFSET: LEGO1 0x100c07f0
void MxMIDIManager::SetMIDIVolume()
{
MxS32 result = (this->m_volume * this->m_multiplier) / 0x64;
HMIDISTRM streamHandle = this->m_MIDIStreamH;
if (streamHandle)
{
MxS32 volume = CalculateVolume(result);
midiOutSetVolume(streamHandle, volume);
}
}
// OFFSET: LEGO1 0x100c0940
void MxMIDIManager::SetVolume(MxS32 p_volume)
{
MxAudioManager::SetVolume(p_volume);
this->m_criticalSection.Enter();
SetMIDIVolume();
this->m_criticalSection.Leave();
}
// OFFSET: LEGO1 0x100c0840
MxResult MxMIDIManager::StartMIDIThread(MxU32 p_frequencyMS, MxBool p_noRegister)
{
MxResult status = FAILURE;
MxBool locked = FALSE;
MxResult result = MxAudioManager::InitPresenters();
if (result == SUCCESS)
{
if (p_noRegister)
{
this->m_criticalSection.Enter();
locked = TRUE;
this->m_thread = new MxTickleThread(this, p_frequencyMS);
if (this->m_thread)
{
if (this->m_thread->Start(0, 0) == SUCCESS)
{
status = SUCCESS;
}
}
}
else
{
TickleManager()->RegisterClient(this, p_frequencyMS);
status = SUCCESS;
}
}
if (status != SUCCESS)
{
Destroy();
}
if (locked)
{
this->m_criticalSection.Leave();
}
return status;
}

42
LEGO1/mxmidimanager.h Normal file
View File

@ -0,0 +1,42 @@
#ifndef MXMIDIMANAGER_H
#define MXMIDIMANAGER_H
#include "decomp.h"
#include "mxaudiomanager.h"
// VTABLE 0x100dc930
// SIZE 0x58
class MxMIDIManager : public MxAudioManager
{
public:
MxMIDIManager();
virtual ~MxMIDIManager() override;
virtual void Destroy() override; // vtable+18
virtual void SetVolume(MxS32 p_volume) override; // vtable+2c
virtual MxResult StartMIDIThread(MxU32 p_frequencyMS, MxU8 p_noRegister); // vtable+30
private:
void LockedReinitialize(MxBool p_skipDestroy);
void DeinitializeMIDI();
MxS32 CalculateVolume(MxS32 p_volume);
void SetMIDIVolume();
HMIDISTRM m_MIDIStreamH; // 0x30
MxBool m_MIDIInitialized; // 0x34
undefined4 m_unk38; // 0x38
undefined4 m_unk3c; // 0x3c
undefined4 m_unk40; // 0x40
undefined4 m_unk44; // 0x44
undefined4 m_unk48; // 0x48
MIDIHDR *m_MIDIHdrP; // 0x4c
MxS32 m_multiplier; // 0x50
DWORD m_MIDIVolume; // 0x54
protected:
void Init();
void InitData();
};
#endif // MXMIDIMANAGER_H

3
LEGO1/mxpresenter.h
View File

@ -68,7 +68,10 @@ class MxPresenter : public MxCore
MxBool IsEnabled();
inline MxS32 GetCurrentTickleState() { return this->m_currentTickleState; }
inline MxPoint32 GetLocation() { return this->m_location; }
inline MxS32 GetDisplayZ() { return this->m_displayZ; }
inline MxDSAction *GetAction() { return this->m_action; }
protected:
__declspec(dllexport) void Init();

14
LEGO1/mxpresenterlist.h
View File

@ -8,7 +8,7 @@ class MxPresenter;
// Unclear what the purpose of this class is
// VTABLE 0x100d62f0
// SIZE 0x18
class MxPresenterListParent : public MxList<MxPresenter>
class MxPresenterListParent : public MxList<MxPresenter*>
{
public:
MxPresenterListParent() {
@ -24,15 +24,15 @@ class MxPresenterList : public MxPresenterListParent
virtual MxS8 Compare(MxPresenter *, MxPresenter *); // +0x14
};
typedef MxListCursorChildChild<MxPresenter> MxPresenterListCursor;
typedef MxListCursorChildChild<MxPresenter*> MxPresenterListCursor;
// OFFSET: LEGO1 0x1001cd20 TEMPLATE
// MxListParent<MxPresenter *>::Compare
// OFFSET: LEGO1 0x1001cd30 TEMPLATE
// MxListParent<MxPresenter>::Destroy
// OFFSET: LEGO1 0x1001cdd0 TEMPLATE
// MxListParent<MxPresenter>::~MxListParent<MxPresenter>
// MxListParent<MxPresenter *>::Destroy
// OFFSET: LEGO1 0x1001ce20 TEMPLATE
// MxList<MxPresenter>::~MxList<MxPresenter>
// MxList<MxPresenter *>::~MxList<MxPresenter *>
#endif // MXPRESENTERLIST_H

34
LEGO1/mxsoundmanager.cpp
View File

@ -1,21 +1,49 @@
#include "mxsoundmanager.h"
#include "mxomni.h"
DECOMP_SIZE_ASSERT(MxSoundManager, 0x3c);
// OFFSET: LEGO1 0x100ae740
MxSoundManager::MxSoundManager()
{
Init();
}
// OFFSET: LEGO1 0x100ae7d0 STUB
// OFFSET: LEGO1 0x100ae7d0
MxSoundManager::~MxSoundManager()
{
// TODO
Destroy(TRUE);
}
// OFFSET: LEGO1 0x100ae830
void MxSoundManager::Init()
{
m_unk30 = 0;
m_unk34 = 0;
m_dsBuffer = NULL;
}
// OFFSET: LEGO1 0x100ae840
void MxSoundManager::Destroy(MxBool p_param)
{
if (this->m_thread) {
this->m_thread->Terminate();
delete this->m_thread;
}
else {
TickleManager()->UnregisterClient(this);
}
this->m_criticalSection.Enter();
if (this->m_dsBuffer) {
this->m_dsBuffer->Release();
}
Init();
this->m_criticalSection.Leave();
if (!p_param) {
MxAudioManager::Destroy();
}
}

11
LEGO1/mxsoundmanager.h
View File

@ -1,11 +1,13 @@
#ifndef MXSOUNDMANAGER_H
#define MXSOUNDMANAGER_H
#include "decomp.h"
#include "mxaudiomanager.h"
#include <dsound.h>
// VTABLE 0x100dc128
// SIZE 0x3c
// Base vtables are: MxCore -> 0x100dc6b0 -> MxAudioManager -> MxSoundManager
class MxSoundManager : public MxAudioManager
{
public:
@ -14,8 +16,11 @@ class MxSoundManager : public MxAudioManager
private:
void Init();
int m_unk30;
int m_unk34;
void Destroy(MxBool);
undefined4 m_unk30;
LPDIRECTSOUNDBUFFER m_dsBuffer; // 0x34
undefined m_unk35[4];
};
#endif // MXSOUNDMANAGER_H

23
LEGO1/mxstringlist.h Normal file
View File

@ -0,0 +1,23 @@
#ifndef MXSTRINGLIST_H
#define MXSTRINGLIST_H
#include "mxlist.h"
#include "mxstring.h"
// VTABLE 0x100dd040
// SIZE 0x18
class MxStringList : public MxList<MxString> {};
// OFFSET: LEGO1 0x100cb3c0 TEMPLATE
// MxListParent<MxString>::Compare
// OFFSET: LEGO1 0x100cb470 TEMPLATE
// MxListParent<MxString>::Destroy
// OFFSET: LEGO1 0x100cb4c0 TEMPLATE
// MxList<MxString>::~MxList<MxString>
// OFFSET: LEGO1 0x100cc450 TEMPLATE
// MxListEntry<MxString>::GetValue
#endif // MXSTRINGLIST_H

2
LEGO1/mxthread.h
View File

@ -24,6 +24,8 @@ class MxThread
protected:
MxThread();
public:
virtual ~MxThread();
private:

339
LEGO1/mxtransitionmanager.cpp
View File

@ -4,16 +4,33 @@
DECOMP_SIZE_ASSERT(MxTransitionManager, 0x900);
// OFFSET: LEGO1 0x1004b8d0 STUB
// 0x100f4378
RECT g_fullScreenRect = {0, 0, 640, 480};
// OFFSET: LEGO1 0x1004b8d0
MxTransitionManager::MxTransitionManager()
{
// TODO
m_animationTimer = 0;
m_transitionType = NOT_TRANSITIONING;
m_ddSurface = NULL;
m_waitIndicator = NULL;
m_copyBuffer = NULL;
m_copyFlags.bit0 = FALSE;
m_unk28.bit0 = FALSE;
m_unk24 = 0;
}
// OFFSET: LEGO1 0x1004ba00 STUB
// OFFSET: LEGO1 0x1004ba00
MxTransitionManager::~MxTransitionManager()
{
// TODO
free(m_copyBuffer);
if (m_waitIndicator != NULL) {
delete m_waitIndicator->GetAction();
delete m_waitIndicator;
}
TickleManager()->UnregisterClient(this);
}
// OFFSET: LEGO1 0x1004bac0
@ -48,10 +65,104 @@ MxResult MxTransitionManager::Tickle()
return SUCCESS;
}
// OFFSET: LEGO1 0x1004c470 STUB
void MxTransitionManager::SetWaitIndicator(MxVideoPresenter *videoPresenter)
// OFFSET: LEGO1 0x1004bc30
void MxTransitionManager::EndTransition(MxBool p_notifyWorld)
{
// TODO
if (m_transitionType != NOT_TRANSITIONING) {
m_transitionType = NOT_TRANSITIONING;
m_copyFlags.bit0 = FALSE;
TickleManager()->UnregisterClient(this);
if (p_notifyWorld) {
LegoWorld *world = GetCurrentWorld();
if (world) {
world->Notify(MxParam(0x18, this));
}
}
}
}
// OFFSET: LEGO1 0x1004bd10
void MxTransitionManager::Transition_Dissolve()
{
// If the animation is finished
if (m_animationTimer == 40) {
m_animationTimer = 0;
EndTransition(TRUE);
return;
}
// If we are starting the animation
if (m_animationTimer == 0) {
// Generate the list of columns in order...
for (MxS32 i = 0; i < 640; i++) {
m_columnOrder[i] = i;
}
// ...then shuffle the list (to ensure that we hit each column once)
for (i = 0; i < 640; i++) {
MxS32 swap = rand() % 640;
MxU16 t = m_columnOrder[i];
m_columnOrder[i] = m_columnOrder[swap];
m_columnOrder[swap] = t;
}
// For each scanline, pick a random X offset
for (i = 0; i < 480; i++) {
m_randomShift[i] = rand() % 640;
}
}
// Run one tick of the animation
DDSURFACEDESC ddsd;
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
HRESULT res = m_ddSurface->Lock(NULL, &ddsd, 1, NULL);
if (res == DDERR_SURFACELOST) {
m_ddSurface->Restore();
res = m_ddSurface->Lock(NULL, &ddsd, 1, NULL);
}
if (res == DD_OK) {
SubmitCopyRect(&ddsd);
for (MxS32 i = 0; i < 640; i++) {
// Select 16 columns on each tick
if (m_animationTimer * 16 > m_columnOrder[i])
continue;
if (m_animationTimer * 16 + 15 < m_columnOrder[i])
continue;
for (MxS32 j = 0; j < 480; j++) {
// Shift the chosen column a different amount at each scanline.
// We use the same shift for that scanline each time.
// By the end, every pixel gets hit.
MxS32 ofs = (m_randomShift[j] + i) % 640;
// Set the chosen pixel to black
if (ddsd.ddpfPixelFormat.dwRGBBitCount == 8) {
((MxU8*)ddsd.lpSurface)[j * ddsd.lPitch + ofs] = 0;
} else {
((MxU16*)ddsd.lpSurface)[j * ddsd.lPitch + ofs] = 0;
}
}
}
SetupCopyRect(&ddsd);
m_ddSurface->Unlock(ddsd.lpSurface);
if (VideoManager()->GetVideoParam().flags().GetFlipSurfaces()) {
LPDIRECTDRAWSURFACE surf = VideoManager()->GetDisplaySurface()->GetDirectDrawSurface1();
surf->BltFast(NULL, NULL, m_ddSurface, &g_fullScreenRect, 0x10);
}
m_animationTimer++;
}
}
// OFFSET: LEGO1 0x1004baa0
@ -64,46 +175,47 @@ MxResult MxTransitionManager::GetDDrawSurfaceFromVideoManager() // vtable+0x14
// OFFSET: LEGO1 0x1004bb70
MxResult MxTransitionManager::StartTransition(TransitionType p_animationType, MxS32 p_speed,
undefined p_unk, MxBool p_playMusicInAnim)
MxBool p_doCopy, MxBool p_playMusicInAnim)
{
// TODO: Incomplete and far from matching
if (this->m_transitionType == NOT_TRANSITIONING) {
if (!p_playMusicInAnim) {
MxBackgroundAudioManager *backgroundAudioManager = BackgroundAudioManager();
backgroundAudioManager->Stop();
}
this->m_transitionType = p_animationType;
// TODO: This part of the function is mangled and I can't make out what it's doing right now
this->m_transitionType = p_animationType;
MxULong time = timeGetTime();
this->m_systemTime = time;
m_copyFlags.bit0 = p_doCopy;
this->m_animationSpeed = p_speed;
if (m_copyFlags.bit0 && m_waitIndicator != NULL) {
m_waitIndicator->Enable(TRUE);
MxTickleManager *tickleManager = TickleManager();
tickleManager->RegisterClient(this, p_speed);
MxDSAction *action = m_waitIndicator->GetAction();
action->SetLoopCount(10000);
action->SetFlags(action->GetFlags() | MxDSAction::Flag_Bit9);
}
LegoInputManager *inputManager = InputManager();
inputManager->m_unk88 = TRUE;
inputManager->m_unk336 = FALSE;
MxU32 time = timeGetTime();
this->m_systemTime = time;
LegoVideoManager *videoManager = VideoManager();
videoManager->SetUnkE4(FALSE);
this->m_animationSpeed = p_speed;
SetAppCursor(1);
return SUCCESS;
MxTickleManager *tickleManager = TickleManager();
tickleManager->RegisterClient(this, p_speed);
LegoInputManager *inputManager = InputManager();
inputManager->m_unk0x88 = TRUE;
inputManager->m_unk0x336 = FALSE;
LegoVideoManager *videoManager = VideoManager();
videoManager->SetUnkE4(FALSE);
SetAppCursor(1);
return SUCCESS;
}
return FAILURE;
}
// OFFSET: LEGO1 0x1004bc30 STUB
void MxTransitionManager::EndTransition(MxBool p_unk)
{
// TODO
}
// OFFSET: LEGO1 0x1004bcf0
void MxTransitionManager::FUN_1004bcf0()
{
@ -112,23 +224,12 @@ void MxTransitionManager::FUN_1004bcf0()
EndTransition(TRUE);
}
// OFFSET: LEGO1 0x1004bd10 STUB
void MxTransitionManager::FUN_1004bd10()
{
// TODO
}
// OFFSET: LEGO1 0x1004bed0 STUB
void MxTransitionManager::FUN_1004bed0()
{
// TODO
}
// OFFSET: LEGO1 0x1004c170 STUB
void MxTransitionManager::FUN_1004c170()
{
// TODO
}
// OFFSET: LEGO1 0x1004c270 STUB
void MxTransitionManager::FUN_1004c270()
@ -141,3 +242,159 @@ void MxTransitionManager::FUN_1004c3e0()
{
// TODO
}
// OFFSET: LEGO1 0x1004c170
void MxTransitionManager::Transition_Wipe()
{
// If the animation is finished
if (m_animationTimer == 240) {
m_animationTimer = 0;
EndTransition(TRUE);
return;
}
DDSURFACEDESC ddsd;
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
HRESULT res = m_ddSurface->Lock(NULL, &ddsd, 1, NULL);
if (res == DDERR_SURFACELOST) {
m_ddSurface->Restore();
res = m_ddSurface->Lock(NULL, &ddsd, 1, NULL);
}
if (res == DD_OK) {
SubmitCopyRect(&ddsd);
// For each of the 240 animation ticks, blank out two scanlines
// starting at the top of the screen.
// (dwRGBBitCount / 8) will tell how many bytes are used per pixel.
MxU8 *line = (MxU8*)ddsd.lpSurface + 2*ddsd.lPitch*m_animationTimer;
memset(line, 0, 640 * ddsd.ddpfPixelFormat.dwRGBBitCount / 8);
line += ddsd.lPitch;
memset(line, 0, 640 * ddsd.ddpfPixelFormat.dwRGBBitCount / 8);
SetupCopyRect(&ddsd);
m_ddSurface->Unlock(ddsd.lpSurface);
m_animationTimer++;
}
}
// OFFSET: LEGO1 0x1004c470
void MxTransitionManager::SetWaitIndicator(MxVideoPresenter *p_waitIndicator)
{
// End current wait indicator
if (m_waitIndicator != NULL) {
m_waitIndicator->GetAction()->SetFlags(m_waitIndicator->GetAction()->GetFlags() & ~MxDSAction::Flag_Parsed);
m_waitIndicator->EndAction();
m_waitIndicator = NULL;
}
// Check if we were given a new wait indicator
if (p_waitIndicator != NULL) {
// Setup the new wait indicator
m_waitIndicator = p_waitIndicator;
LegoVideoManager *videoManager = VideoManager();
videoManager->RemovePresenter(*m_waitIndicator);
if (m_waitIndicator->GetCurrentTickleState() < MxPresenter::TickleState_Streaming) {
m_waitIndicator->Tickle();
}
} else {
// Disable copy rect
m_copyFlags.bit0 = FALSE;
}
}
// OFFSET: LEGO1 0x1004c4d0
void MxTransitionManager::SubmitCopyRect(LPDDSURFACEDESC ddsc)
{
// Check if the copy rect is setup
if (m_copyFlags.bit0 == FALSE || m_waitIndicator == NULL || m_copyBuffer == NULL) {
return;
}
// Copy the copy rect onto the surface
char *dst;
DWORD bytesPerPixel = ddsc->ddpfPixelFormat.dwRGBBitCount / 8;
const char *src = (const char *)m_copyBuffer;
LONG copyPitch;
copyPitch = ((m_copyRect.right - m_copyRect.left) + 1) * bytesPerPixel;
LONG y;
dst = (char *)ddsc->lpSurface + (ddsc->lPitch * m_copyRect.top) + (bytesPerPixel * m_copyRect.left);
for (y = 0; y < m_copyRect.bottom - m_copyRect.top + 1; ++y) {
memcpy(dst, src, copyPitch);
src += copyPitch;
dst += ddsc->lPitch;
}
// Free the copy buffer
free(m_copyBuffer);
m_copyBuffer = NULL;
}
// OFFSET: LEGO1 0x1004c580
void MxTransitionManager::SetupCopyRect(LPDDSURFACEDESC ddsc)
{
// Check if the copy rect is setup
if (m_copyFlags.bit0 == FALSE || m_waitIndicator == NULL) {
return;
}
// Tickle wait indicator
m_waitIndicator->Tickle();
// Check if wait indicator has started
if (m_waitIndicator->GetCurrentTickleState() >= MxPresenter::TickleState_Streaming) {
// Setup the copy rect
DWORD copyPitch = (ddsc->ddpfPixelFormat.dwRGBBitCount / 8) * (m_copyRect.right - m_copyRect.left + 1); // This uses m_copyRect, seemingly erroneously
DWORD bytesPerPixel = ddsc->ddpfPixelFormat.dwRGBBitCount / 8;
m_copyRect.left = m_waitIndicator->GetLocation().m_x;
m_copyRect.top = m_waitIndicator->GetLocation().m_y;
MxS32 height = m_waitIndicator->GetHeight();
MxS32 width = m_waitIndicator->GetWidth();
m_copyRect.right = m_copyRect.left + width - 1;
m_copyRect.bottom = m_copyRect.top + height - 1;
// Allocate the copy buffer
const char *src = (const char*)ddsc->lpSurface + m_copyRect.top * ddsc->lPitch + bytesPerPixel * m_copyRect.left;
m_copyBuffer = malloc(bytesPerPixel * width * height);
if (!m_copyBuffer)
return;
// Copy into the copy buffer
char *dst = (char*)m_copyBuffer;
for (MxS32 i = 0; i < (m_copyRect.bottom - m_copyRect.top + 1); i++)
{
memcpy(dst, src, copyPitch);
src += ddsc->lPitch;
dst += copyPitch;
}
}
// Setup display surface
if ((m_waitIndicator->GetAction()->GetFlags() & MxDSAction::Flag_Bit5) != 0)
{
MxDisplaySurface *displaySurface = VideoManager()->GetDisplaySurface();
MxBool unkbool = FALSE;
displaySurface->vtable2c(ddsc, m_waitIndicator->m_unk50, 0, 0, m_waitIndicator->GetLocation().m_x, m_waitIndicator->GetLocation().m_y, m_waitIndicator->GetWidth(), m_waitIndicator->GetHeight(), unkbool);
}
else
{
MxDisplaySurface *displaySurface = VideoManager()->GetDisplaySurface();
displaySurface->vtable24(ddsc, m_waitIndicator->m_unk50, 0, 0, m_waitIndicator->GetLocation().m_x, m_waitIndicator->GetLocation().m_y, m_waitIndicator->GetWidth(), m_waitIndicator->GetHeight());
}
}

27
LEGO1/mxtransitionmanager.h
View File

@ -12,7 +12,7 @@ class MxTransitionManager : public MxCore
MxTransitionManager();
virtual ~MxTransitionManager() override; // vtable+0x0
__declspec(dllexport) void SetWaitIndicator(MxVideoPresenter *videoPresenter);
__declspec(dllexport) void SetWaitIndicator(MxVideoPresenter *p_waitIndicator);
virtual MxResult Tickle(); // vtable+0x8
@ -40,7 +40,7 @@ class MxTransitionManager : public MxCore
BROKEN // Unknown what this is supposed to be, it locks the game up
};
MxResult StartTransition(TransitionType p_animationType, MxS32 p_speed, undefined p_unk, MxBool p_playMusicInAnim);
MxResult StartTransition(TransitionType p_animationType, MxS32 p_speed, MxBool p_doCopy, MxBool p_playMusicInAnim);
void MxTransitionManager::EndTransition(MxBool p_unk);
@ -53,14 +53,27 @@ class MxTransitionManager : public MxCore
private:
undefined m_pad00[0x20];
undefined m_pad20[0x04];
void EndTransition(MxBool p_notifyWorld);
void Transition_Dissolve();
void Transition_Wipe();
void SubmitCopyRect(LPDDSURFACEDESC ddsc);
void SetupCopyRect(LPDDSURFACEDESC ddsc);
MxVideoPresenter *m_waitIndicator;
RECT m_copyRect;
void *m_copyBuffer;
flag_bitfield m_copyFlags;
undefined4 m_unk24;
flag_bitfield m_unk28;
TransitionType m_transitionType;
LPDIRECTDRAWSURFACE m_ddSurface;
MxU16 m_animationTimer;
undefined m_pad36[0x8c2];
MxULong m_systemTime;
MxS32 m_animationSpeed;
MxU16 m_columnOrder[640]; // 0x36
MxU16 m_randomShift[480]; // 0x536
MxULong m_systemTime; // 0x8f8
MxS32 m_animationSpeed; // 0x8fc
};
#endif // MXTRANSITIONMANAGER_H

15
LEGO1/mxtypes.h
View File

@ -44,4 +44,19 @@ typedef MxU8 MxBool;
#define TWOCC(a, b) (((a) << 0) | ((b) << 8))
#define FOURCC(a, b, c, d) (((a) << 0) | ((b) << 8) | ((c) << 16) | ((d) << 24))
// Must be union with struct for match.
typedef union {
struct {
MxU8 bit0: 1;
MxU8 bit1: 1;
MxU8 bit2: 1;
MxU8 bit3: 1;
MxU8 bit4: 1;
MxU8 bit5: 1;
MxU8 bit6: 1;
MxU8 bit7: 1;
};
// BYTE all; // ?
} flag_bitfield;
#endif // MXTYPE_H

15
LEGO1/mxvideoparamflags.h
View File

@ -3,20 +3,7 @@
#include <windows.h>
// Must be union with struct for match.
typedef union {
struct {
BYTE bit0: 1;
BYTE bit1: 1;
BYTE bit2: 1;
BYTE bit3: 1;
BYTE bit4: 1;
BYTE bit5: 1;
BYTE bit6: 1;
BYTE bit7: 1;
};
// BYTE all; // ?
} flag_bitfield;
#include "mxtypes.h"
class MxVideoParamFlags
{

86
LEGO1/mxvideopresenter.cpp
View File

@ -2,8 +2,94 @@
DECOMP_SIZE_ASSERT(MxVideoPresenter, 0x64);
// OFFSET: LEGO1 0x1000c700 STUB
void MxVideoPresenter::VTable0x5c()
{
// TODO
}
// OFFSET: LEGO1 0x1000c710 STUB
void MxVideoPresenter::VTable0x60()
{
// TODO
}
// OFFSET: LEGO1 0x1000c720 STUB
void MxVideoPresenter::VTable0x68()
{
// TODO
}
// OFFSET: LEGO1 0x1000c730 STUB
void MxVideoPresenter::VTable0x70()
{
// TODO
}
// OFFSET: LEGO1 0x1000c740
MxVideoPresenter::~MxVideoPresenter()
{
Destroy(TRUE);
}
// OFFSET: LEGO1 0x1000c7a0 STUB
void MxVideoPresenter::InitVirtual()
{
// TODO
}
// OFFSET: LEGO1 0x1000c7b0 STUB
void MxVideoPresenter::VTable0x78()
{
// TODO
}
// OFFSET: LEGO1 0x1000c7c0 STUB
void MxVideoPresenter::VTable0x7c()
{
// TODO
}
// OFFSET: LEGO1 0x1000c7e0 STUB
MxS32 MxVideoPresenter::GetWidth()
{
// TODO
return 0;
}
// OFFSET: LEGO1 0x1000c800 STUB
MxS32 MxVideoPresenter::GetHeight()
{
// TODO
return 0;
}
// OFFSET: LEGO1 0x100b2760 STUB
void MxVideoPresenter::Init()
{
// TODO
}
// OFFSET: LEGO1 0x100b27b0 STUB
void MxVideoPresenter::Destroy(MxBool)
{
// TODO
}
// OFFSET: LEGO1 0x100b28b0 STUB
void MxVideoPresenter::VTable0x64()
{
// TODO
}
// OFFSET: LEGO1 0x100b2a70 STUB
void MxVideoPresenter::VTable0x6c()
{
// TODO
}
// OFFSET: LEGO1 0x100b3300 STUB
void MxVideoPresenter::VTable0x74()
{
// TODO
}

17
LEGO1/mxvideopresenter.h
View File

@ -13,6 +13,8 @@ class MxVideoPresenter : public MxMediaPresenter
Init();
}
virtual ~MxVideoPresenter() override; // vtable+0x0
// OFFSET: LEGO1 0x1000c820
inline virtual const char *ClassName() const override // vtable+0x0c
{
@ -27,6 +29,21 @@ class MxVideoPresenter : public MxMediaPresenter
}
void Init();
void Destroy(MxBool);
virtual void InitVirtual() override; // vtable+0x38
virtual void VTable0x5c(); // vtable+0x5c
virtual void VTable0x60(); // vtable+0x60
virtual void VTable0x64(); // vtable+0x64
virtual void VTable0x68(); // vtable+0x68
virtual void VTable0x6c(); // vtable+0x6c
virtual void VTable0x70(); // vtable+0x70
virtual void VTable0x74(); // vtable+0x74
virtual void VTable0x78(); // vtable+0x78
virtual void VTable0x7c(); // vtable+0x7c
virtual MxS32 GetWidth(); // vtable+0x80
virtual MxS32 GetHeight(); // vtable+0x84
undefined4 m_unk50;
undefined4 m_unk54;