303 lines
7.2 KiB
C++
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");
|