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

Apply clang-format

Browse Source
This commit is contained in:
disinvite 2023-10-24 22:09:18 -04:00
parent 6da1bc0a0d
commit fc1edf7d0b
4 changed files with 337 additions and 328 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
LEGO1/mxbitmap.h
View File

@ -1,12 +1,12 @@
#ifndef MXBITMAP_H #ifndef MXBITMAP_H
#define MXBITMAP_H #define MXBITMAP_H
#include <stdlib.h>
#include "mxcore.h" #include "mxcore.h"
#include "mxpalette.h" #include "mxpalette.h"
#include "mxtypes.h" #include "mxtypes.h"
#include <stdlib.h>
// The stock BITMAPINFO struct from wingdi.h only makes room for one color // The stock BITMAPINFO struct from wingdi.h only makes room for one color
// in the palette. It seems like the expectation (if you use the struct) // in the palette. It seems like the expectation (if you use the struct)
// is to malloc as much as you actually need, and then index into the array // is to malloc as much as you actually need, and then index into the array
@ -17,8 +17,8 @@
// SIZE 0x428 // SIZE 0x428
struct MxBITMAPINFO { struct MxBITMAPINFO {
BITMAPINFOHEADER bmiHeader; BITMAPINFOHEADER bmiHeader;
RGBQUAD bmiColors[256]; RGBQUAD bmiColors[256];
}; };
// Non-standard value for biCompression in the BITMAPINFOHEADER struct. // Non-standard value for biCompression in the BITMAPINFOHEADER struct.
@ -26,45 +26,55 @@ struct MxBITMAPINFO {
// You can specify that the bitmap has top-down order instead by providing // You can specify that the bitmap has top-down order instead by providing
// a negative number for biHeight. It could be that Mindscape decided on a // a negative number for biHeight. It could be that Mindscape decided on a
// belt & suspenders approach here. // belt & suspenders approach here.
#define BI_RGB_TOPDOWN 0x10 #define BI_RGB_TOPDOWN 0x10
// SIZE 0x20 // SIZE 0x20
// VTABLE 0x100dc7b0 // VTABLE 0x100dc7b0
class MxBitmap : public MxCore class MxBitmap : public MxCore {
{
public: public:
__declspec(dllexport) MxBitmap(); __declspec(dllexport) MxBitmap();
__declspec(dllexport) virtual ~MxBitmap(); // vtable+00 __declspec(dllexport) virtual ~MxBitmap(); // vtable+00
virtual MxResult ImportBitmap(MxBitmap *p_bitmap); // vtable+14 virtual MxResult ImportBitmap(MxBitmap* p_bitmap); // vtable+14
virtual MxResult ImportBitmapInfo(MxBITMAPINFO *p_info); // vtable+18 virtual MxResult ImportBitmapInfo(MxBITMAPINFO* p_info); // vtable+18
virtual MxResult SetSize(MxS32 p_width, MxS32 p_height, MxPalette *p_palette, MxBool); // vtable+1c virtual MxResult SetSize(MxS32 p_width, MxS32 p_height, MxPalette* p_palette, MxBool); // vtable+1c
virtual MxResult LoadFile(HANDLE p_handle); // vtable+20 virtual MxResult LoadFile(HANDLE p_handle); // vtable+20
__declspec(dllexport) virtual MxLong Read(const char *p_filename); // vtable+24 __declspec(dllexport) virtual MxLong Read(const char* p_filename); // vtable+24
virtual int vtable28(int); virtual int vtable28(int);
virtual void vtable2c(int, int, int, int, int, int, int); virtual void vtable2c(int, int, int, int, int, int, int);
virtual void vtable30(int, int, int, int, int, int, int); virtual void vtable30(int, int, int, int, int, int, int);
__declspec(dllexport) virtual MxPalette *CreatePalette(); // vtable+34 __declspec(dllexport) virtual MxPalette* CreatePalette(); // vtable+34
virtual void ImportPalette(MxPalette* p_palette); // vtable+38 virtual void ImportPalette(MxPalette* p_palette); // vtable+38
virtual MxResult SetBitDepth(MxBool); // vtable+3c virtual MxResult SetBitDepth(MxBool); // vtable+3c
virtual MxResult StretchBits(HDC p_hdc, MxS32 p_xSrc, MxS32 p_ySrc, MxS32 p_xDest, MxS32 p_yDest, MxS32 p_destWidth, MxS32 p_destHeight); // vtable+40 virtual MxResult StretchBits(
HDC p_hdc,
MxS32 p_xSrc,
MxS32 p_ySrc,
MxS32 p_xDest,
MxS32 p_yDest,
MxS32 p_destWidth,
MxS32 p_destHeight
); // vtable+40
inline BITMAPINFOHEADER *GetBmiHeader() const { return m_bmiHeader; } inline BITMAPINFOHEADER* GetBmiHeader() const { return m_bmiHeader; }
inline MxLong GetBmiWidth() const { return m_bmiHeader->biWidth; } inline MxLong GetBmiWidth() const { return m_bmiHeader->biWidth; }
inline MxLong GetBmiStride() const { return ((m_bmiHeader->biWidth + 3) & -4); } inline MxLong GetBmiStride() const { return ((m_bmiHeader->biWidth + 3) & -4); }
inline MxLong GetBmiHeight() const { return m_bmiHeader->biHeight; } inline MxLong GetBmiHeight() const { return m_bmiHeader->biHeight; }
inline MxLong GetBmiHeightAbs() const { return m_bmiHeader->biHeight > 0 ? m_bmiHeader->biHeight : -m_bmiHeader->biHeight; } inline MxLong GetBmiHeightAbs() const
inline MxU8 *GetBitmapData() const { return m_data; } {
return m_bmiHeader->biHeight > 0 ? m_bmiHeader->biHeight : -m_bmiHeader->biHeight;
}
inline MxU8* GetBitmapData() const { return m_data; }
private: private:
MxResult ImportColorsToPalette(RGBQUAD*, MxPalette*); MxResult ImportColorsToPalette(RGBQUAD*, MxPalette*);
MxBITMAPINFO *m_info; // 0x8 MxBITMAPINFO* m_info; // 0x8
BITMAPINFOHEADER *m_bmiHeader; // 0xc BITMAPINFOHEADER* m_bmiHeader; // 0xc
RGBQUAD *m_paletteData; // 0x10 RGBQUAD* m_paletteData; // 0x10
MxU8 *m_data; // 0x14 MxU8* m_data; // 0x14
MxBool m_isHighColor; // 0x18 MxBool m_isHighColor; // 0x18
MxPalette *m_palette; // 0x1c MxPalette* m_palette; // 0x1c
}; };
#endif // MXBITMAP_H #endif // MXBITMAP_H

