debug.cpp

Go to the documentation of this file.

/*
 *  Win32 developer overlay console.
 *
 *  Retail object 0x45AC50-0x45B7DF (link order; see docs/ORDER.md).
 */
#include "game.h"
 
#include <stdarg.h>
 
int g_nDebugOverlayConsoleCount = 0; /* 0x0049cb24 */
DWORD g_dwDebugOverlayKey = 0; /* 0x0049cb28 */
DWORD g_dwDebugOverlayKeyLatch = 0; /* 0x0049cb2c */
HHOOK g_hDebugKeyboardHook = 0; /* 0x0049cb30 */
 
#pragma function(memcpy, memset, strcpy)
/* Function start: 0x45AC50 */
DebugOverlayConsole::DebugOverlayConsole(HINSTANCE module,
                                         HWND targetWindow,
                                         int columnCount,
                                         int rowCount,
                                         int waitMode)
{
    TEXTMETRICA textMetrics;
    HDC dc;
    HGDIOBJ font;
 
    busyWait = waitMode;
    g_nDebugOverlayConsoleCount++;
    window = targetWindow;
    columns = columnCount;
    rows = rowCount;
    cursorRow = 0;
    cursorColumn = cursorRow;
    textBuffer = (char *)malloc(rows * columns);
    dirtyLines = (char *)malloc(rows);
    memset(textBuffer, ' ', rows * columns);
    memset(dirtyLines, 1, rows);
 
    dc = GetDC(window);
    font = CreateFontA(10, 10, 0, 0, 400, 0, 0, 0, 0, 2, 0, 0,
                       0x30, "Courier");
    SelectObject(dc, font);
    textColor = 0xffffff;
    backgroundColor = 0;
    backgroundMode = OPAQUE;
    GetTextMetricsA(dc, &textMetrics);
    SetTextColor(dc, 0xffffff);
    SetBkColor(dc, 0);
    ReleaseDC(window, dc);
    characterWidth = textMetrics.tmMaxCharWidth;
    characterHeight = textMetrics.tmHeight;
 
    if (g_hDebugKeyboardHook == 0) {
        g_hDebugKeyboardHook =
            SetWindowsHookExA(WH_KEYBOARD, (HOOKPROC)DebugKeyboardHookProc,
                              module, 0);
    }
    reverseVideo = 0;
    mutex = CreateMutexA(0, FALSE, 0);
    spinnerIndex = 0;
    animationState = 1;
    spinnerCharacters = (char *)malloc(5);
    strcpy(spinnerCharacters, "-\\|/");
}
 
/* Function start: 0x45AE6C */
DebugOverlayConsole::~DebugOverlayConsole(void)
{
    int shutdownKey;
 
    animationState = 2;
    shutdownKey = 0x103;
    if (--g_nDebugOverlayConsoleCount == 0) {
        UnhookWindowsHookEx(g_hDebugKeyboardHook);
    }
    free(textBuffer);
    free(dirtyLines);
    free(spinnerCharacters);
    (void)shutdownKey;
    return;
}
 
#pragma function(strlen)
/* Function start: 0x45AEE4 */
extern "C" DWORD WINAPI DebugOverlayWorkerProc(void *parameter)
{
    int done;
    DebugOverlayConsole *context;
    /* Retail compares against this stack slot before its first assignment. */
    int lastTick;
    DWORD waited;
    HDC dc;
 
    context = (DebugOverlayConsole *)parameter;
    done = 0;
    while (done == 0) {
        if (context->animationState == 2)
            break;
        if ((int)timeGetTime() > lastTick + 500) {
            waited = WaitForSingleObject(context->mutex, 500);
            if (waited == WAIT_FAILED) {
                ExitThread(1);
            } else if (waited == WAIT_TIMEOUT) {
                continue;
            }
            if (context->animationState != 0) {
                dc = GetDC(context->window);
                TextOutA(dc,
                         context->characterWidth * context->cursorColumn,
                         context->characterHeight * context->cursorRow,
                         context->spinnerCharacters + context->spinnerIndex,
                         1);
                context->spinnerIndex++;
                if ((int)strlen(context->spinnerCharacters) ==
                    context->spinnerIndex) {
                    context->spinnerIndex = 0;
                }
                ReleaseDC(context->window, dc);
            }
            ReleaseMutex(context->mutex);
            lastTick = timeGetTime();
        }
    }
    ExitThread(0);
    return 0;
}
 
