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

More fixes

Browse Source
This commit is contained in:
Christian Semmler 2023-12-12 11:45:37 -05:00
parent 71335281a2
commit 7ded9d0263
26 changed files with 224 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
ISLE/isleapp.cpp
View File

@ -54,7 +54,7 @@ IsleApp::IsleApp()
m_windowActive = 1;
m_videoParam = MxVideoParam(MxRect32(0, 0, 639, 479), NULL, 1, MxVideoParamFlags());
m_videoParam.flags().Set16Bit(MxDirectDraw::GetPrimaryBitDepth() == 16);
m_videoParam.Flags().Set16Bit(MxDirectDraw::GetPrimaryBitDepth() == 16);
m_windowHandle = NULL;
m_cursorArrow = NULL;
@ -157,19 +157,19 @@ void IsleApp::SetupVideoFlags(
char* deviceId
)
{
m_videoParam.flags().SetFullScreen(fullScreen);
m_videoParam.flags().SetFlipSurfaces(flipSurfaces);
m_videoParam.flags().SetBackBuffers(!backBuffers);
m_videoParam.flags().Set_f2bit0(!param_6);
m_videoParam.flags().Set_f1bit7(param_7);
m_videoParam.flags().SetWideViewAngle(wideViewAngle);
m_videoParam.flags().Set_f2bit1(1);
m_videoParam.Flags().SetFullScreen(fullScreen);
m_videoParam.Flags().SetFlipSurfaces(flipSurfaces);
m_videoParam.Flags().SetBackBuffers(!backBuffers);
m_videoParam.Flags().SetF2bit0(!param_6);
m_videoParam.Flags().SetF1bit7(param_7);
m_videoParam.Flags().SetWideViewAngle(wideViewAngle);
m_videoParam.Flags().SetF2bit1(1);
m_videoParam.SetDeviceName(deviceId);
if (using8bit) {
m_videoParam.flags().Set16Bit(0);
m_videoParam.Flags().Set16Bit(0);
}
if (using16bit) {
m_videoParam.flags().Set16Bit(1);
m_videoParam.Flags().Set16Bit(1);
}
}

2
LEGO1/legonavcontroller.cpp
View File