127
LEGO1/mxdsaction.h
View File

@ -9,87 +9,86 @@ class MxOmni;
// VTABLE 0x100dc098 // VTABLE 0x100dc098
// SIZE 0x94 // SIZE 0x94
class MxDSAction : public MxDSObject class MxDSAction : public MxDSObject {
{
public: public:
enum enum {
{ Flag_Looping = 0x01,
Flag_Looping = 0x01, Flag_Bit3 = 0x04,
Flag_Bit3 = 0x04, Flag_Bit4 = 0x08,
Flag_Bit4 = 0x08, Flag_Bit5 = 0x10,
Flag_Bit5 = 0x10, Flag_Enabled = 0x20,
Flag_Enabled = 0x20, Flag_Parsed = 0x80,
Flag_Parsed = 0x80, Flag_Bit9 = 0x200,
Flag_Bit9 = 0x200, Flag_Bit10 = 0x400,
Flag_Bit10 = 0x400, };
};
__declspec(dllexport) MxDSAction(); __declspec(dllexport) MxDSAction();
__declspec(dllexport) virtual ~MxDSAction(); __declspec(dllexport) virtual ~MxDSAction();
void CopyFrom(MxDSAction &p_dsAction); void CopyFrom(MxDSAction& p_dsAction);
MxDSAction &operator=(MxDSAction &p_dsAction); MxDSAction& operator=(MxDSAction& p_dsAction);
// OFFSET: LEGO1 0x100ad980 // OFFSET: LEGO1 0x100ad980
inline virtual const char *ClassName() const override // vtable+0x0c inline virtual const char* ClassName() const override // vtable+0x0c
{ {
// 0x101013f4 // 0x101013f4
return "MxDSAction"; return "MxDSAction";
} }
// OFFSET: LEGO1 0x100ad990 // OFFSET: LEGO1 0x100ad990
inline virtual MxBool IsA(const char *name) const override // vtable+0x10 inline virtual MxBool IsA(const char* name) const override // vtable+0x10
{ {
return !strcmp(name, MxDSAction::ClassName()) || MxDSObject::IsA(name); return !strcmp(name, MxDSAction::ClassName()) || MxDSObject::IsA(name);
} }
virtual MxU32 GetSizeOnDisk() override; // vtable+18; virtual MxU32 GetSizeOnDisk() override; // vtable+18;
virtual void Deserialize(char **p_source, MxS16 p_unk24) override; // vtable+1c; virtual void Deserialize(char** p_source, MxS16 p_unk24) override; // vtable+1c;
virtual MxLong GetDuration(); // vtable+24; virtual MxLong GetDuration(); // vtable+24;
virtual void SetDuration(MxLong p_duration); // vtable+28; virtual void SetDuration(MxLong p_duration); // vtable+28;
virtual MxDSAction *Clone(); // vtable+2c; virtual MxDSAction* Clone(); // vtable+2c;
virtual void MergeFrom(MxDSAction &p_dsAction); // vtable+30; virtual void MergeFrom(MxDSAction& p_dsAction); // vtable+30;
virtual MxBool HasId(MxU32 p_objectId); // vtable+34; virtual MxBool HasId(MxU32 p_objectId); // vtable+34;
virtual void SetUnkTimingField(MxLong p_unkTimingField); // vtable+38; virtual void SetUnkTimingField(MxLong p_unkTimingField); // vtable+38;
virtual MxLong GetUnkTimingField(); // vtable+3c; virtual MxLong GetUnkTimingField(); // vtable+3c;
virtual MxLong GetCurrentTime(); // vtable+40; virtual MxLong GetCurrentTime(); // vtable+40;
void AppendData(MxU16 p_extraLength, const char *p_extraData); void AppendData(MxU16 p_extraLength, const char* p_extraData);
inline MxU32 GetFlags() { return m_flags; } inline MxU32 GetFlags() { return m_flags; }
inline void SetFlags(MxU32 p_flags) { m_flags = p_flags; } inline void SetFlags(MxU32 p_flags) { m_flags = p_flags; }
inline char *GetExtraData() { return m_extraData; } inline char* GetExtraData() { return m_extraData; }
inline MxU16 GetExtraLength() const { return m_extraLength; } inline MxU16 GetExtraLength() const { return m_extraLength; }
inline MxLong GetStartTime() const { return m_startTime; } inline MxLong GetStartTime() const { return m_startTime; }
inline MxS32 GetLoopCount() { return m_loopCount; } inline MxS32 GetLoopCount() { return m_loopCount; }
inline void SetLoopCount(MxS32 p_loopCount) { m_loopCount = p_loopCount; } inline void SetLoopCount(MxS32 p_loopCount) { m_loopCount = p_loopCount; }
inline const MxVector3Data &GetLocation() const { return m_location; } inline const MxVector3Data& GetLocation() const { return m_location; }
inline void SetOmni(MxOmni *p_omni) { m_omni = p_omni; } inline void SetUnknown84(MxCore* p_unk84) { m_unk84 = p_unk84; }
inline void SetOmni(MxOmni* p_omni) { m_omni = p_omni; }
inline MxBool IsLooping() const { return m_flags & Flag_Looping; } inline MxBool IsLooping() const { return m_flags & Flag_Looping; }
inline MxBool IsBit3() const { return m_flags & Flag_Bit3; } inline MxBool IsBit3() const { return m_flags & Flag_Bit3; }
private: private:
MxU32 m_sizeOnDisk; MxU32 m_sizeOnDisk;
MxU32 m_flags; MxU32 m_flags;
MxLong m_startTime; MxLong m_startTime;
protected: protected:
MxLong m_duration; MxLong m_duration;
MxS32 m_loopCount; MxS32 m_loopCount;
private: private:
MxVector3Data m_location; MxVector3Data m_location;
MxVector3Data m_direction; MxVector3Data m_direction;
MxVector3Data m_up; MxVector3Data m_up;
char *m_extraData; char* m_extraData;
MxU16 m_extraLength; MxU16 m_extraLength;
undefined4 m_unk84; MxCore* m_unk84;
undefined4 m_unk88; undefined4 m_unk88;
MxOmni *m_omni; // 0x8c MxOmni* m_omni; // 0x8c
protected: protected:
MxLong m_unkTimingField; // 0x90 MxLong m_unkTimingField; // 0x90
}; };
#endif // MXDSACTION_H #endif // MXDSACTION_H

