Files

303 lines
7.2 KiB
C++

#pragma once
// Win32 scalar and handle types with the widths the 40250 client was built with (32-bit Win32,
// ILP32). Scalars are fixed-width on every target; handle/pointer types stay pointer-sized and
// belong behind platform adapters. `long` itself cannot be redefined: ported code that relies on
// the 32-bit `long` uses LONG/DWORD or an explicit int32_t/uint32_t (docs/PORT-PLAN.md section 3).
#include <cstddef>
#include <cstdint>
#if defined(_WIN32)
// Windows (LLP64) already has these names with the same widths; use the SDK's so platform code
// that includes <windows.h> in the same translation unit does not conflict.
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <windows.h>
#else
typedef uint8_t BYTE;
typedef uint16_t WORD;
typedef uint32_t DWORD;
typedef int32_t LONG;
typedef uint32_t ULONG;
typedef int32_t BOOL;
typedef int32_t INT;
typedef uint32_t UINT;
typedef int16_t SHORT;
typedef uint16_t USHORT;
typedef char CHAR;
typedef uint8_t UCHAR;
typedef float FLOAT;
typedef int64_t LONGLONG;
typedef uint64_t ULONGLONG;
typedef int64_t INT64;
typedef uint64_t UINT64;
typedef uint64_t DWORD64;
typedef wchar_t WCHAR;
typedef void* LPVOID;
typedef const void* LPCVOID;
typedef void* PVOID;
typedef char* LPSTR;
typedef const char* LPCSTR;
typedef char* PSTR;
typedef const char* PCSTR;
typedef CHAR* PCHAR;
typedef BYTE* LPBYTE;
typedef BYTE* PBYTE;
typedef WORD* LPWORD;
typedef DWORD* LPDWORD;
typedef DWORD* PDWORD;
typedef LONG* LPLONG;
typedef BOOL* LPBOOL;
typedef INT* LPINT;
typedef INT* PINT;
typedef UINT* PUINT;
typedef WCHAR* LPWSTR;
typedef const WCHAR* LPCWSTR;
typedef uintptr_t SIZE_T;
typedef WORD LANGID;
typedef intptr_t INT_PTR;
typedef uintptr_t UINT_PTR;
typedef intptr_t LONG_PTR;
typedef uintptr_t ULONG_PTR;
typedef uintptr_t DWORD_PTR;
typedef uintptr_t WPARAM;
typedef intptr_t LPARAM;
typedef intptr_t LRESULT;
typedef LONG HRESULT;
#define S_OK ((HRESULT)0L)
#define S_FALSE ((HRESULT)1L)
#define E_FAIL ((HRESULT)0x80004005L)
#define E_OUTOFMEMORY ((HRESULT)0x8007000EL)
#define E_INVALIDARG ((HRESULT)0x80070057L)
#define SUCCEEDED(hr) (((HRESULT)(hr)) >= 0)
#define FAILED(hr) (((HRESULT)(hr)) < 0)
typedef void* HANDLE;
struct HWND__;
typedef HWND__* HWND;
struct HINSTANCE__;
typedef HINSTANCE__* HINSTANCE;
typedef HINSTANCE HMODULE;
struct HDC__;
typedef HDC__* HDC;
struct HBITMAP__;
typedef HBITMAP__* HBITMAP;
struct HICON__;
typedef HICON__* HICON;
typedef HICON HCURSOR;
struct HBRUSH__;
typedef HBRUSH__* HBRUSH;
struct HKL__;
typedef HKL__* HKL;
typedef LRESULT (*WNDPROC)(HWND, UINT, WPARAM, LPARAM);
typedef struct tagPOINT
{
LONG x;
LONG y;
} POINT, *PPOINT, *LPPOINT;
typedef struct tagRECT
{
LONG left;
LONG top;
LONG right;
LONG bottom;
} RECT, *PRECT, *LPRECT;
typedef struct tagSIZE
{
LONG cx;
LONG cy;
} SIZE, *PSIZE, *LPSIZE;
typedef union _LARGE_INTEGER
{
struct
{
DWORD LowPart;
LONG HighPart;
};
LONGLONG QuadPart;
} LARGE_INTEGER, *PLARGE_INTEGER;
typedef struct _GUID
{
DWORD Data1;
WORD Data2;
WORD Data3;
BYTE Data4[8];
} GUID;
// The 40250 projects build with the multi-byte character set: TCHAR and the GDI structs are the
// `A` variants.
typedef char TCHAR;
#define LF_FACESIZE 32
typedef struct tagLOGFONTA
{
LONG lfHeight;
LONG lfWidth;
LONG lfEscapement;
LONG lfOrientation;
LONG lfWeight;
BYTE lfItalic;
BYTE lfUnderline;
BYTE lfStrikeOut;
BYTE lfCharSet;
BYTE lfOutPrecision;
BYTE lfClipPrecision;
BYTE lfQuality;
BYTE lfPitchAndFamily;
CHAR lfFaceName[LF_FACESIZE];
} LOGFONTA, LOGFONT, *PLOGFONT, *LPLOGFONT;
typedef struct tagTEXTMETRICA
{
LONG tmHeight;
LONG tmAscent;
LONG tmDescent;
LONG tmInternalLeading;
LONG tmExternalLeading;
LONG tmAveCharWidth;
LONG tmMaxCharWidth;
LONG tmWeight;
LONG tmOverhang;
LONG tmDigitizedAspectX;
LONG tmDigitizedAspectY;
BYTE tmFirstChar;
BYTE tmLastChar;
BYTE tmDefaultChar;
BYTE tmBreakChar;
BYTE tmItalic;
BYTE tmUnderlined;
BYTE tmStruckOut;
BYTE tmPitchAndFamily;
BYTE tmCharSet;
} TEXTMETRICA, TEXTMETRIC, *PTEXTMETRIC, *LPTEXTMETRIC;
typedef struct tagBITMAPINFOHEADER
{
DWORD biSize;
LONG biWidth;
LONG biHeight;
WORD biPlanes;
WORD biBitCount;
DWORD biCompression;
DWORD biSizeImage;
LONG biXPelsPerMeter;
LONG biYPelsPerMeter;
DWORD biClrUsed;
DWORD biClrImportant;
} BITMAPINFOHEADER, *LPBITMAPINFOHEADER;
typedef struct tagRGBQUAD
{
BYTE rgbBlue;
BYTE rgbGreen;
BYTE rgbRed;
BYTE rgbReserved;
} RGBQUAD;
typedef struct tagBITMAPINFO
{
BITMAPINFOHEADER bmiHeader;
RGBQUAD bmiColors[1];
} BITMAPINFO, *LPBITMAPINFO;
typedef struct _OSVERSIONINFOA
{
DWORD dwOSVersionInfoSize;
DWORD dwMajorVersion;
DWORD dwMinorVersion;
DWORD dwBuildNumber;
DWORD dwPlatformId;
CHAR szCSDVersion[128];
} OSVERSIONINFOA, OSVERSIONINFO, *LPOSVERSIONINFOA, *LPOSVERSIONINFO;
struct HFONT__;
typedef HFONT__* HFONT;
#ifndef VOID
#define VOID void
#endif
#ifndef CONST
#define CONST const
#endif
#ifndef IN
#define IN
#endif
#ifndef OUT
#define OUT
#endif
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
#define CALLBACK
#define WINAPI
#define APIENTRY
#define __stdcall
#define __cdecl
#define __forceinline inline __attribute__((always_inline))
#define MAX_PATH 260
#define INFINITE 0xFFFFFFFF
#define LOBYTE(w) ((BYTE)(((DWORD_PTR)(w)) & 0xff))
#define HIBYTE(w) ((BYTE)((((DWORD_PTR)(w)) >> 8) & 0xff))
#define LOWORD(l) ((WORD)(((DWORD_PTR)(l)) & 0xffff))
#define HIWORD(l) ((WORD)((((DWORD_PTR)(l)) >> 16) & 0xffff))
#define MAKEWORD(a, b) ((WORD)(((BYTE)(((DWORD_PTR)(a)) & 0xff)) | ((WORD)((BYTE)(((DWORD_PTR)(b)) & 0xff))) << 8))
struct D3DXVECTOR2
{
float x = 0.0f;
float y = 0.0f;
D3DXVECTOR2() = default;
D3DXVECTOR2(float _x, float _y) : x(_x), y(_y) {}
};
struct D3DXCOLOR
{
float r = 0.0f, g = 0.0f, b = 0.0f, a = 0.0f;
D3DXCOLOR() = default;
D3DXCOLOR(float _r, float _g, float _b, float _a) : r(_r), g(_g), b(_b), a(_a) {}
D3DXCOLOR(DWORD dwColor)
{
a = ((dwColor >> 24) & 0xff) / 255.0f;
r = ((dwColor >> 16) & 0xff) / 255.0f;
g = ((dwColor >> 8) & 0xff) / 255.0f;
b = (dwColor & 0xff) / 255.0f;
}
operator DWORD() const
{
return ((DWORD(a * 255.0f) & 0xff) << 24) |
((DWORD(r * 255.0f) & 0xff) << 16) |
((DWORD(g * 255.0f) & 0xff) << 8) |
(DWORD(b * 255.0f) & 0xff);
}
};
#endif // _WIN32
// Widths the 40250 binary was compiled with; serialized structs depend on them.
static_assert(sizeof(BYTE) == 1 && sizeof(WORD) == 2 && sizeof(DWORD) == 4, "Win32 unsigned widths");
static_assert(sizeof(LONG) == 4 && sizeof(BOOL) == 4 && sizeof(UINT) == 4 && sizeof(INT) == 4, "Win32 signed widths");
static_assert(sizeof(SHORT) == 2 && sizeof(FLOAT) == 4, "Win32 short/float widths");
static_assert(sizeof(POINT) == 8 && sizeof(RECT) == 16, "Win32 POINT/RECT layout");
static_assert(sizeof(GUID) == 16 && sizeof(LARGE_INTEGER) == 8, "Win32 GUID/LARGE_INTEGER layout");
static_assert(sizeof(LOGFONTA) == 60 && sizeof(TEXTMETRICA) == 56, "Win32 GDI struct layout");
static_assert(sizeof(OSVERSIONINFOA) == 148, "Win32 OSVERSIONINFOA layout");
static_assert(sizeof(BITMAPINFOHEADER) == 40 && sizeof(BITMAPINFO) == 44, "Win32 DIB header layout");
static_assert(sizeof(WPARAM) == sizeof(void*) && sizeof(HANDLE) == sizeof(void*), "handles stay pointer-sized");