/* Function start: 0x45B04E */
extern "C" LRESULT CALLBACK DebugKeyboardHookProc(int code, WPARAM key,
                                                    LPARAM flags)
{
    if (code < 0)
        return CallNextHookEx(g_hDebugKeyboardHook,
                              code, key, flags);
    if ((flags & 0x40000000) != 0) {
        g_dwDebugOverlayKey = key;
        g_dwDebugOverlayKeyLatch = g_dwDebugOverlayKey;
    }
    return CallNextHookEx(g_hDebugKeyboardHook,
                          code, key, flags);
}
 
WINBASEAPI BOOL WINAPI Beep(DWORD frequency, DWORD duration);
 
#pragma function(strcpy, strlen)
/* Function start: 0x45B0BB */
extern "C" void DebugOverlayPrintf(DebugOverlayConsole *console,
                                     const char *format, ...)
{
    int position;
    int length;
    va_list arguments;
 
    va_start(arguments, format);
    if (format != 0)
        vsprintf(console->formatBuffer, format, arguments);
    else
        strcpy(console->formatBuffer, "\n");
    va_end(arguments);
    length = strlen(console->formatBuffer);
    for (position = 0; length > position; position++) {
        console->dirtyLines[console->cursorRow] = 1;
        if (console->formatBuffer[position] >= ' ' &&
            console->formatBuffer[position] <= '~') {
            console->textBuffer[console->cursorRow * console->columns +
                                console->cursorColumn] =
                console->formatBuffer[position];
            console->cursorColumn++;
            if (console->cursorColumn == console->columns) {
                console->cursorColumn = 0;
                console->cursorRow++;
                if (console->rows == console->cursorRow)
                    console->Scroll();
            }
        } else {
            switch (console->formatBuffer[position]) {
            case '\n':
            case '\r':
                console->cursorColumn = 0;
                console->cursorRow++;
                if (console->rows == console->cursorRow)
                    console->Scroll();
                break;
            case '\a':
                Beep(0, 0);
                break;
            case '\b':
                console->cursorColumn--;
                if (console->cursorColumn < 0) {
                    console->cursorColumn = 0;
                    console->cursorRow--;
                    if (console->cursorRow < 0)
                        console->cursorRow = 0;
                }
                console->textBuffer[
                    console->cursorRow * console->columns +
                    console->cursorColumn] = ' ';
                break;
            }
        }
    }
    console->DrawPendingLines();
}
 
#pragma intrinsic(strcpy, strlen)
/* Function start: 0x45B2E0 */
void DebugOverlayConsole::Clear(void)
{
    cursorRow = 0;
    cursorColumn = cursorRow;
    memset(textBuffer, ' ', rows * columns);
    memset(dirtyLines, 1, rows);
    return;
}
 
/* Function start: 0x45B348 */
void DebugOverlayConsole::Scroll(void)
{
    memmove(textBuffer, columns + textBuffer, (rows - 1) * columns);
    cursorRow = rows - 1;
    memset((rows - 1) * columns + textBuffer, ' ', columns);
    memset(dirtyLines, 1, rows);
    return;
}
 
/* Function start: 0x45B3DC */
void DebugOverlayConsole::DrawPendingLines(void)
{
    HDC deviceContext;
    int rowIndex;
 
    deviceContext = GetDC(window);
    for (rowIndex = 0; rows > rowIndex; rowIndex++) {
        if (dirtyLines[rowIndex] != 0) {
            TextOutA(deviceContext, 0, characterHeight * rowIndex,
                     columns * rowIndex + textBuffer, columns);
        }
    }
    ReleaseDC(window, deviceContext);
    memset(dirtyLines, 0, rows);
    return;
}
 