@ -66,7 +66,7 @@ void LegoNavController::SetControlMax(int p_hMax, int p_vMax)
this->m_hMax = p_hMax;
this->m_vMax = p_vMax;
if (VideoManager()->GetVideoParam().flags().GetFullScreen()) {
if (VideoManager()->GetVideoParam().Flags().GetFullScreen()) {
this->m_hMax = 640;
this->m_vMax = 480;
}

16
LEGO1/mxdisplaysurface.cpp
View File

@ -70,10 +70,10 @@ MxResult MxDisplaySurface::Create(MxVideoParam& p_videoParam)
this->m_initialized = TRUE;
this->m_videoParam = p_videoParam;
if (!this->m_videoParam.flags().GetFullScreen())
this->m_videoParam.flags().SetFlipSurfaces(FALSE);
if (!this->m_videoParam.Flags().GetFullScreen())
this->m_videoParam.Flags().SetFlipSurfaces(FALSE);
if (!this->m_videoParam.flags().GetFlipSurfaces()) {
if (!this->m_videoParam.Flags().GetFlipSurfaces()) {
this->m_videoParam.SetBackBuffers(1);
}
else {
@ -84,10 +84,10 @@ MxResult MxDisplaySurface::Create(MxVideoParam& p_videoParam)
else if (backBuffers > 2)
this->m_videoParam.SetBackBuffers(2);
this->m_videoParam.flags().SetBackBuffers(TRUE);
this->m_videoParam.Flags().SetBackBuffers(TRUE);
}
if (this->m_videoParam.flags().GetFullScreen()) {
if (this->m_videoParam.Flags().GetFullScreen()) {
MxS32 width = this->m_videoParam.GetRect().GetWidth();
MxS32 height = this->m_videoParam.GetRect().GetHeight();
@ -100,7 +100,7 @@ MxResult MxDisplaySurface::Create(MxVideoParam& p_videoParam)
if (lpDirectDraw->GetDisplayMode(&ddsd))
goto done;
MxS32 bitdepth = !this->m_videoParam.flags().Get16Bit() ? 8 : 16;
MxS32 bitdepth = !this->m_videoParam.Flags().Get16Bit() ? 8 : 16;
if (ddsd.dwWidth != width || ddsd.dwHeight != height || ddsd.ddpfPixelFormat.dwRGBBitCount != bitdepth) {
if (lpDirectDraw->SetDisplayMode(width, height, bitdepth))
@ -108,7 +108,7 @@ MxResult MxDisplaySurface::Create(MxVideoParam& p_videoParam)
}
}
if (this->m_videoParam.flags().GetFlipSurfaces()) {
if (this->m_videoParam.Flags().GetFlipSurfaces()) {
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwBackBufferCount = this->m_videoParam.GetBackBuffers();
@ -139,7 +139,7 @@ MxResult MxDisplaySurface::Create(MxVideoParam& p_videoParam)
ddsd.dwHeight = this->m_videoParam.GetRect().GetHeight();
ddsd.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY | DDSCAPS_3DDEVICE | DDSCAPS_OFFSCREENPLAIN;
if (!this->m_videoParam.flags().GetBackBuffers())
if (!this->m_videoParam.Flags().GetBackBuffers())
ddsd.ddsCaps.dwCaps = DDSCAPS_3DDEVICE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_OFFSCREENPLAIN;
if (lpDirectDraw->CreateSurface(&ddsd, &this->m_ddSurface2, NULL))

2
LEGO1/mxticklemanager.h
View File

@ -21,7 +21,7 @@ class MxTickleClient {
inline void SetLastUpdateTime(MxTime p_lastUpdateTime) { m_lastUpdateTime = p_lastUpdateTime; }
inline void SetFlags(MxU16 flags) { m_flags = flags; }
inline void SetFlags(MxU16 p_flags) { m_flags = p_flags; }
private:
MxCore* m_client; // 0x0

14
LEGO1/mxtimer.cpp
View File

@ -3,10 +3,10 @@
#include <windows.h>
// GLOBAL: LEGO1 0x10101414
MxLong MxTimer::s_LastTimeCalculated = 0;
MxLong MxTimer::g_lastTimeCalculated = 0;
// GLOBAL: LEGO1 0x10101418
MxLong MxTimer::s_LastTimeTimerStarted = 0;
MxLong MxTimer::g_lastTimeTimerStarted = 0;
// FUNCTION: LEGO1 0x100ae060
MxTimer::MxTimer()
@ -14,20 +14,20 @@ MxTimer::MxTimer()
this->m_isRunning = FALSE;
m_startTime = timeGetTime();
// yeah this is somehow what the asm is
s_LastTimeCalculated = m_startTime;
g_lastTimeCalculated = m_startTime;
}
// FUNCTION: LEGO1 0x100ae140
MxLong MxTimer::GetRealTime()
{
MxTimer::s_LastTimeCalculated = timeGetTime();
return MxTimer::s_LastTimeCalculated - this->m_startTime;
MxTimer::g_lastTimeCalculated = timeGetTime();
return MxTimer::g_lastTimeCalculated - this->m_startTime;
}
// FUNCTION: LEGO1 0x100ae160
void MxTimer::Start()
{
s_LastTimeTimerStarted = this->GetRealTime();
g_lastTimeTimerStarted = this->GetRealTime();
this->m_isRunning = TRUE;
}
@ -35,7 +35,7 @@ void MxTimer::Start()
void MxTimer::Stop()
{
MxLong elapsed = this->GetRealTime();
MxLong startTime = elapsed - MxTimer::s_LastTimeTimerStarted;
MxLong startTime = elapsed - MxTimer::g_lastTimeTimerStarted;
this->m_isRunning = FALSE;
// this feels very stupid but it's what the assembly does
this->m_startTime = this->m_startTime + startTime - 5;

8
LEGO1/mxtimer.h
View File

@ -17,16 +17,16 @@ class MxTimer : public MxCore {
inline MxLong GetTime()
{
if (this->m_isRunning)
return s_LastTimeTimerStarted;
return g_lastTimeTimerStarted;
else
return s_LastTimeCalculated - this->m_startTime;
return g_lastTimeCalculated - this->m_startTime;
}
private:
MxLong m_startTime;
MxBool m_isRunning;
static MxLong s_LastTimeCalculated;
static MxLong s_LastTimeTimerStarted;
static MxLong g_lastTimeCalculated;
static MxLong g_lastTimeTimerStarted;
};
#endif // MXTIMER_H

110
LEGO1/mxtransitionmanager.cpp
View File

@ -21,8 +21,8 @@ MxTransitionManager::MxTransitionManager()
m_ddSurface = NULL;
m_waitIndicator = NULL;
m_copyBuffer = NULL;
m_copyFlags.bit0 = FALSE;
m_unk0x28.bit0 = FALSE;
m_copyFlags.m_bit0 = FALSE;
m_unk0x28.m_bit0 = FALSE;
m_unk0x24 = 0;
}
@ -58,22 +58,22 @@ MxResult MxTransitionManager::Tickle()
switch (this->m_transitionType) {
case NO_ANIMATION:
Transition_None();
TransitionNone();
break;
case DISSOLVE:
Transition_Dissolve();
TransitionDissolve();
break;
case PIXELATION:
Transition_Pixelation();
TransitionPixelation();
break;
case SCREEN_WIPE:
Transition_Wipe();
TransitionWipe();
break;
case WINDOWS:
Transition_Windows();
TransitionWindows();
break;
case BROKEN:
Transition_Broken();
TransitionBroken();
break;
}
return SUCCESS;
@ -95,9 +95,9 @@ MxResult MxTransitionManager::StartTransition(
this->m_transitionType = p_animationType;
m_copyFlags.bit0 = p_doCopy;
m_copyFlags.m_bit0 = p_doCopy;
if (m_copyFlags.bit0 && m_waitIndicator != NULL) {
if (m_copyFlags.m_bit0 && m_waitIndicator != NULL) {
m_waitIndicator->Enable(TRUE);
MxDSAction* action = m_waitIndicator->GetAction();
@ -132,7 +132,7 @@ void MxTransitionManager::EndTransition(MxBool p_notifyWorld)
if (m_transitionType != NOT_TRANSITIONING) {
m_transitionType = NOT_TRANSITIONING;
m_copyFlags.bit0 = FALSE;
m_copyFlags.m_bit0 = FALSE;
TickleManager()->UnregisterClient(this);
@ -147,7 +147,7 @@ void MxTransitionManager::EndTransition(MxBool p_notifyWorld)
}
// FUNCTION: LEGO1 0x1004bcf0
void MxTransitionManager::Transition_None()
void MxTransitionManager::TransitionNone()
{
LegoVideoManager* videoManager = VideoManager();
videoManager->GetDisplaySurface()->FUN_100ba640();
@ -155,7 +155,7 @@ void MxTransitionManager::Transition_None()
}
// FUNCTION: LEGO1 0x1004bd10
void MxTransitionManager::Transition_Dissolve()
void MxTransitionManager::TransitionDissolve()
{
// If the animation is finished
if (m_animationTimer == 40) {
@ -212,14 +212,14 @@ void MxTransitionManager::Transition_Dissolve()
// 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 x_shift = (m_randomShift[row] + col) % 640;
MxS32 xShift = (m_randomShift[row] + col) % 640;
// Set the chosen pixel to black
if (ddsd.ddpfPixelFormat.dwRGBBitCount == 8) {
((MxU8*) ddsd.lpSurface)[row * ddsd.lPitch + x_shift] = 0;
((MxU8*) ddsd.lpSurface)[row * ddsd.lPitch + xShift] = 0;
}
else {
((MxU16*) ddsd.lpSurface)[row * ddsd.lPitch + x_shift] = 0;
((MxU16*) ddsd.lpSurface)[row * ddsd.lPitch + xShift] = 0;
}
}
}
@ -227,7 +227,7 @@ void MxTransitionManager::Transition_Dissolve()
SetupCopyRect(&ddsd);
m_ddSurface->Unlock(ddsd.lpSurface);
if (VideoManager()->GetVideoParam().flags().GetFlipSurfaces()) {
if (VideoManager()->GetVideoParam().Flags().GetFlipSurfaces()) {
LPDIRECTDRAWSURFACE surf = VideoManager()->GetDisplaySurface()->GetDirectDrawSurface1();
surf->BltFast(NULL, NULL, m_ddSurface, &g_fullScreenRect, DDBLTFAST_WAIT);
}
@ -237,7 +237,7 @@ void MxTransitionManager::Transition_Dissolve()
}
// FUNCTION: LEGO1 0x1004bed0
void MxTransitionManager::Transition_Pixelation()
void MxTransitionManager::TransitionPixelation()
{
if (m_animationTimer == 16) {
m_animationTimer = 0;
@ -289,20 +289,20 @@ void MxTransitionManager::Transition_Pixelation()
continue;
for (MxS32 row = 0; row < 48; row++) {
MxS32 x_shift = 10 * ((m_randomShift[row] + col) % 64);
MxS32 xShift = 10 * ((m_randomShift[row] + col) % 64);
// To do the pixelation, we subdivide the 640x480 surface into
// 10x10 pixel blocks. At the chosen block, we sample the top-leftmost
// color and set the other 99 pixels to that value.
// Find the pixel to sample
MxS32 sample_ofs = 10 * row * ddsd.lPitch + x_shift;
MxS32 sampleOfs = 10 * row * ddsd.lPitch + xShift;
MxS32 bytesPerPixel = ddsd.ddpfPixelFormat.dwRGBBitCount / 8;
// Save this cast from void* to save time.
// Seems to help accuracy doing it this way.
MxU8* surface = (MxU8*) ddsd.lpSurface;
MxU8* source = surface + sample_ofs * bytesPerPixel;
MxU8* source = surface + sampleOfs * bytesPerPixel;
MxU32 sample = bytesPerPixel == 1 ? *source : *(MxU16*) source;
@ -310,32 +310,32 @@ void MxTransitionManager::Transition_Pixelation()
if (ddsd.ddpfPixelFormat.dwRGBBitCount == 8) {
// TODO: This block and the next don't match, but they are
// hopefully correct in principle.
MxU16 color_word = MAKEWORD(LOBYTE(sample), LOBYTE(sample));
MxU32 new_color = MAKELONG(color_word, color_word);
MxU16 colorWord = MAKEWORD(LOBYTE(sample), LOBYTE(sample));
MxU32 newColor = MAKELONG(colorWord, colorWord);
MxU8* pos = surface + k * ddsd.lPitch + x_shift;
MxU8* pos = surface + k * ddsd.lPitch + xShift;
MxU32* dest = (MxU32*) pos;
// Sets 10 pixels (10 bytes)
dest[0] = new_color;
dest[1] = new_color;
dest[0] = newColor;
dest[1] = newColor;
MxU16* half = (MxU16*) (dest + 2);
*half = new_color;
*half = newColor;
}
else {
MxU32 new_color = MAKELONG(sample, sample);
MxU32 newColor = MAKELONG(sample, sample);
// You might expect a cast to MxU16* instead, but lPitch is
// bytes/scanline, not pixels/scanline. Therefore, we just
// need to double the x_shift to get to the right spot.
MxU8* pos = surface + k * ddsd.lPitch + 2 * x_shift;
// need to double the xShift to get to the right spot.
MxU8* pos = surface + k * ddsd.lPitch + 2 * xShift;
MxU32* dest = (MxU32*) pos;
// Sets 10 pixels (20 bytes)
dest[0] = new_color;
dest[1] = new_color;
dest[2] = new_color;
dest[3] = new_color;
dest[4] = new_color;
dest[0] = newColor;
dest[1] = newColor;
dest[2] = newColor;
dest[3] = newColor;
dest[4] = newColor;
}
}
}
@ -344,7 +344,7 @@ void MxTransitionManager::Transition_Pixelation()
SetupCopyRect(&ddsd);
m_ddSurface->Unlock(ddsd.lpSurface);
if (VideoManager()->GetVideoParam().flags().GetFlipSurfaces()) {
if (VideoManager()->GetVideoParam().Flags().GetFlipSurfaces()) {
LPDIRECTDRAWSURFACE surf = VideoManager()->GetDisplaySurface()->GetDirectDrawSurface1();
surf->BltFast(NULL, NULL, m_ddSurface, &g_fullScreenRect, DDBLTFAST_WAIT);
}
@ -354,7 +354,7 @@ void MxTransitionManager::Transition_Pixelation()
}
// FUNCTION: LEGO1 0x1004c170
void MxTransitionManager::Transition_Wipe()
void MxTransitionManager::TransitionWipe()
{
// If the animation is finished
if (m_animationTimer == 240) {
@ -393,7 +393,7 @@ void MxTransitionManager::Transition_Wipe()
}
// FUNCTION: LEGO1 0x1004c270
void MxTransitionManager::Transition_Windows()
void MxTransitionManager::TransitionWindows()
{
if (m_animationTimer == 240) {
m_animationTimer = 0;
@ -439,7 +439,7 @@ void MxTransitionManager::Transition_Windows()
}
// FUNCTION: LEGO1 0x1004c3e0
void MxTransitionManager::Transition_Broken()
void MxTransitionManager::TransitionBroken()
{
// This function has no actual animation logic.
// It also never calls EndTransition to
@ -487,22 +487,22 @@ void MxTransitionManager::SetWaitIndicator(MxVideoPresenter* p_waitIndicator)
}
else {
// Disable copy rect
m_copyFlags.bit0 = FALSE;
m_copyFlags.m_bit0 = FALSE;
}
}
// FUNCTION: LEGO1 0x1004c4d0
void MxTransitionManager::SubmitCopyRect(LPDDSURFACEDESC ddsc)
void MxTransitionManager::SubmitCopyRect(LPDDSURFACEDESC p_ddsc)
{
// Check if the copy rect is setup
if (m_copyFlags.bit0 == FALSE || m_waitIndicator == NULL || m_copyBuffer == NULL) {
if (m_copyFlags.m_bit0 == FALSE || m_waitIndicator == NULL || m_copyBuffer == NULL) {
return;
}
// Copy the copy rect onto the surface
MxU8* dst;
MxU32 bytesPerPixel = ddsc->ddpfPixelFormat.dwRGBBitCount / 8;
MxU32 bytesPerPixel = p_ddsc->ddpfPixelFormat.dwRGBBitCount / 8;
const MxU8* src = (const MxU8*) m_copyBuffer;
@ -510,12 +510,12 @@ void MxTransitionManager::SubmitCopyRect(LPDDSURFACEDESC ddsc)
copyPitch = ((m_copyRect.right - m_copyRect.left) + 1) * bytesPerPixel;
MxS32 y;
dst = (MxU8*) ddsc->lpSurface + (ddsc->lPitch * m_copyRect.top) + (bytesPerPixel * m_copyRect.left);
dst = (MxU8*) p_ddsc->lpSurface + (p_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;
dst += p_ddsc->lPitch;
}
// Free the copy buffer
@ -524,10 +524,10 @@ void MxTransitionManager::SubmitCopyRect(LPDDSURFACEDESC ddsc)
}
// FUNCTION: LEGO1 0x1004c580
void MxTransitionManager::SetupCopyRect(LPDDSURFACEDESC ddsc)
void MxTransitionManager::SetupCopyRect(LPDDSURFACEDESC p_ddsc)
{
// Check if the copy rect is setup
if (m_copyFlags.bit0 == FALSE || m_waitIndicator == NULL) {
if (m_copyFlags.m_bit0 == FALSE || m_waitIndicator == NULL) {
return;
}
@ -537,9 +537,9 @@ void MxTransitionManager::SetupCopyRect(LPDDSURFACEDESC ddsc)
// Check if wait indicator has started
if (m_waitIndicator->GetCurrentTickleState() >= MxPresenter::TickleState_Streaming) {
// Setup the copy rect
MxU32 copyPitch = (ddsc->ddpfPixelFormat.dwRGBBitCount / 8) *
MxU32 copyPitch = (p_ddsc->ddpfPixelFormat.dwRGBBitCount / 8) *
(m_copyRect.right - m_copyRect.left + 1); // This uses m_copyRect, seemingly erroneously
MxU32 bytesPerPixel = ddsc->ddpfPixelFormat.dwRGBBitCount / 8;
MxU32 bytesPerPixel = p_ddsc->ddpfPixelFormat.dwRGBBitCount / 8;
m_copyRect.left = m_waitIndicator->GetLocationX();
m_copyRect.top = m_waitIndicator->GetLocationY();
@ -552,7 +552,7 @@ void MxTransitionManager::SetupCopyRect(LPDDSURFACEDESC ddsc)
// Allocate the copy buffer
const MxU8* src =
(const MxU8*) ddsc->lpSurface + m_copyRect.top * ddsc->lPitch + bytesPerPixel * m_copyRect.left;
(const MxU8*) p_ddsc->lpSurface + m_copyRect.top * p_ddsc->lPitch + bytesPerPixel * m_copyRect.left;
m_copyBuffer = new MxU8[bytesPerPixel * width * height];
if (!m_copyBuffer)
@ -563,7 +563,7 @@ void MxTransitionManager::SetupCopyRect(LPDDSURFACEDESC ddsc)
for (MxS32 i = 0; i < (m_copyRect.bottom - m_copyRect.top + 1); i++) {
memcpy(dst, src, copyPitch);
src += ddsc->lPitch;
src += p_ddsc->lPitch;
dst += copyPitch;
}
}
@ -571,9 +571,9 @@ void MxTransitionManager::SetupCopyRect(LPDDSURFACEDESC ddsc)
// Setup display surface
if ((m_waitIndicator->GetAction()->GetFlags() & MxDSAction::Flag_Bit5) != 0) {
MxDisplaySurface* displaySurface = VideoManager()->GetDisplaySurface();
MxBool unkbool = FALSE;
MxBool und = FALSE;
displaySurface->VTable0x2c(
ddsc,
p_ddsc,
m_waitIndicator->GetBitmap(),
0,
0,
@ -581,13 +581,13 @@ void MxTransitionManager::SetupCopyRect(LPDDSURFACEDESC ddsc)
m_waitIndicator->GetLocationY(),
m_waitIndicator->GetWidth(),
m_waitIndicator->GetHeight(),
unkbool
und
);
}
else {
MxDisplaySurface* displaySurface = VideoManager()->GetDisplaySurface();
displaySurface->VTable0x24(
ddsc,
p_ddsc,
m_waitIndicator->GetBitmap(),
0,
0,

20
LEGO1/mxtransitionmanager.h
View File

@ -45,23 +45,23 @@ class MxTransitionManager : public MxCore {
private:
void EndTransition(MxBool p_notifyWorld);
void Transition_None();
void Transition_Dissolve();
void Transition_Pixelation();
void Transition_Wipe();
void Transition_Windows();
void Transition_Broken();
void TransitionNone();
void TransitionDissolve();
void TransitionPixelation();
void TransitionWipe();
void TransitionWindows();
void TransitionBroken();
void SubmitCopyRect(LPDDSURFACEDESC ddsc);
void SetupCopyRect(LPDDSURFACEDESC ddsc);
void SubmitCopyRect(LPDDSURFACEDESC p_ddsc);
void SetupCopyRect(LPDDSURFACEDESC p_ddsc);
MxVideoPresenter* m_waitIndicator;
RECT m_copyRect;
MxU8* m_copyBuffer;
flag_bitfield m_copyFlags;
FlagBitfield m_copyFlags;
undefined4 m_unk0x24;
flag_bitfield m_unk0x28;
FlagBitfield m_unk0x28;
TransitionType m_transitionType;
LPDIRECTDRAWSURFACE m_ddSurface;

18
LEGO1/mxtypes.h
View File

@ -58,16 +58,16 @@ typedef MxU8 MxBool;
// 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;
MxU8 m_bit0 : 1;
MxU8 m_bit1 : 1;
MxU8 m_bit2 : 1;
MxU8 m_bit3 : 1;
MxU8 m_bit4 : 1;
MxU8 m_bit5 : 1;
MxU8 m_bit6 : 1;
MxU8 m_bit7 : 1;
};
// BYTE all; // ?
} flag_bitfield;
} FlagBitfield;
#endif // MXTYPES_H

4
LEGO1/mxvariable.cpp
View File

@ -12,9 +12,9 @@ MxString* MxVariable::GetValue()
}
// FUNCTION: LEGO1 0x1003beb0
void MxVariable::SetValue(const char* value)
void MxVariable::SetValue(const char* p_value)
{
m_value = value;
m_value = p_value;
}
// FUNCTION: LEGO1 0x1003bec0

2
LEGO1/mxvariable.h
View File

@ -21,7 +21,7 @@ class MxVariable {
m_value = p_value;
}
virtual MxString* GetValue();
virtual void SetValue(const char*);
virtual void SetValue(const char* p_value);
virtual void Destroy();
inline const MxString* GetKey() const { return &m_key; }

12
LEGO1/mxvideomanager.cpp
View File

@ -99,14 +99,14 @@ void MxVideoManager::SortPresenterList()
finished = TRUE;
for (MxU32 i = count; i != 0; i--) {
MxPresenter *p_a, *p_b;
MxPresenter *presenterA, *presenterB;
a.Next(p_a);
b.Next(p_b);
a.Next(presenterA);
b.Next(presenterB);
if (p_a->GetDisplayZ() < p_b->GetDisplayZ()) {
a.SetValue(p_b);
b.SetValue(p_a);
if (presenterA->GetDisplayZ() < presenterB->GetDisplayZ()) {
a.SetValue(presenterB);
b.SetValue(presenterA);
finished = FALSE;
}
}

12
LEGO1/mxvideoparam.cpp
View File

@ -23,13 +23,13 @@ MxVideoParam::MxVideoParam()
// FUNCTION: LEGO1 0x100beca0
MxVideoParam::MxVideoParam(
COMPAT_CONST MxRect32& p_rect,
MxPalette* p_pal,
MxPalette* p_palette,
MxULong p_backBuffers,
COMPAT_CONST MxVideoParamFlags& p_flags
)
{
this->m_rect = p_rect;
this->m_palette = p_pal;
this->m_palette = p_palette;
this->m_backBuffers = p_backBuffers;
this->m_flags = p_flags;
this->m_unk0x1c = 0;
@ -56,16 +56,16 @@ MxVideoParam::~MxVideoParam()
}
// FUNCTION: LEGO1 0x100bed70
void MxVideoParam::SetDeviceName(char* id)
void MxVideoParam::SetDeviceName(char* p_deviceId)
{
if (this->m_deviceId != NULL)
delete[] this->m_deviceId;
if (id != 0) {
this->m_deviceId = new char[strlen(id) + 1];
if (p_deviceId != NULL) {
this->m_deviceId = new char[strlen(p_deviceId) + 1];
if (this->m_deviceId != NULL) {
strcpy(this->m_deviceId, id);
strcpy(this->m_deviceId, p_deviceId);
}
}
else {

16
LEGO1/mxvideoparam.h
View File

@ -14,15 +14,19 @@
class MxVideoParam {
public:
__declspec(dllexport) MxVideoParam();
__declspec(dllexport) MxVideoParam(MxVideoParam&);
__declspec(dllexport)
MxVideoParam(COMPAT_CONST MxRect32& rect, MxPalette* pal, MxULong p3, COMPAT_CONST MxVideoParamFlags& flags);
__declspec(dllexport) MxVideoParam& operator=(const MxVideoParam&);
__declspec(dllexport) MxVideoParam(MxVideoParam& p_videoParam);
__declspec(dllexport) MxVideoParam(
COMPAT_CONST MxRect32& p_rect,
MxPalette* p_palette,
MxULong p_backBuffers,
COMPAT_CONST MxVideoParamFlags& p_flags
);
__declspec(dllexport) MxVideoParam& operator=(const MxVideoParam& p_videoParam);
__declspec(dllexport) ~MxVideoParam();
__declspec(dllexport) void SetDeviceName(char* id);
__declspec(dllexport) void SetDeviceName(char* p_deviceId);
inline MxVideoParamFlags& flags() { return m_flags; }
inline MxVideoParamFlags& Flags() { return m_flags; }
inline void SetPalette(MxPalette* p_palette) { this->m_palette = p_palette; }
inline void SetBackBuffers(MxU32 p_backBuffers) { this->m_backBuffers = p_backBuffers; }

8
LEGO1/mxvideoparamflags.cpp
View File

@ -6,10 +6,10 @@ MxVideoParamFlags::MxVideoParamFlags()
this->SetFullScreen(0);
this->SetFlipSurfaces(0);
this->SetBackBuffers(0);
this->Set_f1bit3(0);
this->Set_f1bit4(0);
this->SetF1bit3(0);
this->SetF1bit4(0);
this->Set16Bit(0);
this->SetWideViewAngle(1);
this->Set_f1bit7(1);
this->Set_f2bit1(1);
this->SetF1bit7(1);
this->SetF2bit1(1);
}

68
LEGO1/mxvideoparamflags.h
View File

@ -9,43 +9,43 @@ class MxVideoParamFlags {
public:
__declspec(dllexport) MxVideoParamFlags();
inline void SetFullScreen(BOOL e) { m_flags1.bit0 = e; }
inline void SetFlipSurfaces(BOOL e) { m_flags1.bit1 = e; }
inline void SetBackBuffers(BOOL e) { m_flags1.bit2 = e; }
inline void Set_f1bit3(BOOL e) { m_flags1.bit3 = e; }
inline void Set_f1bit4(BOOL e) { m_flags1.bit4 = e; }
inline void Set16Bit(BYTE e) { m_flags1.bit5 = e; }
inline void SetWideViewAngle(BOOL e) { m_flags1.bit6 = e; }
inline void Set_f1bit7(BOOL e) { m_flags1.bit7 = e; }
inline void Set_f2bit0(BOOL e) { m_flags2.bit0 = e; }
inline void Set_f2bit1(BOOL e) { m_flags2.bit1 = e; }
inline void Set_f2bit2(BOOL e) { m_flags2.bit2 = e; }
inline void Set_f2bit3(BOOL e) { m_flags2.bit3 = e; }
inline void Set_f2bit4(BOOL e) { m_flags2.bit4 = e; }
inline void Set_f2bit5(BOOL e) { m_flags2.bit5 = e; }
inline void Set_f2bit6(BOOL e) { m_flags2.bit6 = e; }
inline void Set_f2bit7(BOOL e) { m_flags2.bit7 = e; }
inline void SetFullScreen(BOOL p_e) { m_flags1.m_bit0 = p_e; }
inline void SetFlipSurfaces(BOOL p_e) { m_flags1.m_bit1 = p_e; }
inline void SetBackBuffers(BOOL p_e) { m_flags1.m_bit2 = p_e; }
inline void SetF1bit3(BOOL p_e) { m_flags1.m_bit3 = p_e; }
inline void SetF1bit4(BOOL p_e) { m_flags1.m_bit4 = p_e; }
inline void Set16Bit(BYTE p_e) { m_flags1.m_bit5 = p_e; }
inline void SetWideViewAngle(BOOL p_e) { m_flags1.m_bit6 = p_e; }
inline void SetF1bit7(BOOL p_e) { m_flags1.m_bit7 = p_e; }
inline void SetF2bit0(BOOL p_e) { m_flags2.m_bit0 = p_e; }
inline void SetF2bit1(BOOL p_e) { m_flags2.m_bit1 = p_e; }
inline void SetF2bit2(BOOL p_e) { m_flags2.m_bit2 = p_e; }
inline void SetF2bit3(BOOL p_e) { m_flags2.m_bit3 = p_e; }
inline void SetF2bit4(BOOL p_e) { m_flags2.m_bit4 = p_e; }
inline void SetF2bit5(BOOL p_e) { m_flags2.m_bit5 = p_e; }
inline void SetF2bit6(BOOL p_e) { m_flags2.m_bit6 = p_e; }
inline void SetF2bit7(BOOL p_e) { m_flags2.m_bit7 = p_e; }
inline BYTE GetFullScreen() { return m_flags1.bit0; }
inline BYTE GetFlipSurfaces() { return m_flags1.bit1; }
inline BYTE GetBackBuffers() { return m_flags1.bit2; }
inline BYTE Get_f1bit3() { return m_flags1.bit3; }
inline BYTE Get_f1bit4() { return m_flags1.bit4; }
inline BYTE Get16Bit() { return m_flags1.bit5; }
inline BYTE GetWideViewAngle() { return m_flags1.bit6; }
inline BYTE Get_f1bit7() { return m_flags1.bit7; }
inline BYTE Get_f2bit0() { return m_flags2.bit0; }
inline BYTE Get_f2bit1() { return m_flags2.bit1; }
inline BYTE Get_f2bit2() { return m_flags2.bit2; }
inline BYTE Get_f2bit3() { return m_flags2.bit3; }
inline BYTE Get_f2bit4() { return m_flags2.bit4; }
inline BYTE Get_f2bit5() { return m_flags2.bit5; }
inline BYTE Get_f2bit6() { return m_flags2.bit6; }
inline BYTE Get_f2bit7() { return m_flags2.bit7; }
inline BYTE GetFullScreen() { return m_flags1.m_bit0; }
inline BYTE GetFlipSurfaces() { return m_flags1.m_bit1; }
inline BYTE GetBackBuffers() { return m_flags1.m_bit2; }
inline BYTE Get_f1bit3() { return m_flags1.m_bit3; }
inline BYTE Get_f1bit4() { return m_flags1.m_bit4; }
inline BYTE Get16Bit() { return m_flags1.m_bit5; }
inline BYTE GetWideViewAngle() { return m_flags1.m_bit6; }
inline BYTE Get_f1bit7() { return m_flags1.m_bit7; }
inline BYTE Get_f2bit0() { return m_flags2.m_bit0; }
inline BYTE Get_f2bit1() { return m_flags2.m_bit1; }
inline BYTE Get_f2bit2() { return m_flags2.m_bit2; }
inline BYTE Get_f2bit3() { return m_flags2.m_bit3; }
inline BYTE Get_f2bit4() { return m_flags2.m_bit4; }
inline BYTE Get_f2bit5() { return m_flags2.m_bit5; }
inline BYTE Get_f2bit6() { return m_flags2.m_bit6; }
inline BYTE Get_f2bit7() { return m_flags2.m_bit7; }
private:
flag_bitfield m_flags1;
flag_bitfield m_flags2;
FlagBitfield m_flags1;
FlagBitfield m_flags2;
};
#endif // MXVIDEOPARAMFLAGS_H

56
LEGO1/mxvideopresenter.cpp
View File

@ -72,16 +72,16 @@ MxVideoPresenter::AlphaMask::AlphaMask(const MxBitmap& p_bitmap)
{
m_width = p_bitmap.GetBmiWidth();
// DECOMP: ECX becomes word-sized if these are not two separate actions.
MxLong _height = p_bitmap.GetBmiHeightAbs();
m_height = _height;
MxLong height = p_bitmap.GetBmiHeightAbs();
m_height = height;
MxS32 size = ((m_width * m_height) / 8) + 1;
m_bitmask = new MxU8[size];
memset(m_bitmask, 0, size);
MxU32 biCompression = p_bitmap.GetBmiHeader()->biCompression;
MxU32 rows_before_top;
MxU8* bitmap_src_ptr;
MxU32 rowsBeforeTop;
MxU8* bitmapSrcPtr;
// 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
@ -95,11 +95,11 @@ MxVideoPresenter::AlphaMask::AlphaMask(const MxBitmap& p_bitmap)
// DECOMP: I think this must be an OR. If not, the check for
// biCompression == 16 gets optimized away.
if (biCompression == BI_RGB_TOPDOWN || p_bitmap.GetBmiHeight() < 0) {
rows_before_top = 0;
rowsBeforeTop = 0;
}
else {
rows_before_top = p_bitmap.GetBmiHeightAbs();
rows_before_top--;
rowsBeforeTop = p_bitmap.GetBmiHeightAbs();
rowsBeforeTop--;
}
goto seek_to_last_row;
@ -107,48 +107,48 @@ MxVideoPresenter::AlphaMask::AlphaMask(const MxBitmap& p_bitmap)
else if (biCompression == BI_RGB_TOPDOWN) {
// DECOMP: This is the only condition where we skip the
// calculation below.
bitmap_src_ptr = p_bitmap.GetBitmapData();
bitmapSrcPtr = p_bitmap.GetBitmapData();
}
else {
if (p_bitmap.GetBmiHeight() < 0) {
rows_before_top = 0;
rowsBeforeTop = 0;
}
else {
rows_before_top = p_bitmap.GetBmiHeightAbs();
rows_before_top--;
rowsBeforeTop = p_bitmap.GetBmiHeightAbs();
rowsBeforeTop--;
}
// TODO: would prefer not to use goto if we can figure this structure out
seek_to_last_row:
bitmap_src_ptr = p_bitmap.GetBmiStride() * rows_before_top + p_bitmap.GetBitmapData();
bitmapSrcPtr = p_bitmap.GetBmiStride() * rowsBeforeTop + p_bitmap.GetBitmapData();
}
// How many bytes are there for each row of the bitmap?
// (i.e. the image stride)
// If this is a bottom-up DIB, we will walk it in reverse.
// TODO: Same rounding trick as in MxBitmap
MxS32 row_seek = ((m_width + 3) & -4);
MxS32 rowSeek = ((m_width + 3) & -4);
if (p_bitmap.GetBmiHeight() < 0)
row_seek = -row_seek;
rowSeek = -rowSeek;
// The actual offset into the m_bitmask array. The two for-loops
// are just for counting the pixels.
MxS32 offset = 0;
MxU8* t_ptr = bitmap_src_ptr;
MxU8* tPtr = bitmapSrcPtr;
for (MxS32 j = 0; j < m_height; j++) {
for (MxS32 i = 0; i < m_width; i++) {
if (*t_ptr) {
if (*tPtr) {
// TODO: Second CDQ instruction for abs() should not be there.
MxU32 shift = abs(offset) & 7;
m_bitmask[offset / 8] |= (1 << abs((MxS32) shift));
}
t_ptr++;
tPtr++;
offset++;
}
// Seek to the start of the next row
bitmap_src_ptr += row_seek;
t_ptr = bitmap_src_ptr;
bitmapSrcPtr += rowSeek;
tPtr = bitmapSrcPtr;
}
}
@ -263,20 +263,20 @@ MxBool MxVideoPresenter::IsHit(MxS32 p_x, MxS32 p_y)
MxLong heightAbs = m_bitmap->GetBmiHeightAbs();
MxLong min_x = GetLocationX();
MxLong min_y = GetLocationY();
MxLong minX = GetLocationX();
MxLong minY = GetLocationY();
MxLong max_y = min_y + heightAbs;
MxLong max_x = min_x + m_bitmap->GetBmiWidth();
MxLong maxY = minY + heightAbs;
MxLong maxX = minX + m_bitmap->GetBmiWidth();
if (p_x < min_x || p_x >= max_x || p_y < min_y || p_y >= max_y)
if (p_x < minX || p_x >= maxX || p_y < minY || p_y >= maxY)
return FALSE;
MxU8* pixel;
MxLong biCompression = m_bitmap->GetBmiHeader()->biCompression;
MxLong height = m_bitmap->GetBmiHeight();
MxLong seek_row;
MxLong seekRow;
// DECOMP: Same basic layout as AlphaMask constructor
// The idea here is to again seek to the correct place in the bitmap's
@ -285,13 +285,13 @@ MxBool MxVideoPresenter::IsHit(MxS32 p_x, MxS32 p_y)
// the MxPresenter location x and y coordinates.
if (biCompression == BI_RGB) {
if (biCompression == BI_RGB_TOPDOWN || height < 0) {
seek_row = p_y - GetLocationY();
seekRow = p_y - GetLocationY();
}
else {
height = height > 0 ? height : -height;
seek_row = height - p_y - 1 + GetLocationY();
seekRow = height - p_y - 1 + GetLocationY();
}
pixel = m_bitmap->GetBmiStride() * seek_row + m_bitmap->GetBitmapData() - GetLocationX() + p_x;
pixel = m_bitmap->GetBmiStride() * seekRow + m_bitmap->GetBitmapData() - GetLocationX() + p_x;
}
else if (biCompression == BI_RGB_TOPDOWN) {
pixel = m_bitmap->GetBitmapData();

6
LEGO1/mxwavepresenter.cpp
View File

@ -335,9 +335,9 @@ void MxWavePresenter::ParseExtra()
memcpy(extraCopy, extraData, len);
extraCopy[len] = '\0';
char t_soundValue[512];
if (KeyValueStringParse(t_soundValue, g_strSOUND, extraCopy)) {
if (!strcmpi(t_soundValue, "FALSE"))
char soundValue[512];
if (KeyValueStringParse(soundValue, g_strSOUND, extraCopy)) {
if (!strcmpi(soundValue, "FALSE"))
Enable(FALSE);
}
}

4
LEGO1/pizzamissionstate.cpp
View File

@ -4,10 +4,10 @@ DECOMP_SIZE_ASSERT(PizzaMissionStateEntry, 0x20)
DECOMP_SIZE_ASSERT(PizzaMissionState, 0xb0)
// FUNCTION: LEGO1 0x10039510
PizzaMissionStateEntry* PizzaMissionState::GetState(MxU8 id)
PizzaMissionStateEntry* PizzaMissionState::GetState(MxU8 p_id)
{
for (MxS16 i = 0; i < 5; i++)
if (m_state[i].m_id == id)
if (m_state[i].m_id == p_id)
return m_state + i;
return NULL;
}

4
LEGO1/pizzamissionstate.h
View File

@ -28,10 +28,10 @@ class PizzaMissionState : public LegoState {
return !strcmp(p_name, PizzaMissionState::ClassName()) || LegoState::IsA(p_name);
}
inline MxU16 GetColor(MxU8 id) { return GetState(id)->m_color; }
inline MxU16 GetColor(MxU8 p_id) { return GetState(p_id)->m_color; }
private:
PizzaMissionStateEntry* GetState(MxU8 id);
PizzaMissionStateEntry* GetState(MxU8 p_id);
protected:
undefined4 m_unk0x8;

4
LEGO1/racestate.cpp
View File

@ -12,12 +12,12 @@ RaceState::RaceState()
}
// FUNCTION: LEGO1 0x10016280
RaceStateEntry* RaceState::GetState(MxU8 id)
RaceStateEntry* RaceState::GetState(MxU8 p_id)
{
for (MxS16 i = 0;; i++) {
if (i >= 5)
return NULL;
if (m_state[i].m_id == id)
if (m_state[i].m_id == p_id)
return m_state + i;
}
}

4
LEGO1/racestate.h
View File

@ -30,10 +30,10 @@ class RaceState : public LegoState {
return !strcmp(p_name, RaceState::ClassName()) || LegoState::IsA(p_name);
}
inline MxU16 GetColor(MxU8 id) { return GetState(id)->m_color; }
inline MxU16 GetColor(MxU8 p_id) { return GetState(p_id)->m_color; }
private:
RaceStateEntry* GetState(MxU8 id);
RaceStateEntry* GetState(MxU8 p_id);
protected:
RaceStateEntry m_state[5];

12
LEGO1/score.cpp
View File

@ -107,9 +107,9 @@ MxLong Score::Notify(MxParam& p_param)
}
// FUNCTION: LEGO1 0x10001510
MxLong Score::FUN_10001510(MxEndActionNotificationParam& p)
MxLong Score::FUN_10001510(MxEndActionNotificationParam& p_param)
{
MxDSAction* action = p.GetAction();
MxDSAction* action = p_param.GetAction();
if (m_atom == action->GetAtomId()) {
MxU32 id = action->GetObjectId();
@ -151,12 +151,12 @@ void Score::Stop()
}
// FUNCTION: LEGO1 0x100016d0
MxLong Score::FUN_100016d0(MxType17NotificationParam& p)
MxLong Score::FUN_100016d0(MxType17NotificationParam& p_param)
{
MxS16 l = p.GetUnknown28();
MxS16 l = p_param.GetUnknown28();
if (l == 1 || p.GetUnknown20() == 4) {
switch (p.GetUnknown20()) {
if (l == 1 || p_param.GetUnknown20() == 4) {
switch (p_param.GetUnknown20()) {
case 1:
m_unk0xf8 = 2;
DeleteScript();

4
LEGO1/score.h
View File

@ -38,8 +38,8 @@ class Score : public LegoWorld {
virtual void VTable0x68(MxBool p_add) override; // vtable+68
void Paint();
MxLong FUN_10001510(MxEndActionNotificationParam& p);
MxLong FUN_100016d0(MxType17NotificationParam& p);
MxLong FUN_10001510(MxEndActionNotificationParam& p_param);
MxLong FUN_100016d0(MxType17NotificationParam& p_param);
void FillArea(MxU32 p_x, MxU32 p_y, MxS16 p_color);
protected:

4
LEGO1/towtrackmissionstate.h
View File

@ -22,9 +22,9 @@ class TowTrackMissionState : public LegoState {
return !strcmp(p_name, TowTrackMissionState::ClassName()) || LegoState::IsA(p_name);
}
inline MxU16 GetColor(MxU8 id)
inline MxU16 GetColor(MxU8 p_id)
{
switch (id) {
switch (p_id) {
case 1:
return m_color1;
case 2:

8
tools/ncc/skip.yaml
View File

@ -4,4 +4,10 @@ configureLegoModelPresenter(MxS32): 'DLL exported function'
configureLegoPartPresenter(MxS32, MxS32): 'DLL exported function'
configureLegoROI(MxS32): 'DLL exported function'
configureLegoWorldPresenter(MxS32): 'DLL exported function'
GetNoCD_SourceName(): 'DLL exported function'
GetNoCD_SourceName(): 'DLL exported function'
m_3dView: 'Allow this variable name'
m_3dManager: 'Allow this variable name'
m_16bitPal: 'Allow this variable name'
p_milliseconds: 'Probably a bug with function call'
m_increaseAmount: "Can't currently detect member in union"
m_increaseFactor: "Can't currently detect member in union"