361
LEGO1/mxvideopresenter.cpp
View File

@ -1,5 +1,6 @@
#include "mxvideopresenter.h" #include "mxvideopresenter.h"
#include "MxVideoManager.h"
#include "mxvideomanager.h"
DECOMP_SIZE_ASSERT(MxVideoPresenter, 0x64); DECOMP_SIZE_ASSERT(MxVideoPresenter, 0x64);
DECOMP_SIZE_ASSERT(MxVideoPresenter::AlphaMask, 0xc); DECOMP_SIZE_ASSERT(MxVideoPresenter::AlphaMask, 0xc);
@ -7,302 +8,306 @@ DECOMP_SIZE_ASSERT(MxVideoPresenter::AlphaMask, 0xc);
// OFFSET: LEGO1 0x1000c700 // OFFSET: LEGO1 0x1000c700
void MxVideoPresenter::VTable0x5c(undefined4 p_unknown1) void MxVideoPresenter::VTable0x5c(undefined4 p_unknown1)
{ {
// Empty // Empty
} }
// OFFSET: LEGO1 0x1000c710 // OFFSET: LEGO1 0x1000c710
void MxVideoPresenter::VTable0x60() void MxVideoPresenter::VTable0x60()
{ {
// Empty // Empty
} }
// OFFSET: LEGO1 0x1000c720 // OFFSET: LEGO1 0x1000c720
void MxVideoPresenter::VTable0x68(undefined4 p_unknown1) void MxVideoPresenter::VTable0x68(undefined4 p_unknown1)
{ {
// Empty // Empty
} }
// OFFSET: LEGO1 0x1000c730 // OFFSET: LEGO1 0x1000c730
void MxVideoPresenter::VTable0x70() void MxVideoPresenter::VTable0x70()
{ {
// Empty // Empty
} }
// OFFSET: LEGO1 0x1000c740 // OFFSET: LEGO1 0x1000c740
MxVideoPresenter::~MxVideoPresenter() MxVideoPresenter::~MxVideoPresenter()
{ {
Destroy(TRUE); Destroy(TRUE);
} }
// OFFSET: LEGO1 0x1000c7a0 // OFFSET: LEGO1 0x1000c7a0
void MxVideoPresenter::Destroy() void MxVideoPresenter::Destroy()
{ {
Destroy(FALSE); Destroy(FALSE);
} }
// OFFSET: LEGO1 0x1000c7b0 // OFFSET: LEGO1 0x1000c7b0
LPDIRECTDRAWSURFACE MxVideoPresenter::VTable0x78() LPDIRECTDRAWSURFACE MxVideoPresenter::VTable0x78()
{ {
return m_unk58; return m_unk58;
} }
// OFFSET: LEGO1 0x1000c7c0 // OFFSET: LEGO1 0x1000c7c0
MxBool MxVideoPresenter::VTable0x7c() MxBool MxVideoPresenter::VTable0x7c()
{ {
return (m_bitmap != NULL) || (m_alpha != NULL); return (m_bitmap != NULL) || (m_alpha != NULL);
} }
// OFFSET: LEGO1 0x1000c7e0 // OFFSET: LEGO1 0x1000c7e0
MxS32 MxVideoPresenter::GetWidth() MxS32 MxVideoPresenter::GetWidth()
{ {
return m_alpha ? m_alpha->m_width return m_alpha ? m_alpha->m_width : m_bitmap->GetBmiHeader()->biWidth;
: m_bitmap->GetBmiHeader()->biWidth;
} }
// OFFSET: LEGO1 0x1000c800 // OFFSET: LEGO1 0x1000c800
MxS32 MxVideoPresenter::GetHeight() MxS32 MxVideoPresenter::GetHeight()
{ {
return m_alpha ? m_alpha->m_height return m_alpha ? m_alpha->m_height : m_bitmap->GetBmiHeader()->biHeight;
: m_bitmap->GetBmiHeader()->biHeight;
} }
// OFFSET: LEGO1 0x100b24f0 // OFFSET: LEGO1 0x100b24f0
MxVideoPresenter::AlphaMask::AlphaMask(const MxBitmap &p_bitmap) MxVideoPresenter::AlphaMask::AlphaMask(const MxBitmap& p_bitmap)
{ {
m_width = p_bitmap.GetBmiWidth(); m_width = p_bitmap.GetBmiWidth();
// DECOMP: ECX becomes word-sized if these are not two separate actions. // DECOMP: ECX becomes word-sized if these are not two separate actions.
MxLong _height = p_bitmap.GetBmiHeightAbs(); MxLong _height = p_bitmap.GetBmiHeightAbs();
m_height = _height; m_height = _height;
MxS32 size = ((m_width * m_height) / 8) + 1; MxS32 size = ((m_width * m_height) / 8) + 1;
m_bitmask = new MxU8[size]; m_bitmask = new MxU8[size];
memset(m_bitmask, 0, size); memset(m_bitmask, 0, size);
MxU32 biCompression = p_bitmap.GetBmiHeader()->biCompression; MxU32 biCompression = p_bitmap.GetBmiHeader()->biCompression;
MxU32 rows_before_top; MxU32 rows_before_top;
MxU8 *bitmap_src_ptr; MxU8* bitmap_src_ptr;
// The goal here is to enable us to walk through the bitmap's rows // The goal here is to enable us to walk through the bitmap's rows
// in order, regardless of the orientation. We want to end up at the // in order, regardless of the orientation. We want to end up at the
// start of the first row, which is either at position 0, or at // start of the first row, which is either at position 0, or at
// (image_stride * biHeight) - 1. // (image_stride * biHeight) - 1.
// Reminder: Negative biHeight means this is a top-down DIB. // Reminder: Negative biHeight means this is a top-down DIB.
// Otherwise it is bottom-up. // Otherwise it is bottom-up.
if (biCompression == BI_RGB) { if (biCompression == BI_RGB) {
// DECOMP: I think this must be an OR. If not, the check for // DECOMP: I think this must be an OR. If not, the check for
// biCompression == 16 gets optimized away. // biCompression == 16 gets optimized away.
if (biCompression == BI_RGB_TOPDOWN || p_bitmap.GetBmiHeight() < 0) { if (biCompression == BI_RGB_TOPDOWN || p_bitmap.GetBmiHeight() < 0) {
rows_before_top = 0; rows_before_top = 0;
} else { }
rows_before_top = p_bitmap.GetBmiHeightAbs(); else {
rows_before_top--; rows_before_top = p_bitmap.GetBmiHeightAbs();
} rows_before_top--;
}
goto seek_to_last_row; goto seek_to_last_row;
} else if (biCompression == BI_RGB_TOPDOWN) { }
// DECOMP: This is the only condition where we skip the else if (biCompression == BI_RGB_TOPDOWN) {
// calculation below. // DECOMP: This is the only condition where we skip the
bitmap_src_ptr = p_bitmap.GetBitmapData(); // calculation below.
} else { bitmap_src_ptr = p_bitmap.GetBitmapData();
if (p_bitmap.GetBmiHeight() < 0) { }
rows_before_top = 0; else {
} else { if (p_bitmap.GetBmiHeight() < 0) {
rows_before_top = p_bitmap.GetBmiHeightAbs(); rows_before_top = 0;
rows_before_top--; }
} else {
rows_before_top = p_bitmap.GetBmiHeightAbs();
rows_before_top--;
}
// TODO: would prefer not to use goto if we can figure this structure out // TODO: would prefer not to use goto if we can figure this structure out
seek_to_last_row: seek_to_last_row:
bitmap_src_ptr = p_bitmap.GetBmiStride() * rows_before_top + p_bitmap.GetBitmapData(); bitmap_src_ptr = p_bitmap.GetBmiStride() * rows_before_top + p_bitmap.GetBitmapData();
} }
// How many bytes are there for each row of the bitmap? // How many bytes are there for each row of the bitmap?
// (i.e. the image stride) // (i.e. the image stride)
// If this is a bottom-up DIB, we will walk it in reverse. // If this is a bottom-up DIB, we will walk it in reverse.
// TODO: Same rounding trick as in MxBitmap // TODO: Same rounding trick as in MxBitmap
MxS32 row_seek = ((m_width+3)&-4); MxS32 row_seek = ((m_width + 3) & -4);
if (p_bitmap.GetBmiHeight() < 0) if (p_bitmap.GetBmiHeight() < 0)
row_seek = -row_seek; row_seek = -row_seek;
// The actual offset into the m_bitmask array. The two for-loops // The actual offset into the m_bitmask array. The two for-loops
// are just for counting the pixels. // are just for counting the pixels.
MxS32 offset = 0; MxS32 offset = 0;
MxU8 *t_ptr = bitmap_src_ptr; MxU8* t_ptr = bitmap_src_ptr;
for (MxS32 j = 0; j < m_height; j++) { for (MxS32 j = 0; j < m_height; j++) {
for (MxS32 i = 0; i < m_width; i++) { for (MxS32 i = 0; i < m_width; i++) {
if (*t_ptr) { if (*t_ptr) {
// TODO: Second CDQ instruction for abs() should not be there. // TODO: Second CDQ instruction for abs() should not be there.
MxU32 shift = abs(offset) & 7; MxU32 shift = abs(offset) & 7;
m_bitmask[offset / 8] |= (1 << abs(shift)); m_bitmask[offset / 8] |= (1 << abs((MxS32) shift));
} }
t_ptr++; t_ptr++;
offset++; offset++;
} }
// Seek to the start of the next row // Seek to the start of the next row
bitmap_src_ptr += row_seek; bitmap_src_ptr += row_seek;
t_ptr = bitmap_src_ptr; t_ptr = bitmap_src_ptr;
} }
} }
// OFFSET: LEGO1 0x100b2670 // OFFSET: LEGO1 0x100b2670
MxVideoPresenter::AlphaMask::AlphaMask(const MxVideoPresenter::AlphaMask &p_alpha) MxVideoPresenter::AlphaMask::AlphaMask(const MxVideoPresenter::AlphaMask& p_alpha)
{ {
m_width = p_alpha.m_width; m_width = p_alpha.m_width;
m_height = p_alpha.m_height; m_height = p_alpha.m_height;
MxS32 size = ((m_width * m_height) / 8) + 1; MxS32 size = ((m_width * m_height) / 8) + 1;
m_bitmask = new MxU8[size]; m_bitmask = new MxU8[size];
memcpy(m_bitmask, p_alpha.m_bitmask, size); memcpy(m_bitmask, p_alpha.m_bitmask, size);
} }
// OFFSET: LEGO1 0x100b26d0 // OFFSET: LEGO1 0x100b26d0
MxVideoPresenter::AlphaMask::~AlphaMask() MxVideoPresenter::AlphaMask::~AlphaMask()
{ {
if (m_bitmask) if (m_bitmask)
delete[] m_bitmask; delete[] m_bitmask;
} }
// OFFSET: LEGO1 0x100b26f0 // OFFSET: LEGO1 0x100b26f0
MxS32 MxVideoPresenter::AlphaMask::IsHit(MxU32 p_x, MxU32 p_y) MxS32 MxVideoPresenter::AlphaMask::IsHit(MxU32 p_x, MxU32 p_y)
{ {
if (p_x >= m_width || p_y >= m_height) if (p_x >= m_width || p_y >= m_height)
return 0; return 0;
MxS32 pos = p_y * m_width + p_x; MxS32 pos = p_y * m_width + p_x;
return m_bitmask[pos / 8] & (1 << abs(abs(pos) & 7)) ? 1 : 0; return m_bitmask[pos / 8] & (1 << abs(abs(pos) & 7)) ? 1 : 0;
} }
// OFFSET: LEGO1 0x100b2760 // OFFSET: LEGO1 0x100b2760
void MxVideoPresenter::Init() void MxVideoPresenter::Init()
{ {
m_bitmap = NULL; m_bitmap = NULL;
m_alpha = NULL; m_alpha = NULL;
m_unk5c = 1; m_unk5c = 1;
m_unk58 = NULL; m_unk58 = NULL;
m_unk60 = -1; m_unk60 = -1;
m_flags = m_flags & 0xfe; m_flags = m_flags & 0xfe;
if (MVideoManager() != NULL) { if (MVideoManager() != NULL) {
MVideoManager(); MVideoManager();
m_flags = m_flags | 2; m_flags = m_flags | 2;
m_flags = m_flags & 0xfb; m_flags = m_flags & 0xfb;
} }
m_flags = m_flags & 0xf7; m_flags = m_flags & 0xf7;
m_flags = m_flags & 0xef; m_flags = m_flags & 0xef;
} }
// OFFSET: LEGO1 0x100b27b0 // OFFSET: LEGO1 0x100b27b0
void MxVideoPresenter::Destroy(MxBool p_fromDestructor) void MxVideoPresenter::Destroy(MxBool p_fromDestructor)
{ {
if (MVideoManager() != NULL) if (MVideoManager() != NULL)
MVideoManager()->RemovePresenter(*this); MVideoManager()->RemovePresenter(*this);
if (m_unk58) { if (m_unk58) {
m_unk58->Release(); m_unk58->Release();
m_unk58 = NULL; m_unk58 = NULL;
m_flags = m_flags & 0xfd; m_flags = m_flags & 0xfd;
m_flags = m_flags & 0xfb; m_flags = m_flags & 0xfb;
} }
if (MVideoManager() && (m_alpha || m_bitmap)) { if (MVideoManager() && (m_alpha || m_bitmap)) {
MxS32 height = GetHeight(); MxS32 height = GetHeight();
MxS32 width = GetWidth(); MxS32 width = GetWidth();
MxS32 x = GetLocationX(); MxS32 x = GetLocationX();
MxS32 y = GetLocationY(); MxS32 y = GetLocationY();
MxRect32 rect(x, y, x + width, y + height); MxRect32 rect(x, y, x + width, y + height);
MVideoManager()->InvalidateRect(rect); MVideoManager()->InvalidateRect(rect);
MVideoManager()->vtable0x34(rect.m_left, rect.m_top, rect.GetWidth(), rect.GetHeight()); MVideoManager()->vtable0x34(rect.m_left, rect.m_top, rect.GetWidth(), rect.GetHeight());
} }
delete m_bitmap; delete m_bitmap;
delete m_alpha; delete m_alpha;
Init(); Init();
if (!p_fromDestructor) if (!p_fromDestructor)
MxMediaPresenter::Destroy(FALSE); MxMediaPresenter::Destroy(FALSE);
} }
// OFFSET: LEGO1 0x100b28b0 STUB // OFFSET: LEGO1 0x100b28b0 STUB
void MxVideoPresenter::VTable0x64() void MxVideoPresenter::VTable0x64()
{ {
// TODO // TODO
} }
// OFFSET: LEGO1 0x100b2900 // OFFSET: LEGO1 0x100b2900
MxBool MxVideoPresenter::IsHit(MxS32 p_x, MxS32 p_y) MxBool MxVideoPresenter::IsHit(MxS32 p_x, MxS32 p_y)
{ {
MxDSAction *action = GetAction(); MxDSAction* action = GetAction();
if ((action == NULL) || (((action->GetFlags() & MxDSAction::Flag_Bit10) == 0) && !IsEnabled()) if ((action == NULL) || (((action->GetFlags() & MxDSAction::Flag_Bit10) == 0) && !IsEnabled()) ||
|| (!m_bitmap && !m_alpha)) (!m_bitmap && !m_alpha))
return FALSE; return FALSE;
if (m_bitmap) if (m_bitmap)
return m_alpha->IsHit(p_x - GetLocationX(), p_y - GetLocationY()); return m_alpha->IsHit(p_x - GetLocationX(), p_y - GetLocationY());
MxLong heightAbs = m_bitmap->GetBmiHeightAbs();
MxLong min_x = GetLocationX();
MxLong min_y = GetLocationY();
MxLong max_y = min_y + heightAbs;
MxLong max_x = min_x + m_bitmap->GetBmiWidth();
if (p_x < min_x || p_x >= max_x || p_y < min_y || p_y >= max_y) MxLong heightAbs = m_bitmap->GetBmiHeightAbs();
return FALSE;
MxU8 *pixel; MxLong min_x = GetLocationX();
MxLong min_y = GetLocationY();
MxLong biCompression = m_bitmap->GetBmiHeader()->biCompression; MxLong max_y = min_y + heightAbs;
MxLong height = m_bitmap->GetBmiHeight(); MxLong max_x = min_x + m_bitmap->GetBmiWidth();
MxLong seek_row;
// DECOMP: Same basic layout as AlphaMask constructor
// The idea here is to again seek to the correct place in the bitmap's
// m_data buffer. The x,y args are (most likely) screen x and y, so we
// need to shift that to coordinates local to the bitmap by removing
// the MxPresenter location x and y coordinates.
if (biCompression == BI_RGB) {
if (biCompression == BI_RGB_TOPDOWN || height < 0) {
seek_row = p_y - GetLocationY();
} else {
height = height > 0 ? height : -height;
seek_row = height - p_y - 1 + GetLocationY();
}
pixel = m_bitmap->GetBmiStride() * seek_row + m_bitmap->GetBitmapData() - GetLocationX() + p_x;
} else if (biCompression == BI_RGB_TOPDOWN) {
pixel = m_bitmap->GetBitmapData();
} else {
height = height > 0 ? height : -height;
height--;
pixel = m_bitmap->GetBmiStride() * height + m_bitmap->GetBitmapData();
}
// DECOMP: m_flags is 1 byte, so no enum here if (p_x < min_x || p_x >= max_x || p_y < min_y || p_y >= max_y)
if (m_flags & 0x10) return FALSE;
return (MxBool) *pixel;
if ((GetAction()->GetFlags() & MxDSAction::Flag_Bit4) && *pixel == 0) MxU8* pixel;
return FALSE;
return TRUE; MxLong biCompression = m_bitmap->GetBmiHeader()->biCompression;
MxLong height = m_bitmap->GetBmiHeight();
MxLong seek_row;
// DECOMP: Same basic layout as AlphaMask constructor
// The idea here is to again seek to the correct place in the bitmap's
// m_data buffer. The x,y args are (most likely) screen x and y, so we
// need to shift that to coordinates local to the bitmap by removing
// the MxPresenter location x and y coordinates.
if (biCompression == BI_RGB) {
if (biCompression == BI_RGB_TOPDOWN || height < 0) {
seek_row = p_y - GetLocationY();
}
else {
height = height > 0 ? height : -height;
seek_row = height - p_y - 1 + GetLocationY();
}
pixel = m_bitmap->GetBmiStride() * seek_row + m_bitmap->GetBitmapData() - GetLocationX() + p_x;
}
else if (biCompression == BI_RGB_TOPDOWN) {
pixel = m_bitmap->GetBitmapData();
}
else {
height = height > 0 ? height : -height;
height--;
pixel = m_bitmap->GetBmiStride() * height + m_bitmap->GetBitmapData();
}
// DECOMP: m_flags is 1 byte, so no enum here
if (m_flags & 0x10)
return (MxBool) *pixel;
if ((GetAction()->GetFlags() & MxDSAction::Flag_Bit4) && *pixel == 0)
return FALSE;
return TRUE;
} }
// OFFSET: LEGO1 0x100b2a70 STUB // OFFSET: LEGO1 0x100b2a70 STUB
void MxVideoPresenter::VTable0x6c() void MxVideoPresenter::VTable0x6c()
{ {
// TODO // TODO
} }
// OFFSET: LEGO1 0x100b3300 // OFFSET: LEGO1 0x100b3300
undefined MxVideoPresenter::VTable0x74() undefined MxVideoPresenter::VTable0x74()
{ {
return 0; return 0;
} }