/* Function start: 0x45B49C */
char DebugOverlayConsole::WaitForKey(void)
{
    MSG message;
    DWORD key;
 
    if (busyWait == 0) {
        while (g_dwDebugOverlayKey == 0) {
            while (PeekMessageA(&message, 0, 0, 0, 0) != 0) {
                if (message.message == WM_QUIT)
                    return 0;
                if (GetMessageA(&message, 0, 0, 0) != 0) {
                    TranslateMessage(&message);
                    DispatchMessageA(&message);
                }
            }
        }
    } else {
        while (g_dwDebugOverlayKey == 0) {
        }
    }
    key = g_dwDebugOverlayKey;
    g_dwDebugOverlayKey = 0;
    return (char)key;
}
 
/* Function start: 0x45B55C */
void DebugOverlayConsole::EnableReverseVideo(void)
{
    HDC deviceContext;
 
    if (reverseVideo == 0) {
        deviceContext = GetDC(window);
        SetBkColor(deviceContext, textColor);
        SetTextColor(deviceContext, backgroundColor);
        reverseVideo = 1;
        ReleaseDC(window, deviceContext);
    }
}
 
/* Function start: 0x45B5D8 */
void DebugOverlayConsole::DisableReverseVideo(void)
{
    HDC deviceContext;
 
    if (reverseVideo != 0) {
        deviceContext = GetDC(window);
        SetTextColor(deviceContext, textColor);
        SetBkColor(deviceContext, backgroundColor);
        reverseVideo = 0;
        ReleaseDC(window, deviceContext);
    }
}
 
WINUSERAPI HDC WINAPI GetDC(HWND window);
WINGDIAPI COLORREF WINAPI SetTextColor(HDC deviceContext, COLORREF colour);
WINGDIAPI int WINAPI SetBkMode(HDC deviceContext, int mode);
WINGDIAPI BOOL WINAPI TextOutA(HDC deviceContext, int x, int y, LPCSTR text,
                               int length);
 
/* Function start: 0x45B654 */
void DebugOverlayConsole::SetOverlayTextColor(int red, int green, int blue)
{
    HDC deviceContext;
 
    deviceContext = GetDC(window);
    textColor = (green << 8) + (blue << 16) + red;
    SetTextColor(deviceContext, textColor);
    ReleaseDC(window, deviceContext);
}
 
WINGDIAPI COLORREF WINAPI SetBkColor(HDC deviceContext, COLORREF colour);
WINUSERAPI int WINAPI ReleaseDC(HWND window, HDC deviceContext);
 
/* Function start: 0x45B6BB */
void DebugOverlayConsole::SetOverlayBackgroundColor(int red, int green,
                                                    int blue)
{
    HDC deviceContext;
 
    deviceContext = GetDC(window);
    backgroundColor = (blue << 16) + (green << 8) + red;
    SetBkColor(deviceContext, backgroundColor);
    ReleaseDC(window, deviceContext);
}
 
/* Function start: 0x45B722 */
void DebugOverlayConsole::SetTransparentBackground(void)
{
    HDC deviceContext;
 
    backgroundMode = TRANSPARENT;
    deviceContext = GetDC(window);
    SetBkMode(deviceContext, backgroundMode);
    ReleaseDC(window, deviceContext);
}
 
/* Function start: 0x45B77A */
/* Nothing in the shipped executable calls this. */
void DebugOverlayConsole::SetOpaqueBackground(void)
{
    HDC deviceContext;
 
    backgroundMode = OPAQUE;
    deviceContext = GetDC(window);
    SetBkMode(deviceContext, backgroundMode);
    ReleaseDC(window, deviceContext);
}