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

Merge branch 'mxmediapresenter-tickle' into mxvideopresenter

Browse Source
This commit is contained in:
Christian Semmler 2023-11-13 05:42:00 -05:00
commit ee7024d4ac
19 changed files with 254 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
LEGO1/legobuildingmanager.cpp
View File

@ -3,10 +3,10 @@
// 0x100f37cc
int g_buildingManagerConfig = 1;
// OFFSET: LEGO1 0x1002f8c0 STUB
// OFFSET: LEGO1 0x1002f8c0
LegoBuildingManager::LegoBuildingManager()
{
// TODO
Init();
}
// OFFSET: LEGO1 0x1002f960 STUB

2
LEGO1/legoomni.cpp
View File

@ -532,7 +532,7 @@ MxBool LegoOmni::DoesEntityExist(MxDSAction& ds)
}
// OFFSET: LEGO1 0x1005b2f0
MxEntity* LegoOmni::FindWorld(const char* p_id, MxS32 p_entityId, MxCore* p_presenter)
MxEntity* LegoOmni::FindWorld(const char* p_id, MxS32 p_entityId, MxPresenter* p_presenter)
{
LegoWorld* foundEntity = NULL;
if (strcmpi(p_id, g_current)) {

20
LEGO1/legoomni.h
View File

@ -83,16 +83,16 @@ class LegoOmni : public MxOmni {
return !strcmp(name, LegoOmni::ClassName()) || MxOmni::IsA(name);
}
virtual void Init() override; // vtable+14
virtual MxResult Create(MxOmniCreateParam& p) override; // vtable+18
virtual void Destroy() override; // vtable+1c
virtual MxResult Start(MxDSAction* action) override; // vtable+20
virtual MxResult DeleteObject(MxDSAction& ds) override; // vtable+24
virtual MxBool DoesEntityExist(MxDSAction& ds) override; // vtable+28
virtual MxEntity* FindWorld(const char* p_id, MxS32 p_entityId, MxCore* 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
virtual void Init() override; // vtable+14
virtual MxResult Create(MxOmniCreateParam& p) override; // vtable+18
virtual void Destroy() override; // vtable+1c
virtual MxResult Start(MxDSAction* action) override; // vtable+20
virtual MxResult DeleteObject(MxDSAction& ds) override; // vtable+24
virtual MxBool DoesEntityExist(MxDSAction& ds) 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);

14
LEGO1/legotexturepresenter.cpp
View File

@ -1,7 +1,17 @@
#include "legotexturepresenter.h"
// OFFSET: LEGO1 0x1004eb40 STUB
#include "legoomni.h"
#include "legovideomanager.h"
// OFFSET: LEGO1 0x1004eb40
LegoTexturePresenter::~LegoTexturePresenter()
{
// TODO
VideoManager()->RemovePresenter(*this);
}
// OFFSET: LEGO1 0x1004ebb0
MxResult LegoTexturePresenter::AddToManager()
{
VideoManager()->AddPresenter(*this);
return SUCCESS;
}

2
LEGO1/legotexturepresenter.h
View File

@ -21,6 +21,8 @@ class LegoTexturePresenter : public MxMediaPresenter {
{
return !strcmp(name, LegoTexturePresenter::ClassName()) || MxMediaPresenter::IsA(name);
}
virtual MxResult AddToManager() override; // vtable+0x34
};
#endif // LEGOTEXTUREPRESENTER_H

25
LEGO1/mxcollection.h Normal file
View File

@ -0,0 +1,25 @@
#ifndef MXCOLLECTION_H
#define MXCOLLECTION_H
#include "mxcore.h"
template <class T>
class MxCollection : public MxCore {
public:
MxCollection()
{
m_count = 0;
m_customDestructor = Destroy;
}
virtual ~MxCollection() {}
static void Destroy(T){};
virtual MxS8 Compare(T, T) { return 0; }
protected:
MxU32 m_count; // +0x8
void (*m_customDestructor)(T); // +0xc
};
#endif // MXCOLLECTION_H

8
LEGO1/mxcompositepresenter.cpp
View File

@ -35,8 +35,10 @@ void MxCompositePresenter::VTable0x60(undefined4 p_unknown)
// TODO
}
// OFFSET: LEGO1 0x1000caf0 STUB
void MxCompositePresenter::VTable0x64()
// OFFSET: LEGO1 0x1000caf0
MxBool MxCompositePresenter::VTable0x64(undefined4 p_unknown)
{
// TODO
if (m_compositePresenter)
return m_compositePresenter->VTable0x64(p_unknown);
return TRUE;
}

2
LEGO1/mxcompositepresenter.h
View File

@ -27,7 +27,7 @@ class MxCompositePresenter : public MxPresenter {
virtual void VTable0x58();
virtual void VTable0x5c();
virtual void VTable0x60(undefined4 p_unknown);
virtual void VTable0x64();
virtual MxBool VTable0x64(undefined4 p_unknown);
private:
MxUnkList m_list;

3
LEGO1/mxdsaction.h
View File

@ -18,7 +18,7 @@ class MxDSAction : public MxDSObject {
Flag_Bit5 = 0x10,
Flag_Enabled = 0x20,
Flag_Bit7 = 0x40,
Flag_Parsed = 0x80,
Flag_World = 0x80,
Flag_Bit9 = 0x200,
Flag_Bit10 = 0x400,
};
@ -64,6 +64,7 @@ class MxDSAction : public MxDSObject {
inline void SetLoopCount(MxS32 p_loopCount) { m_loopCount = p_loopCount; }
inline const MxVector3Data& GetLocation() const { return m_location; }
inline void SetUnknown84(MxCore* p_unk84) { m_unk84 = p_unk84; }
inline MxCore* GetUnknown8c() { return m_unk8c; }
inline void SetUnknown8c(MxCore* p_unk8c) { m_unk8c = p_unk8c; }
inline MxBool IsLooping() const { return m_flags & Flag_Looping; }

190
LEGO1/mxhashtable.h
View File

@ -1,13 +1,11 @@
#ifndef MXHASHTABLE_H
#define MXHASHTABLE_H
#include "mxcollection.h"
#include "mxcore.h"
#include "mxtypes.h"
#define HASH_TABLE_INIT_SIZE 128
#define HASH_TABLE_OPT_NO_EXPAND 0
#define HASH_TABLE_OPT_EXPAND_ADD 1
#define HASH_TABLE_OPT_EXPAND_MULTIPLY 2
template <class T>
class MxHashTableCursor;
@ -15,8 +13,7 @@ class MxHashTableCursor;
template <class T>
class MxHashTableNode {
public:
MxHashTableNode<T>() {}
MxHashTableNode<T>(T* p_obj, MxU32 p_hash)
MxHashTableNode<T>(T p_obj, MxU32 p_hash)
{
m_obj = p_obj;
m_hash = p_hash;
@ -24,54 +21,39 @@ class MxHashTableNode {
m_next = NULL;
}
// private:
T* m_obj;
// DECOMP: Should use getter and setter methods here per the style guide.
// However, LEGO1D (with no functions inlined) does not use them.
T m_obj;
MxU32 m_hash;
MxHashTableNode* m_prev;
MxHashTableNode* m_next;
};
// See MxOmni::Create
// VTABLE 0x100dc1b0
template <class T>
class HashTableParent : public MxCore {
class MxHashTable : protected MxCollection<T> {
public:
HashTableParent()
{
m_numKeys = 0;
m_customDestructor = Destroy;
}
enum HashTableOpt {
HashTableOpt_NoExpand = 0,
HashTableOpt_ExpandAdd = 1,
HashTableOpt_ExpandMultiply = 2,
};
static void Destroy(T*){};
virtual MxS8 Compare(T*, T*) = 0;
protected:
MxU32 m_numKeys; // +0x8
void (*m_customDestructor)(T*); // +0xc
};
// VTABLE 0x100dc1e8
template <class T>
class MxHashTable : protected HashTableParent<T> {
public:
MxHashTable()
{
m_numSlots = HASH_TABLE_INIT_SIZE;
m_slots = new MxHashTableNode<T>*[HASH_TABLE_INIT_SIZE];
memset(m_slots, 0, sizeof(MxHashTableNode<T>*) * m_numSlots);
m_resizeOption = HASH_TABLE_OPT_NO_EXPAND;
m_resizeOption = HashTableOpt_NoExpand;
}
virtual ~MxHashTable() override;
void Resize();
void Add(T*);
void Add(T);
void DeleteAll();
virtual MxS8 Compare(T*, T*) override = 0;
virtual MxU32 Hash(T*) = 0;
virtual MxU32 Hash(T) { return 0; }
// FIXME: use of friend here?
friend class MxHashTableCursor<T>;
protected:
@ -79,91 +61,108 @@ class MxHashTable : protected HashTableParent<T> {
MxHashTableNode<T>** m_slots; // +0x10
MxU32 m_numSlots; // +0x14
MxU32 m_autoResizeRatio;
int m_resizeOption; // +0x1c
MxU32 m_autoResizeRatio; // +0x18
HashTableOpt m_resizeOption; // +0x1c
// FIXME: or FIXME? This qword is used as an integer or double depending
// on the value of m_resizeOption. Hard to say whether this is how the devs
// did it, but a simple cast in either direction doesn't match.
union {
MxU32 m_increaseAmount;
double m_increaseFactor;
MxU32 m_increaseAmount; // +0x20
double m_increaseFactor; // +0x20
};
};
template <class T>
class MxHashTableCursor : public MxCore {
public:
MxHashTableCursor(MxHashTable<T>* p_hashTable)
MxHashTableCursor(MxHashTable<T>* p_table)
{
m_table = p_hashTable;
m_table = p_table;
m_match = NULL;
}
MxBool Find(T* p_obj)
{
MxU32 hash = m_table->Hash(p_obj);
int bucket = hash % m_table->m_numSlots;
MxHashTableNode<T>* t = m_table->m_slots[bucket];
while (t) {
if (t->m_hash == hash && !m_table->Compare(t->m_obj, p_obj))
m_match = t;
t = t->m_next;
}
return m_match != NULL;
}
void GetMatch(T*& p_obj)
{
if (m_match) {
p_obj = m_match->m_obj;
}
}
void DeleteMatch()
{
// Cut the matching node out of the linked list
// by updating pointer references.
if (m_match->m_prev) {
m_match->m_prev->m_next = m_match->m_next;
}
else {
// No "prev" node, so move "next" to the head of the list.
int bucket = m_match->m_hash % m_table->m_numSlots;
m_table->m_slots[bucket] = m_match->m_next;
}
if (m_match->m_next)
m_match->m_next->m_prev = m_match->m_prev;
m_table->m_customDestructor(m_match->m_obj);
delete m_match;
m_table->m_numKeys--;
}
MxBool Find(T p_obj);
MxBool Current(T& p_obj);
void DeleteMatch();
private:
MxHashTable<T>* m_table;
MxHashTableNode<T>* m_match;
};
template <class T>
MxBool MxHashTableCursor<T>::Find(T p_obj)
{
MxU32 hash = m_table->Hash(p_obj);
MxS32 bucket = hash % m_table->m_numSlots;
MxHashTableNode<T>* t = m_table->m_slots[bucket];
while (t) {
if (t->m_hash == hash && !m_table->Compare(t->m_obj, p_obj))
m_match = t;
t = t->m_next;
}
return m_match != NULL;
}
template <class T>
MxBool MxHashTableCursor<T>::Current(T& p_obj)
{
if (m_match) {
p_obj = m_match->m_obj;
}
return m_match != NULL;
}
template <class T>
void MxHashTableCursor<T>::DeleteMatch()
{
// Cut the matching node out of the linked list
// by updating pointer references.
if (m_match == NULL)
return;
if (m_match->m_prev) {
m_match->m_prev->m_next = m_match->m_next;
}
else {
// No "prev" node, so move "next" to the head of the list.
MxS32 bucket = m_match->m_hash % m_table->m_numSlots;
m_table->m_slots[bucket] = m_match->m_next;
}
if (m_match->m_next)
m_match->m_next->m_prev = m_match->m_prev;
m_table->m_customDestructor(m_match->m_obj);
delete m_match;
m_table->m_count--;
}
template <class T>
MxHashTable<T>::~MxHashTable()
{
for (int i = 0; i < m_numSlots; i++) {
DeleteAll();
}
template <class T>
void MxHashTable<T>::DeleteAll()
{
for (MxS32 i = 0; i < m_numSlots; i++) {
MxHashTableNode<T>* t = m_slots[i];
while (t) {
MxHashTableNode<T>* next = t->m_next;
this->m_customDestructor(t->m_obj);
m_customDestructor(t->m_obj);
delete t;
t = next;
}
}
this->m_numKeys = 0;
m_count = 0;
memset(m_slots, 0, sizeof(MxHashTableNode<T>*) * m_numSlots);
delete[] m_slots;
@ -178,21 +177,20 @@ inline void MxHashTable<T>::Resize()
MxHashTableNode<T>** old_table = m_slots;
switch (m_resizeOption) {
case HASH_TABLE_OPT_EXPAND_ADD:
case HashTableOpt_ExpandAdd:
m_numSlots += m_increaseAmount;
break;
case HASH_TABLE_OPT_EXPAND_MULTIPLY:
case HashTableOpt_ExpandMultiply:
m_numSlots *= m_increaseFactor;
break;
}
MxHashTableNode<T>** new_table = new MxHashTableNode<T>*[m_numSlots];
// FIXME: order? m_numKeys set after `rep stosd`
m_slots = new_table;
memset(m_slots, 0, sizeof(MxHashTableNode<T>*) * m_numSlots);
this->m_numKeys = 0;
m_count = 0;
for (int i = 0; i != old_size; i++) {
for (MxS32 i = 0; i != old_size; i++) {
MxHashTableNode<T>* t = old_table[i];
while (t) {
@ -208,7 +206,7 @@ inline void MxHashTable<T>::Resize()
template <class T>
inline void MxHashTable<T>::_NodeInsert(MxHashTableNode<T>* p_node)
{
int bucket = p_node->m_hash % m_numSlots;
MxS32 bucket = p_node->m_hash % m_numSlots;
p_node->m_next = m_slots[bucket];
@ -216,13 +214,13 @@ inline void MxHashTable<T>::_NodeInsert(MxHashTableNode<T>* p_node)
m_slots[bucket]->m_prev = p_node;
m_slots[bucket] = p_node;
this->m_numKeys++;
m_count++;
}
template <class T>
inline void MxHashTable<T>::Add(T* p_newobj)
inline void MxHashTable<T>::Add(T p_newobj)
{
if (m_resizeOption && ((this->m_numKeys + 1) / m_numSlots) > m_autoResizeRatio)
if (m_resizeOption && ((m_count + 1) / m_numSlots) > m_autoResizeRatio)
MxHashTable<T>::Resize();
MxU32 hash = Hash(p_newobj);
@ -231,4 +229,6 @@ inline void MxHashTable<T>::Add(T* p_newobj)
MxHashTable<T>::_NodeInsert(node);
}
#undef HASH_TABLE_INIT_SIZE
#endif // MXHASHTABLE_H

34
LEGO1/mxmediapresenter.cpp
View File

@ -1,6 +1,9 @@
#include "mxmediapresenter.h"
#include "mxactionnotificationparam.h"
#include "mxautolocker.h"
#include "mxcompositepresenter.h"
#include "mxnotificationmanager.h"
#include "mxstreamchunk.h"
#include "mxtimer.h"
@ -217,10 +220,37 @@ MxResult MxMediaPresenter::StartAction(MxStreamController* p_controller, MxDSAct
return result;
}
// OFFSET: LEGO1 0x100b5bc0 STUB
// OFFSET: LEGO1 0x100b5bc0
void MxMediaPresenter::EndAction()
{
// TODO
MxAutoLocker lock(&m_criticalSection);
if (!m_action)
return;
m_currentChunk = NULL;
if (m_action->GetFlags() & MxDSAction::Flag_World &&
(!m_compositePresenter || !m_compositePresenter->VTable0x64(2))) {
MxPresenter::Enable(FALSE);
SetTickleState(TickleState::TickleState_Idle);
}
else {
MxDSAction* action = m_action;
MxPresenter::EndAction();
if (m_subscriber) {
delete m_subscriber;
m_subscriber = NULL;
}
if (action && action->GetUnknown8c()) {
NotificationManager()->Send(
action->GetUnknown8c(),
&MxEndActionNotificationParam(c_notificationEndAction, this, action, FALSE)
);
}
}
}
// OFFSET: LEGO1 0x100b5f10

2
LEGO1/mxomni.cpp
View File

@ -92,7 +92,7 @@ void MxOmni::Vtable0x2c()
}
// OFFSET: LEGO1 0x100aefb0
MxEntity* MxOmni::FindWorld(const char*, MxS32, MxCore*)
MxEntity* MxOmni::FindWorld(const char*, MxS32, MxPresenter*)
{
return NULL;
}

3
LEGO1/mxomni.h
View File

@ -14,6 +14,7 @@ class MxNotificationManager;
class MxNotificationParam;
class MxObjectFactory;
class MxOmniCreateParam;
class MxPresenter;
class MxSoundManager;
class MxStreamer;
class MxTickleManager;
@ -46,7 +47,7 @@ class MxOmni : public MxCore {
virtual MxResult DeleteObject(MxDSAction& p_dsAction); // vtable+24
virtual MxBool DoesEntityExist(MxDSAction& p_dsAction); // vtable+28
virtual void Vtable0x2c(); // vtable+2c
virtual MxEntity* FindWorld(const char*, MxS32, MxCore*); // vtable+30
virtual MxEntity* FindWorld(const char*, MxS32, MxPresenter*); // vtable+30
virtual void NotifyCurrentEntity(MxNotificationParam* p_param); // vtable+34
virtual void StartTimer(); // vtable+38
virtual void StopTimer(); // vtable+3c

19
LEGO1/mxpresenter.cpp
View File

@ -5,6 +5,7 @@
#include "legoomni.h"
#include "mxactionnotificationparam.h"
#include "mxautolocker.h"
#include "mxcompositepresenter.h"
#include "mxdsanim.h"
#include "mxdssound.h"
#include "mxnotificationmanager.h"
@ -22,7 +23,7 @@ void MxPresenter::Init()
m_action = NULL;
m_location = MxPoint32(0, 0);
m_displayZ = 0;
m_unkPresenter = NULL;
m_compositePresenter = NULL;
m_previousTickleStates = 0;
}
@ -49,24 +50,24 @@ void MxPresenter::ParseExtra()
MxS32 val = token ? atoi(token) : 0;
MxEntity* result = MxOmni::GetInstance()->FindWorld(t_token, val, this);
m_action->SetFlags(m_action->GetFlags() | MxDSAction::Flag_Parsed);
m_action->SetFlags(m_action->GetFlags() | MxDSAction::Flag_World);
if (result)
SendTo_unkPresenter(MxOmni::GetInstance());
SendToCompositePresenter(MxOmni::GetInstance());
}
}
}
// OFFSET: LEGO1 0x100b5120
void MxPresenter::SendTo_unkPresenter(MxOmni* p_omni)
void MxPresenter::SendToCompositePresenter(MxOmni* p_omni)
{
if (m_unkPresenter) {
if (m_compositePresenter) {
MxAutoLocker lock(&m_criticalSection);
NotificationManager()->Send(m_unkPresenter, &MxNotificationParam(MXPRESENTER_NOTIFICATION, this));
NotificationManager()->Send(m_compositePresenter, &MxNotificationParam(MXPRESENTER_NOTIFICATION, this));
m_action->SetUnknown8c(p_omni ? p_omni : MxOmni::GetInstance());
m_unkPresenter = NULL;
m_compositePresenter = NULL;
}
}
@ -138,8 +139,10 @@ void MxPresenter::EndAction()
{
if (this->m_action == FALSE)
return;
MxAutoLocker lock(&this->m_criticalSection);
if (!this->m_unkPresenter) {
if (!this->m_compositePresenter) {
MxOmni::GetInstance()->NotifyCurrentEntity(
&MxEndActionNotificationParam(c_notificationEndAction, NULL, this->m_action, TRUE)
);

18
LEGO1/mxpresenter.h
View File

@ -8,6 +8,7 @@
#include "mxomni.h"
#include "mxpoint32.h"
class MxCompositePresenter;
class MxStreamController;
// VTABLE 0x100d4d38
@ -75,14 +76,15 @@ class MxPresenter : public MxCore {
protected:
__declspec(dllexport) void Init();
void SendTo_unkPresenter(MxOmni*);
TickleState m_currentTickleState; // 0x8
MxU32 m_previousTickleStates; // 0x0c
MxPoint32 m_location; // 0x10
MxS32 m_displayZ; // 0x18
MxDSAction* m_action; // 0x1c
MxCriticalSection m_criticalSection; // 0x20
MxPresenter* m_unkPresenter; // 0x3c
void SendToCompositePresenter(MxOmni*);
TickleState m_currentTickleState; // 0x8
MxU32 m_previousTickleStates; // 0x0c
MxPoint32 m_location; // 0x10
MxS32 m_displayZ; // 0x18
MxDSAction* m_action; // 0x1c
MxCriticalSection m_criticalSection; // 0x20
MxCompositePresenter* m_compositePresenter; // 0x3c
};
const char* PresenterNameDispatch(const MxDSAction&);

1
LEGO1/mxstring.h
View File

@ -18,6 +18,7 @@ class MxString : public MxCore {
MxString operator+(const char*);
MxString& operator+=(const char*);
inline MxS8 Compare(const MxString& p_str) const { return strcmp(m_data, p_str.m_data); }
inline const char* GetData() const { return m_data; }
private:

2
LEGO1/mxtransitionmanager.cpp
View File

@ -468,7 +468,7 @@ 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->GetAction()->SetFlags(m_waitIndicator->GetAction()->GetFlags() & ~MxDSAction::Flag_World);
m_waitIndicator->EndAction();
m_waitIndicator = NULL;
}

20
LEGO1/mxvariabletable.cpp
View File

@ -3,7 +3,7 @@
// OFFSET: LEGO1 0x100b7330
MxS8 MxVariableTable::Compare(MxVariable* p_var0, MxVariable* p_var1)
{
return strcmp(p_var0->GetKey()->GetData(), p_var1->GetKey()->GetData());
return p_var0->GetKey()->Compare(*p_var1->GetKey());
}
// OFFSET: LEGO1 0x100b7370
@ -22,43 +22,43 @@ MxU32 MxVariableTable::Hash(MxVariable* p_var)
// OFFSET: LEGO1 0x100b73a0
void MxVariableTable::SetVariable(const char* p_key, const char* p_value)
{
MxHashTableCursor<MxVariable> cursor(this);
MxHashTableCursor<MxVariable*> cursor(this);
MxVariable* var = new MxVariable(p_key, p_value);
if (cursor.Find(var)) {
delete var;
cursor.GetMatch(var);
cursor.Current(var);
var->SetValue(p_value);
}
else {
MxHashTable<MxVariable>::Add(var);
MxHashTable<MxVariable*>::Add(var);
}
}
// OFFSET: LEGO1 0x100b7740
void MxVariableTable::SetVariable(MxVariable* var)
void MxVariableTable::SetVariable(MxVariable* p_var)
{
MxHashTableCursor<MxVariable> cursor(this);
MxBool found = cursor.Find(var);
MxHashTableCursor<MxVariable*> cursor(this);
MxBool found = cursor.Find(p_var);
if (found)
cursor.DeleteMatch();
MxHashTable<MxVariable>::Add(var);
MxHashTable<MxVariable*>::Add(p_var);
}
// OFFSET: LEGO1 0x100b78f0
const char* MxVariableTable::GetVariable(const char* p_key)
{
const char* value = "";
MxHashTableCursor<MxVariable> cursor(this);
MxHashTableCursor<MxVariable*> cursor(this);
MxVariable* var = new MxVariable(p_key);
MxBool found = cursor.Find(var);
delete var;
if (found) {
cursor.GetMatch(var);
cursor.Current(var);
value = var->GetValue()->GetData();
}

38
LEGO1/mxvariabletable.h
View File

@ -7,12 +7,12 @@
// VTABLE 0x100dc1c8
// SIZE 0x28
class MxVariableTable : public MxHashTable<MxVariable> {
class MxVariableTable : public MxHashTable<MxVariable*> {
public:
MxVariableTable() { m_customDestructor = Destroy; }
__declspec(dllexport) void SetVariable(const char* key, const char* value);
__declspec(dllexport) void SetVariable(MxVariable* var);
__declspec(dllexport) const char* GetVariable(const char* key);
__declspec(dllexport) void SetVariable(const char* p_key, const char* p_value);
__declspec(dllexport) void SetVariable(MxVariable* p_var);
__declspec(dllexport) const char* GetVariable(const char* p_key);
// OFFSET: LEGO1 0x100afdb0
static void Destroy(MxVariable* p_obj) { p_obj->Destroy(); }
@ -21,13 +21,37 @@ class MxVariableTable : public MxHashTable<MxVariable> {
virtual MxU32 Hash(MxVariable*) override; // +0x18
};
// OFFSET: LEGO1 0x100afcd0 TEMPLATE
// MxCollection<MxVariable *>::Compare
// OFFSET: LEGO1 0x100afce0 TEMPLATE
// MxCollection<MxVariable *>::~MxCollection<MxVariable *>
// OFFSET: LEGO1 0x100afd30 TEMPLATE
// MxCollection<MxVariable *>::Destroy
// OFFSET: LEGO1 0x100afd40 TEMPLATE
// MxCollection<MxVariable *>::`scalar deleting destructor'
// OFFSET: LEGO1 0x100afdc0 TEMPLATE
// MxHashTable<MxVariable *>::Hash
// OFFSET: LEGO1 0x100b0bd0 TEMPLATE
// MxHashTable<MxVariable>::~MxHashTable<MxVariable>
// MxHashTable<MxVariable *>::~MxHashTable<MxVariable *>
// OFFSET: LEGO1 0x100b0ca0 TEMPLATE
// MxHashTable<MxVariable *>::`scalar deleting destructor'
// OFFSET: LEGO1 0x100b7ab0 TEMPLATE
// MxHashTable<MxVariable>::Resize
// MxHashTable<MxVariable *>::Resize
// OFFSET: LEGO1 0x100b7b80 TEMPLATE
// MxHashTable<MxVariable>::_NodeInsert
// MxHashTable<MxVariable *>::_NodeInsert
// VTABLE 0x100dc1b0 TEMPLATE
// class MxCollection<MxVariable *>
// VTABLE 0x100dc1e8 TEMPLATE
// class MxHashTable<MxVariable *>
#endif // MXVARIABLETABLE_H