99
LEGO1/mxvideopresenter.h
View File

@ -1,72 +1,67 @@
#ifndef MXVIDEOPRESENTER_H #ifndef MXVIDEOPRESENTER_H
#define MXVIDEOPRESENTER_H #define MXVIDEOPRESENTER_H
#include "mxmediapresenter.h"
#include "mxbitmap.h"
#include "decomp.h" #include "decomp.h"
#include "mxbitmap.h"
#include "mxmediapresenter.h"
// VTABLE 0x100d4be8 // VTABLE 0x100d4be8
class MxVideoPresenter : public MxMediaPresenter class MxVideoPresenter : public MxMediaPresenter {
{
public: public:
MxVideoPresenter() MxVideoPresenter() { Init(); }
{
Init();
}
virtual ~MxVideoPresenter() override; // vtable+0x0 virtual ~MxVideoPresenter() override; // vtable+0x0
// OFFSET: LEGO1 0x1000c820 // OFFSET: LEGO1 0x1000c820
inline virtual const char *ClassName() const override // vtable+0x0c inline virtual const char* ClassName() const override // vtable+0x0c
{ {
// 0x100f0760 // 0x100f0760
return "MxVideoPresenter"; return "MxVideoPresenter";
} }
// OFFSET: LEGO1 0x1000c830 // OFFSET: LEGO1 0x1000c830
inline virtual MxBool IsA(const char *name) const override // vtable+0x10 inline virtual MxBool IsA(const char* name) const override // vtable+0x10
{ {
return !strcmp(name, MxVideoPresenter::ClassName()) || MxMediaPresenter::IsA(name); return !strcmp(name, MxVideoPresenter::ClassName()) || MxMediaPresenter::IsA(name);
} }
void Init(); void Init();
void Destroy(MxBool p_fromDestructor); void Destroy(MxBool p_fromDestructor);
virtual void Destroy() override; // vtable+0x38 virtual void Destroy() override; // vtable+0x38
virtual MxBool IsHit(MxS32 p_x, MxS32 p_y) override; //vtable+0x50 virtual MxBool IsHit(MxS32 p_x, MxS32 p_y) override; // vtable+0x50
virtual void VTable0x5c(undefined4 p_unknown1); // vtable+0x5c virtual void VTable0x5c(undefined4 p_unknown1); // vtable+0x5c
virtual void VTable0x60(); // vtable+0x60 virtual void VTable0x60(); // vtable+0x60
virtual void VTable0x64(); // vtable+0x64 virtual void VTable0x64(); // vtable+0x64
virtual void VTable0x68(undefined4 p_unknown1); // vtable+0x68 virtual void VTable0x68(undefined4 p_unknown1); // vtable+0x68
virtual void VTable0x6c(); // vtable+0x6c virtual void VTable0x6c(); // vtable+0x6c
virtual void VTable0x70(); // vtable+0x70 virtual void VTable0x70(); // vtable+0x70
virtual undefined VTable0x74(); // vtable+0x74 virtual undefined VTable0x74(); // vtable+0x74
virtual LPDIRECTDRAWSURFACE VTable0x78(); // vtable+0x78 virtual LPDIRECTDRAWSURFACE VTable0x78(); // vtable+0x78
virtual MxBool VTable0x7c(); // vtable+0x7c virtual MxBool VTable0x7c(); // vtable+0x7c
virtual MxS32 GetWidth(); // vtable+0x80 virtual MxS32 GetWidth(); // vtable+0x80
virtual MxS32 GetHeight(); // vtable+0x84 virtual MxS32 GetHeight(); // vtable+0x84
// SIZE 0xc // SIZE 0xc
struct AlphaMask { struct AlphaMask {
MxU8 *m_bitmask; MxU8* m_bitmask;
MxU16 m_width; MxU16 m_width;
MxU16 m_height; MxU16 m_height;
AlphaMask(const MxBitmap &); AlphaMask(const MxBitmap&);
AlphaMask(const AlphaMask &); AlphaMask(const AlphaMask&);
virtual ~AlphaMask(); virtual ~AlphaMask();
MxS32 IsHit(MxU32 p_x, MxU32 p_y); MxS32 IsHit(MxU32 p_x, MxU32 p_y);
}; };
MxBitmap *m_bitmap; MxBitmap* m_bitmap;
AlphaMask *m_alpha; AlphaMask* m_alpha;
LPDIRECTDRAWSURFACE m_unk58; LPDIRECTDRAWSURFACE m_unk58;
undefined2 m_unk5c; undefined2 m_unk5c;
unsigned char m_flags; // 0x5e unsigned char m_flags; // 0x5e
MxLong m_unk60; MxLong m_unk60;
}; };
#endif // MXVIDEOPRESENTER_H #endif // MXVIDEOPRESENTER_H