Files
wowdecomp/Engine/Source/Os/Win32/Input.cpp
T
SatyandClaude Opus 5.5 720e730823 Engine no longer depends on WoW/Source
- MOUSEBUTTON/MOUSEMODE move to Engine/Source/Event/Types.h (WoW/Source/Console/Types.h
  removed; COLOR_T is in ConsoleBase/Types.h).
- CRange and CBoundingBox move to Tempest (CRange.h, CBoundingBox.h); World.h includes them.
- TEXTURECACHE moves to Gxu/GxuFontMiscClasses.h (its code is in the Gxu font range,
  0x6C8E70+); CACHEENTRY stays in WoW/Common/TextureCache.h.
- CGxDevice.h, CGxFont.h, M2Model.h, Event and Os drop their WoW includes.
Build clean on Win32/x64 (known Wow.exe link gaps only); verify unchanged.

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
2026-09-26 19:20:38 +02:00

1658 lines
46 KiB
C++

#if defined(WOWDECOMP_ARCH_32)
#include <cstdint>
#include <windows.h>
#include <imm.h>
#include <malloc.h>
#include "Engine/Source/Event/Types.h"
#include "Engine/Source/Os/Gui.h"
#include "Engine/Source/Os/Input.h"
#include "Engine/Source/Os/Joystick.h"
#include "Engine/Source/Os/TimeManager.h"
#include "Engine/Source/Storm/H/storm.h"
#include "Engine/Source/Tempest/C2iVector.h"
#define WM_POPUPSYSTEMMENU 0x313
// STATIC: 0x00B1C228
static uint32_t s_latin1lookup[32] = {
0xFFFE, 0xFFFE, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0xFFFE, 0xFFFE, 0x0178,
};
// STATIC: 0x00B1C2A8
static uint32_t s_latin2lookup[256] = {
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
0x20AC, 0xFFFE, 0x201A, 0xFFFE, 0x201E, 0x2026, 0x2020, 0x2021,
0xFFFE, 0x2030, 0x0160, 0x2039, 0x015A, 0x0164, 0x017D, 0x0179,
0xFFFE, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
0xFFFE, 0x2122, 0x0161, 0x203A, 0x015B, 0x0165, 0x017E, 0x017A,
0x00A0, 0x02C7, 0x02D8, 0x0141, 0x00A4, 0x0104, 0x00A6, 0x00A7,
0x00A8, 0x00A9, 0x015E, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x017B,
0x00B0, 0x00B1, 0x02DB, 0x0142, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
0x00B8, 0x0105, 0x015F, 0x00BB, 0x013D, 0x02DD, 0x013E, 0x017C,
0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9,
};
// STATIC: 0x00B1C6A8
static uint32_t s_cyrilliclookup[256] = {
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021,
0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F,
0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
0x0020, 0x2122, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F,
0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7,
0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407,
0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7,
0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
};
// STATIC: 0x00B1CAA8
static uint32_t s_latin5lookup[256] = {
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
0x20AC, 0x0020, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x0020, 0x0020, 0x0020,
0x0020, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x0020, 0x0020, 0x0178,
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0130, 0x015E, 0x00DF,
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF,
};
// STATIC: 0x00B1CEA8
static uint32_t s_thailookup[256] = {
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
0x20AC, 0x0020, 0x0020, 0x0020, 0x0020, 0x2026, 0x0020, 0x0020,
0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
0x0020, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
0x00A0, 0x0E01, 0x0E02, 0x0E03, 0x0E04, 0x0E05, 0x0E06, 0x0E07,
0x0E08, 0x0E09, 0x0E0A, 0x0E0B, 0x0E0C, 0x0E0D, 0x0E0E, 0x0E0F,
0x0E10, 0x0E11, 0x0E12, 0x0E13, 0x0E14, 0x0E15, 0x0E16, 0x0E17,
0x0E18, 0x0E19, 0x0E1A, 0x0E1B, 0x0E1C, 0x0E1D, 0x0E1E, 0x0E1F,
0x0E20, 0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25, 0x0E26, 0x0E27,
0x0E28, 0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E, 0x0E2F,
0x0E30, 0x0E31, 0x0E32, 0x0E33, 0x0E34, 0x0E35, 0x0E36, 0x0E37,
0x0E38, 0x0E39, 0x0E3A, 0x0020, 0x0020, 0x0020, 0x0020, 0x0E3F,
0x0E40, 0x0E41, 0x0E42, 0x0E43, 0x0E44, 0x0E45, 0x0E46, 0x0E47,
0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C, 0x0E4D, 0x0E4E, 0x0E4F,
0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57,
0x0E58, 0x0E59, 0x0E5A, 0x0E5B, 0x0020, 0x0020, 0x0020, 0x0020,
};
// STATIC: 0x00B1C220
static int32_t s_appActive = 1;
// STATIC: 0x00B1D2A8
static uint32_t s_rshiftScanCode = 0x100;
// STATIC: 0x00D413D0
static int16_t s_numLockState;
// STATIC: 0x00D413D4
static RECT s_dragRect;
// STATIC: 0x00D413E4
static C2iVector s_dragStart;
// STATIC: 0x00D413EC
static C2iVector s_centerMousePos;
// STATIC: 0x00D413F4
static HWND s_mouseWnd;
// STATIC: 0x00D413F8
static C2iVector s_mousePos;
// STATIC: 0x00D41400
static int32_t s_queueHead;
// STATIC: 0x00D41404
static int32_t s_queueTail;
// STATIC: 0x00D41408
static OSEVENT s_queue[16];
// STATIC: 0x00D41548
static int32_t s_mouseSpeed;
// STATIC: 0x00D4154C
static int32_t s_savedMouseSpeed;
// STATIC: 0x00D41550
static int32_t s_releasingCapture;
// STATIC: 0x00D41554
static uint32_t s_osButtonState;
// STATIC: 0x00D41558
static RECT s_defaultWindowRect;
// STATIC: 0x00D41568
static intptr_t s_windowSize;
// STATIC: 0x00D4156C
static OS_MOUSE_MODE s_osMouseMode;
// STATIC: 0x00D41570
static int32_t s_dragHitTest;
// STATIC: 0x00D41574
static int32_t s_dragging;
// STATIC: 0x00D41578
static int32_t s_dragCancel;
// STATIC: 0x00D4157C
static uint32_t s_codePage;
// STATIC: 0x00D41580
static int32_t s_WindowResizeLock;
// STATIC: 0x00D41584
static intptr_t (*s_chainWindowProc)(void* window, uint32_t message, uintptr_t wparam, intptr_t lparam);
// STATIC: 0x00D41588
static uint32_t s_extraButtonState;
// STATIC: 0x00D4158C
static void (*s_eventPollProc)();
// STATIC: 0x00D41590
static BOOL (WINAPI* s_getPhysicalCursorPos)(POINT* point);
// STATIC: 0x00D41594
static BOOL (WINAPI* s_setPhysicalCursorPos)(int32_t x, int32_t y);
// STATIC: 0x00D41598
static void (WINAPI* s_logicalToPhysicalPoint)(HWND hwnd, POINT* point);
// VERIFY: e59d4ab5 auto
// OFFSET: 0x00868C10
static BOOL OsGetPhysicalCursorPos(POINT* point) {
if (!s_getPhysicalCursorPos) {
HMODULE user32 = LoadLibraryA("user32.dll");
if (user32) {
s_getPhysicalCursorPos = reinterpret_cast<decltype(s_getPhysicalCursorPos)>(GetProcAddress(user32, "GetPhysicalCursorPos"));
if (!s_getPhysicalCursorPos) {
s_getPhysicalCursorPos = reinterpret_cast<decltype(s_getPhysicalCursorPos)>(GetProcAddress(user32, "GetCursorPos"));
}
FreeLibrary(user32);
}
if (!s_getPhysicalCursorPos) {
return FALSE;
}
}
return s_getPhysicalCursorPos(point);
}
// VERIFY: 4c15d9db auto
// OFFSET: 0x00868C70
static BOOL OsSetPhysicalCursorPos(int32_t x, int32_t y) {
if (!s_setPhysicalCursorPos) {
HMODULE user32 = LoadLibraryA("user32.dll");
if (user32) {
s_setPhysicalCursorPos = reinterpret_cast<decltype(s_setPhysicalCursorPos)>(GetProcAddress(user32, "SetPhysicalCursorPos"));
if (!s_setPhysicalCursorPos) {
s_setPhysicalCursorPos = reinterpret_cast<decltype(s_setPhysicalCursorPos)>(GetProcAddress(user32, "SetCursorPos"));
}
FreeLibrary(user32);
}
if (!s_setPhysicalCursorPos) {
return FALSE;
}
}
return s_setPhysicalCursorPos(x, y);
}
static void WINAPI LogicalToPhysicalPointNop(HWND hwnd, POINT* point) {
}
// VERIFY: 521ae11a auto
// OFFSET: 0x00868CE0
static void OsLogicalToPhysicalPoint(HWND hwnd, POINT* point) {
if (!s_logicalToPhysicalPoint) {
HMODULE user32 = LoadLibraryA("user32.dll");
if (user32) {
s_logicalToPhysicalPoint = reinterpret_cast<decltype(s_logicalToPhysicalPoint)>(GetProcAddress(user32, "LogicalToPhysicalPoint"));
FreeLibrary(user32);
}
if (!s_logicalToPhysicalPoint) {
s_logicalToPhysicalPoint = LogicalToPhysicalPointNop;
}
}
s_logicalToPhysicalPoint(hwnd, point);
}
// VERIFY: a463d7ac manual
// OFFSET: 0x00868D40
void OsQueuePut(OSINPUT id, int32_t param0, int32_t param1, int32_t param2, int32_t param3) {
int32_t next = s_queueTail == 15 ? 0 : s_queueTail + 1;
if (next == s_queueHead) {
s_queueHead = s_queueHead == 15 ? 0 : s_queueHead + 1;
}
OSEVENT& event = s_queue[s_queueTail];
event.id = id;
event.param[0] = param0;
event.param[1] = param1;
event.param[2] = param2;
event.param[3] = OsGetAsyncTimeMs();
s_queueTail = next;
}
// VERIFY: 75299399 manual
// OFFSET: 0x00868DB0
int32_t OsQueueGet(OSINPUT* id, int32_t* param0, int32_t* param1, int32_t* param2, int32_t* param3) {
if (s_queueHead == s_queueTail) {
return 0;
}
OSEVENT& event = s_queue[s_queueHead];
*id = event.id;
*param0 = event.param[0];
*param1 = event.param[1];
*param2 = event.param[2];
*param3 = event.param[3];
s_queueHead = s_queueHead == 15 ? 0 : s_queueHead + 1;
return 1;
}
// VERIFY: 5830d143 manual
// OFFSET: 0x00868E30
static int32_t ConvertKeyCode(uint32_t vkey, KEY* key) {
if (vkey >= VK_F1 && vkey <= VK_F12) {
*key = static_cast<KEY>(vkey + (KEY_F1 - VK_F1));
return 1;
}
if (vkey >= '0' && vkey <= '9') {
*key = static_cast<KEY>(vkey);
return 1;
}
switch (vkey) {
case VK_LSHIFT:
*key = KEY_LSHIFT;
return 1;
case VK_RSHIFT:
*key = KEY_RSHIFT;
return 1;
case VK_LCONTROL:
*key = KEY_LCONTROL;
return 1;
case VK_RCONTROL:
*key = KEY_RCONTROL;
return 1;
case VK_LMENU:
*key = KEY_LALT;
return 1;
case VK_RMENU:
*key = KEY_RALT;
return 1;
case VK_ESCAPE:
*key = KEY_ESCAPE;
return 1;
case VK_RETURN:
*key = KEY_ENTER;
return 1;
case VK_BACK:
*key = KEY_BACKSPACE;
return 1;
case VK_TAB:
*key = KEY_TAB;
return 1;
case VK_LEFT:
*key = KEY_LEFT;
return 1;
case VK_UP:
*key = KEY_UP;
return 1;
case VK_RIGHT:
*key = KEY_RIGHT;
return 1;
case VK_DOWN:
*key = KEY_DOWN;
return 1;
case VK_INSERT:
*key = KEY_INSERT;
return 1;
case VK_DELETE:
*key = KEY_DELETE;
return 1;
case VK_HOME:
*key = KEY_HOME;
return 1;
case VK_END:
*key = KEY_END;
return 1;
case VK_PRIOR:
*key = KEY_PAGEUP;
return 1;
case VK_NEXT:
*key = KEY_PAGEDOWN;
return 1;
case VK_CAPITAL:
*key = KEY_CAPSLOCK;
return 1;
case VK_NUMLOCK:
*key = KEY_NUMLOCK;
return 1;
case VK_SCROLL:
*key = KEY_SCROLLLOCK;
return 1;
case VK_PAUSE:
*key = KEY_PAUSE;
return 1;
case VK_SNAPSHOT:
*key = KEY_PRINTSCREEN;
return 1;
case VK_SPACE:
*key = KEY_SPACE;
return 1;
case VK_NUMPAD0:
*key = KEY_NUMPAD0;
return 1;
case VK_NUMPAD1:
*key = KEY_NUMPAD1;
return 1;
case VK_NUMPAD2:
*key = KEY_NUMPAD2;
return 1;
case VK_NUMPAD3:
*key = KEY_NUMPAD3;
return 1;
case VK_NUMPAD4:
*key = KEY_NUMPAD4;
return 1;
case VK_NUMPAD5:
*key = KEY_NUMPAD5;
return 1;
case VK_NUMPAD6:
*key = KEY_NUMPAD6;
return 1;
case VK_NUMPAD7:
*key = KEY_NUMPAD7;
return 1;
case VK_NUMPAD8:
*key = KEY_NUMPAD8;
return 1;
case VK_NUMPAD9:
*key = KEY_NUMPAD9;
return 1;
case VK_ADD:
*key = KEY_NUMPAD_PLUS;
return 1;
case VK_SUBTRACT:
*key = KEY_NUMPAD_MINUS;
return 1;
case VK_MULTIPLY:
*key = KEY_NUMPAD_MULTIPLY;
return 1;
case VK_DIVIDE:
*key = KEY_NUMPAD_DIVIDE;
return 1;
case VK_DECIMAL:
*key = KEY_NUMPAD_DECIMAL;
return 1;
default: {
uint32_t ch = MapVirtualKeyA(vkey, MAPVK_VK_TO_CHAR) & 0xFFFF;
*key = static_cast<KEY>(ch);
if (ch == 0 || ch > 0xFF) {
return 0;
}
return 1;
}
}
}
// VERIFY: 2daef69c manual
// OFFSET: 0x008691C0
static int32_t ConvertKeyToVirtualKey(KEY key, uint32_t* vkey) {
if (key >= KEY_F1 && key <= KEY_F12) {
*vkey = key - (KEY_F1 - VK_F1);
return 1;
}
if (key >= KEY_0 && key <= KEY_9) {
*vkey = key;
return 1;
}
switch (key) {
case KEY_LSHIFT:
*vkey = VK_LSHIFT;
return 1;
case KEY_RSHIFT:
*vkey = VK_RSHIFT;
return 1;
case KEY_LCONTROL:
*vkey = VK_LCONTROL;
return 1;
case KEY_RCONTROL:
*vkey = VK_RCONTROL;
return 1;
case KEY_LALT:
*vkey = VK_LMENU;
return 1;
case KEY_RALT:
*vkey = VK_RMENU;
return 1;
case KEY_SPACE:
*vkey = VK_SPACE;
return 1;
case KEY_NUMPAD0:
*vkey = VK_NUMPAD0;
return 1;
case KEY_NUMPAD1:
*vkey = VK_NUMPAD1;
return 1;
case KEY_NUMPAD2:
*vkey = VK_NUMPAD2;
return 1;
case KEY_NUMPAD3:
*vkey = VK_NUMPAD3;
return 1;
case KEY_NUMPAD4:
*vkey = VK_NUMPAD4;
return 1;
case KEY_NUMPAD5:
*vkey = VK_NUMPAD5;
return 1;
case KEY_NUMPAD6:
*vkey = VK_NUMPAD6;
return 1;
case KEY_NUMPAD7:
*vkey = VK_NUMPAD7;
return 1;
case KEY_NUMPAD8:
*vkey = VK_NUMPAD8;
return 1;
case KEY_NUMPAD9:
*vkey = VK_NUMPAD9;
return 1;
case KEY_NUMPAD_PLUS:
*vkey = VK_ADD;
return 1;
case KEY_NUMPAD_MINUS:
*vkey = VK_SUBTRACT;
return 1;
case KEY_NUMPAD_MULTIPLY:
*vkey = VK_MULTIPLY;
return 1;
case KEY_NUMPAD_DIVIDE:
*vkey = VK_DIVIDE;
return 1;
case KEY_NUMPAD_DECIMAL:
*vkey = VK_DECIMAL;
return 1;
case KEY_ESCAPE:
*vkey = VK_ESCAPE;
return 1;
case KEY_ENTER:
*vkey = VK_RETURN;
return 1;
case KEY_BACKSPACE:
*vkey = VK_BACK;
return 1;
case KEY_TAB:
*vkey = VK_TAB;
return 1;
case KEY_LEFT:
*vkey = VK_LEFT;
return 1;
case KEY_UP:
*vkey = VK_UP;
return 1;
case KEY_RIGHT:
*vkey = VK_RIGHT;
return 1;
case KEY_DOWN:
*vkey = VK_DOWN;
return 1;
case KEY_INSERT:
*vkey = VK_INSERT;
return 1;
case KEY_DELETE:
*vkey = VK_DELETE;
return 1;
case KEY_HOME:
*vkey = VK_HOME;
return 1;
case KEY_END:
*vkey = VK_END;
return 1;
case KEY_PAGEUP:
*vkey = VK_PRIOR;
return 1;
case KEY_PAGEDOWN:
*vkey = VK_NEXT;
return 1;
case KEY_CAPSLOCK:
*vkey = VK_CAPITAL;
return 1;
case KEY_NUMLOCK:
*vkey = VK_NUMLOCK;
return 1;
case KEY_SCROLLLOCK:
*vkey = VK_SCROLL;
return 1;
case KEY_PAUSE:
*vkey = VK_PAUSE;
return 1;
case KEY_PRINTSCREEN:
*vkey = VK_SNAPSHOT;
return 1;
default: {
uint32_t vk = VkKeyScanA(static_cast<CHAR>(key)) & 0xFF;
*vkey = vk;
if (vk == 0 || vk > 0xFF) {
return 0;
}
return 1;
}
}
}
// VERIFY: 4f2eb8e2 manual
// OFFSET: 0x008694E0
static int32_t ConvertButton(uint32_t message, uintptr_t wparam, MOUSEBUTTON* button) {
switch (message) {
case WM_NCLBUTTONDOWN:
case WM_NCLBUTTONUP:
case WM_NCLBUTTONDBLCLK:
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
*button = MOUSE_BUTTON_LEFT;
return 1;
case WM_NCRBUTTONDOWN:
case WM_NCRBUTTONUP:
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
*button = MOUSE_BUTTON_RIGHT;
return 1;
case WM_NCMBUTTONDOWN:
case WM_NCMBUTTONUP:
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
*button = MOUSE_BUTTON_MIDDLE;
return 1;
case WM_NCXBUTTONDOWN:
case WM_NCXBUTTONUP:
case WM_XBUTTONDOWN:
case WM_XBUTTONUP:
switch (GET_XBUTTON_WPARAM(wparam)) {
case XBUTTON1:
*button = MOUSE_BUTTON_XBUTTON1;
return 1;
case XBUTTON2:
*button = MOUSE_BUTTON_XBUTTON2;
return 1;
default:
break;
}
break;
default:
break;
}
*button = MOUSE_BUTTON_NONE;
return 0;
}
// VERIFY: 535070f3 auto
// OFFSET: 0x008695B0
static void RestoreMouse() {
POINT point;
point.x = s_mousePos.x;
point.y = s_mousePos.y;
ClientToScreen(s_mouseWnd, &point);
OsLogicalToPhysicalPoint(s_mouseWnd, &point);
OsSetPhysicalCursorPos(point.x, point.y);
}
// VERIFY: 6e7171b8 auto
// OFFSET: 0x00869600
static void SaveMouse(HWND hwnd, const POINT& point) {
if (s_osMouseMode == OS_MOUSE_MODE_RELATIVE) {
return;
}
s_mouseWnd = hwnd;
s_mousePos.x = point.x;
s_mousePos.y = point.y;
}
// VERIFY: c77eb699 auto
// OFFSET: 0x00869620
void OsInputSetWindowResizeLock(int32_t resizeLock) {
s_WindowResizeLock = resizeLock;
}
// VERIFY: 7a315de8 auto
// OFFSET: 0x00869630
float OsInputGetMouseSpeed() {
return s_mouseSpeed * 0.1f;
}
// VERIFY: 536c65bf manual
// OFFSET: 0x00869640
int32_t OsInputIsKeyDown(KEY key) {
uint32_t vkey;
if (!ConvertKeyToVirtualKey(key, &vkey)) {
return 0;
}
return (GetAsyncKeyState(vkey) >> 15) & 1;
}
// VERIFY: 5eb89080 manual
// OFFSET: 0x00869670
int32_t OsInputIsMouseButtonDown(MOUSEBUTTON button) {
switch (button) {
case MOUSE_BUTTON_LEFT:
return (GetAsyncKeyState(VK_LBUTTON) >> 15) & 1;
case MOUSE_BUTTON_MIDDLE:
return (GetAsyncKeyState(VK_MBUTTON) >> 15) & 1;
case MOUSE_BUTTON_RIGHT:
return (GetAsyncKeyState(VK_RBUTTON) >> 15) & 1;
case MOUSE_BUTTON_XBUTTON1:
return (GetAsyncKeyState(VK_XBUTTON1) >> 15) & 1;
case MOUSE_BUTTON_XBUTTON2:
return (GetAsyncKeyState(VK_XBUTTON2) >> 15) & 1;
default:
return 0;
}
}
// VERIFY: 7da0b025 auto
// OFFSET: 0x00869720
void OsInputInitialize() {
s_numLockState = GetAsyncKeyState(VK_NUMLOCK);
s_savedMouseSpeed = 10;
SystemParametersInfoA(SPI_GETMOUSESPEED, 0, &s_savedMouseSpeed, 0);
s_mouseSpeed = s_savedMouseSpeed;
}
// VERIFY: 93192a66 auto
// OFFSET: 0x00869760
void OsInputDestroy() {
if (GetAsyncKeyState(VK_NUMLOCK) != s_numLockState) {
INPUT input = {};
input.type = INPUT_KEYBOARD;
input.ki.wVk = VK_NUMLOCK;
SendInput(1, &input, sizeof(input));
}
if (s_appActive && s_mouseSpeed != s_savedMouseSpeed) {
SystemParametersInfoA(SPI_SETMOUSESPEED, 0, reinterpret_cast<void*>(static_cast<intptr_t>(s_savedMouseSpeed)), 0);
}
}
// VERIFY: 1f154fc9 auto
// OFFSET: 0x008697E0
static int32_t ProcessMouseEvent(uint32_t message, HWND hwnd, MOUSEBUTTON button, OSINPUT id) {
POINT point;
if (s_osMouseMode == OS_MOUSE_MODE_RELATIVE) {
point.x = s_mousePos.x;
point.y = s_mousePos.y;
} else {
GetCursorPos(&point);
ScreenToClient(hwnd, &point);
}
OsQueuePut(id, button, point.x, point.y, 0);
return message == WM_XBUTTONDOWN || message == WM_XBUTTONUP || message == WM_NCXBUTTONDOWN || message == WM_NCXBUTTONUP;
}
// VERIFY: 50290f71 auto
// OFFSET: 0x00869870
static int32_t HandleMouseDown(uint32_t message, uintptr_t wparam, int32_t* xbutton, HWND hwnd) {
MOUSEBUTTON button;
if (!ConvertButton(message, wparam, &button)) {
return 0;
}
if (!s_osButtonState) {
SetCapture(hwnd);
}
s_osButtonState |= button;
int32_t result = ProcessMouseEvent(message, hwnd, button, OS_INPUT_MOUSE_DOWN);
if (xbutton) {
*xbutton = result;
}
return 1;
}
// VERIFY: a4738bfd auto
// OFFSET: 0x008698C0
static int32_t HandleMouseUp(uint32_t message, uintptr_t wparam, int32_t* xbutton, HWND hwnd) {
MOUSEBUTTON button;
if (!ConvertButton(message, wparam, &button)) {
return 0;
}
s_osButtonState &= ~button;
if (!s_osButtonState) {
s_releasingCapture = 1;
ReleaseCapture();
s_releasingCapture = 0;
}
int32_t result = ProcessMouseEvent(message, hwnd, button, OS_INPUT_MOUSE_UP);
if (xbutton) {
*xbutton = result;
}
return 1;
}
// VERIFY: 256ddccc auto
// OFFSET: 0x00869930
static void MoveDragWindow(HWND hwnd, const C2iVector& delta) {
MoveWindow(hwnd, s_dragRect.left + delta.x, s_dragRect.top + delta.y, s_dragRect.right - s_dragRect.left, s_dragRect.bottom - s_dragRect.top, TRUE);
}
// VERIFY: 6934b733 auto
// OFFSET: 0x00869970
static void ResizeDragWindow(int32_t hitTest, HWND hwnd, const C2iVector& delta) {
if (s_WindowResizeLock) {
return;
}
RECT rect = s_dragRect;
switch (hitTest) {
case HTLEFT:
case HTTOPLEFT:
case HTBOTTOMLEFT:
rect.left += delta.x;
break;
case HTRIGHT:
case HTTOPRIGHT:
case HTBOTTOMRIGHT:
rect.right += delta.x;
break;
default:
break;
}
switch (hitTest) {
case HTTOP:
case HTTOPLEFT:
case HTTOPRIGHT:
rect.top += delta.y;
break;
case HTBOTTOM:
case HTBOTTOMLEFT:
case HTBOTTOMRIGHT:
rect.bottom += delta.y;
break;
default:
break;
}
if (SendMessageA(hwnd, WM_SIZING, hitTest - (HTLEFT - WMSZ_LEFT), reinterpret_cast<LPARAM>(&rect))) {
MoveWindow(hwnd, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, TRUE);
}
}
// VERIFY: 04761905 auto
// OFFSET: 0x00869A70
static void DispatchMouseMove(HWND hwnd, int32_t point) {
if (!s_dragging) {
return;
}
C2iVector delta;
delta.x = static_cast<int16_t>(point) - s_dragStart.x;
delta.y = static_cast<int16_t>(point >> 16) - s_dragStart.y;
if (s_dragHitTest == HTCAPTION) {
MoveDragWindow(hwnd, delta);
} else {
ResizeDragWindow(s_dragHitTest, hwnd, delta);
}
}
// VERIFY: 130c80fa manual
// OFFSET: 0x00869AD0
static void BeginDrag(int32_t hitTest, HWND hwnd, int32_t point) {
s_dragCancel = 0;
s_dragHitTest = hitTest;
if (hitTest == HTCAPTION || (hitTest >= HTLEFT && hitTest <= HTBOTTOMRIGHT)) {
SetFocus(hwnd);
WINDOWPLACEMENT placement;
if (GetWindowPlacement(hwnd, &placement) && placement.showCmd != SW_SHOWMAXIMIZED) {
GetWindowRect(hwnd, &s_dragRect);
s_dragStart.x = static_cast<int16_t>(point);
s_dragStart.y = static_cast<int16_t>(point >> 16);
SetCapture(hwnd);
s_dragging = 1;
return;
}
}
s_dragging = 0;
}
// VERIFY: 218cae0c manual
// OFFSET: 0x00869B60
static void HandleNcDblClick(HWND hwnd, int32_t hitTest) {
s_dragCancel = 1;
if (s_dragging) {
ReleaseCapture();
s_dragging = 0;
}
switch (hitTest) {
case HTCAPTION:
case HTMAXBUTTON:
ShowWindow(hwnd, IsZoomed(hwnd) ? SW_RESTORE : SW_MAXIMIZE);
break;
case HTSYSMENU:
case HTCLOSE:
PostQuitMessage(0);
break;
case HTMINBUTTON:
ShowWindow(hwnd, SW_MINIMIZE);
break;
default:
break;
}
}
// VERIFY: 61176f42 manual
// OFFSET: 0x00869C00
static void HandleDragEnd(int32_t hitTest, HWND hwnd, int32_t point) {
if (!s_dragCancel) {
if (s_dragHitTest == hitTest) {
switch (hitTest) {
case HTCAPTION:
if (s_dragging) {
C2iVector delta;
delta.x = static_cast<int16_t>(point) - s_dragStart.x;
delta.y = static_cast<int16_t>(point >> 16) - s_dragStart.y;
MoveDragWindow(hwnd, delta);
}
break;
case HTMINBUTTON:
ShowWindow(hwnd, SW_MINIMIZE);
break;
case HTMAXBUTTON:
ShowWindow(hwnd, IsZoomed(hwnd) ? SW_RESTORE : SW_MAXIMIZE);
break;
case HTLEFT:
case HTRIGHT:
case HTTOP:
case HTTOPLEFT:
case HTTOPRIGHT:
case HTBOTTOM:
case HTBOTTOMLEFT:
case HTBOTTOMRIGHT:
DispatchMouseMove(hwnd, point);
break;
case HTCLOSE:
PostQuitMessage(0);
break;
default:
break;
}
}
if (s_dragging) {
ReleaseCapture();
s_dragging = 0;
}
}
s_dragCancel = 0;
}
// VERIFY: d8010977 manual
// OFFSET: 0x00869CF0
static bool DispatchMouseButtonChanges(HWND hwnd, uint32_t message, uintptr_t wparam, int32_t* xbutton) {
uint32_t state = static_cast<uint32_t>(wparam) & ~0x1F;
uint32_t changed = s_extraButtonState ^ state;
s_extraButtonState = state;
for (uint32_t i = 5; i < 32; i++) {
if ((changed >> i) & 1) {
MOUSEBUTTON button = static_cast<MOUSEBUTTON>(1 << i);
ProcessMouseEvent(message, hwnd, button, (button & state) ? OS_INPUT_MOUSE_DOWN : OS_INPUT_MOUSE_UP);
if (!s_osButtonState) {
SetCapture(hwnd);
}
s_osButtonState |= button;
}
}
if (xbutton) {
*xbutton = 1;
}
return true;
}
// VERIFY: 43689e9e auto
// OFFSET: 0x00869D90
void OsInputSetEventPollProc(void (*pollProc)()) {
s_eventPollProc = pollProc;
}
// VERIFY: 9aad8011 auto
// OFFSET: 0x00869DA0
static void CALLBACK OsInputCallEventPollProc(HWND hwnd, UINT message, UINT_PTR id, DWORD time) {
s_eventPollProc();
}
// VERIFY: daae85b1 auto
// OFFSET: 0x00869DB0
static void CenterMouse() {
RECT rect;
GetWindowRect(static_cast<HWND>(OsGuiGetWindow(0)), &rect);
s_centerMousePos.x = rect.right / 2;
s_centerMousePos.y = rect.bottom / 2;
OsSetPhysicalCursorPos(s_centerMousePos.x, s_centerMousePos.y);
}
// VERIFY: 0ffe5fb1 auto
// OFFSET: 0x00869E00
int32_t OsInputGet(OSINPUT* id, int32_t* param0, int32_t* param1, int32_t* param2, int32_t* param3) {
*id = static_cast<OSINPUT>(-1);
if (s_windowSize && !IsIconic(static_cast<HWND>(OsGuiGetWindow(0)))) {
s_windowSize = 0;
RECT windowRect;
GetWindowRect(static_cast<HWND>(OsGuiGetWindow(0)), &windowRect);
RECT adjust = { 0, 0, 0, 0 };
AdjustWindowRectEx(&adjust, GetWindowLongA(static_cast<HWND>(OsGuiGetWindow(0)), GWL_STYLE), FALSE, 0);
int32_t width = (windowRect.right - adjust.right) - (windowRect.left - adjust.left);
int32_t height = (windowRect.bottom - adjust.bottom) - (windowRect.top - adjust.top);
if (width != s_defaultWindowRect.right || height != s_defaultWindowRect.bottom) {
s_defaultWindowRect.left = 0;
s_defaultWindowRect.top = 0;
s_defaultWindowRect.right = width;
s_defaultWindowRect.bottom = height;
*id = OS_INPUT_SIZE;
*param0 = width;
*param1 = height;
*param2 = 0;
*param3 = 0;
return 1;
}
}
if (s_queueHead == s_queueTail) {
OsPollJoysticks(s_appActive);
MSG msg;
BOOL available = PeekMessageA(&msg, nullptr, 0, 0, PM_NOREMOVE);
while (s_queueHead == s_queueTail) {
if (!available) {
return 0;
}
if (!GetMessageA(&msg, nullptr, 0, 0)) {
*id = OS_INPUT_SHUTDOWN;
return 1;
}
if (OsGuiProcessMessage(&msg) || s_queueHead != s_queueTail) {
break;
}
TranslateMessage(&msg);
DispatchMessageA(&msg);
if (s_queueHead != s_queueTail) {
break;
}
available = PeekMessageA(&msg, nullptr, 0, 0, PM_NOREMOVE);
}
}
OsQueueGet(id, param0, param1, param2, param3);
return 1;
}
// VERIFY: 11a72f4a auto
// OFFSET: 0x0086A020
void OsInputSetMouseMode(OS_MOUSE_MODE mode) {
if (mode >= OS_MOUSE_MODES) {
SErrSetLastError(STORM_ERROR_INVALID_PARAMETER);
return;
}
if (mode == s_osMouseMode) {
return;
}
if (mode == OS_MOUSE_MODE_RELATIVE) {
s_osMouseMode = mode;
CenterMouse();
} else if (s_osMouseMode == OS_MOUSE_MODE_RELATIVE) {
s_osMouseMode = OS_MOUSE_MODE_NORMAL;
RestoreMouse();
}
}
// VERIFY: c38ece61 auto
// OFFSET: 0x0086A070
void OsInputSetMouseSpeed(float speed) {
float clamped = speed < 0.1f ? 0.1f : (speed >= 2.0f ? 2.0f : speed);
s_mouseSpeed = static_cast<int32_t>(clamped * 10.0f);
if (s_appActive) {
SystemParametersInfoA(SPI_SETMOUSESPEED, 0, reinterpret_cast<void*>(static_cast<intptr_t>(s_mouseSpeed)), 0);
}
}
// VERIFY: 9440f9a0 auto
// OFFSET: 0x0086A0D0
void OsInputGetMousePosition(int32_t* x, int32_t* y) {
HWND hwnd = static_cast<HWND>(OsGuiGetWindow(0));
POINT point;
GetCursorPos(&point);
ScreenToClient(hwnd, &point);
SaveMouse(hwnd, point);
if (x) {
*x = point.x;
}
if (y) {
*y = point.y;
}
}
// VERIFY: 28ed4ab4 auto
// OFFSET: 0x0086A130
void OsInputSetMousePosition(int32_t x, int32_t y) {
HWND hwnd = static_cast<HWND>(OsGuiGetWindow(0));
POINT point;
point.x = x;
point.y = y;
SaveMouse(hwnd, point);
ClientToScreen(hwnd, &point);
OsLogicalToPhysicalPoint(s_mouseWnd, &point);
OsSetPhysicalCursorPos(point.x, point.y);
}
// VERIFY: 97923916 auto
// OFFSET: 0x0086A1A0
int32_t OsGetDefaultWindowRect(tagRECT* rect) {
if (!rect) {
SErrSetLastError(STORM_ERROR_INVALID_PARAMETER);
return 0;
}
if (!s_defaultWindowRect.right || !s_defaultWindowRect.bottom) {
if (!GetClientRect(static_cast<HWND>(OsGuiGetWindow(0)), &s_defaultWindowRect)) {
return 0;
}
}
*rect = s_defaultWindowRect;
return 1;
}
// VERIFY: 5f1e1652 manual
// OFFSET: 0x0086A210
intptr_t OsWindowProc(void* window, uint32_t message, uintptr_t wparam, intptr_t lparam) {
HWND hwnd = static_cast<HWND>(window);
UINT_PTR timer = 0;
switch (message) {
case WM_SIZE:
case WM_DISPLAYCHANGE:
s_windowSize = lparam;
break;
case WM_ACTIVATE: {
BOOL minimized = IsIconic(hwnd);
s_appActive = LOWORD(wparam) != WA_INACTIVE && !minimized ? 1 : 0;
s_osButtonState = 0;
SystemParametersInfoA(SPI_SETMOUSESPEED, 0, reinterpret_cast<void*>(static_cast<intptr_t>(s_appActive ? s_mouseSpeed : s_savedMouseSpeed)), 0);
OsQueuePut(OS_INPUT_FOCUS, s_appActive != 0, 0, 0, 0);
break;
}
case WM_CLOSE:
OsQueuePut(OS_INPUT_CLOSE, 0, 0, 0, 0);
return 0;
case WM_INPUTLANGCHANGE: {
OsQueuePut(OS_INPUT_IME, 0, 0, 0, 0);
CHARSETINFO charset;
if (TranslateCharsetInfo(reinterpret_cast<DWORD*>(wparam), &charset, TCI_SRCCHARSET)) {
s_codePage = charset.ciACP;
}
break;
}
case WM_IME_STARTCOMPOSITION:
OsQueuePut(OS_INPUT_IME, 1, 0, 0, 0);
return 1;
case WM_IME_ENDCOMPOSITION:
OsQueuePut(OS_INPUT_IME, 6, 0, 0, 0);
return 1;
case WM_IME_COMPOSITION: {
int32_t flags = 0;
if (lparam & GCS_CURSORPOS) {
flags = 1;
}
if (lparam & GCS_COMPSTR) {
flags |= 2;
}
if (lparam & GCS_RESULTSTR) {
flags |= 4;
}
OsQueuePut(OS_INPUT_IME, 2, 0, flags, 0);
return 1;
}
case WM_CHAR: {
if (wparam < 0x20) {
break;
}
uint32_t character = static_cast<uint32_t>(wparam);
uint32_t ch = wparam & 0xFF;
if (ch >= 0x80) {
if (!s_codePage) {
s_codePage = GetACP();
}
switch (s_codePage) {
case 874:
character = s_thailookup[ch];
break;
case 1250:
character = s_latin2lookup[ch];
break;
case 1251:
character = s_cyrilliclookup[ch];
break;
case 1252:
if (ch < 0xA0) {
character = s_latin1lookup[ch & 0x7F];
}
break;
case 1254:
character = s_latin5lookup[ch];
break;
default:
break;
}
}
OsQueuePut(OS_INPUT_CHAR, character, static_cast<int16_t>(lparam), 0, 0);
return 0;
}
case WM_KEYDOWN:
case WM_KEYUP:
case WM_SYSKEYDOWN:
case WM_SYSKEYUP: {
int32_t down = message == WM_KEYDOWN || message == WM_SYSKEYDOWN;
uint32_t vkey = static_cast<uint32_t>(wparam);
if (vkey == VK_SHIFT) {
if (!down) {
OsQueuePut(OS_INPUT_KEY_UP, KEY_LSHIFT, 0, 0, 0);
OsQueuePut(OS_INPUT_KEY_UP, KEY_RSHIFT, 0, 0, 0);
return 0;
}
if (s_rshiftScanCode == 0x100) {
s_rshiftScanCode = MapVirtualKeyA(VK_RSHIFT, MAPVK_VK_TO_VSC);
}
vkey = ((lparam >> 16) & 0xFF) == s_rshiftScanCode ? VK_RSHIFT : VK_LSHIFT;
} else if (vkey == VK_CONTROL) {
vkey = (lparam & 0x1000000) ? VK_RCONTROL : VK_LCONTROL;
} else if (vkey == VK_MENU) {
vkey = (lparam & 0x1000000) ? VK_RMENU : VK_LMENU;
}
KEY key;
if (!ConvertKeyCode(vkey, &key)) {
break;
}
OsQueuePut(down ? OS_INPUT_KEY_DOWN : OS_INPUT_KEY_UP, key, LOWORD(lparam), 0, 0);
if (key == KEY_F4 && OsGuiIsModifierKeyDown(2)) {
break;
}
return 0;
}
case WM_NCLBUTTONDOWN:
BeginDrag(static_cast<int32_t>(wparam), hwnd, static_cast<int32_t>(lparam));
return 0;
case WM_NCLBUTTONUP:
HandleDragEnd(static_cast<int32_t>(wparam), hwnd, static_cast<int32_t>(lparam));
return 0;
case WM_NCLBUTTONDBLCLK:
HandleNcDblClick(hwnd, static_cast<int32_t>(wparam));
return 0;
case WM_NCRBUTTONDOWN:
case WM_NCRBUTTONUP:
case WM_POPUPSYSTEMMENU:
if (s_eventPollProc) {
timer = SetTimer(hwnd, 0, 33, OsInputCallEventPollProc);
}
break;
case WM_SYSCOMMAND:
if (wparam == SC_CLOSE) {
OsQueuePut(OS_INPUT_CLOSE, 0, 0, 0, 0);
return 0;
}
if (!s_chainWindowProc && wparam == SC_KEYMENU) {
return 0;
}
break;
case WM_MOUSEMOVE: {
if (s_dragging) {
POINT point;
point.x = static_cast<int16_t>(lparam);
point.y = static_cast<int16_t>(lparam >> 16);
ClientToScreen(hwnd, &point);
DispatchMouseMove(hwnd, MAKELPARAM(point.x, point.y));
return 0;
}
POINT point;
if (s_osMouseMode != OS_MOUSE_MODE_NORMAL) {
OsGetPhysicalCursorPos(&point);
if (point.x != s_centerMousePos.x || point.y != s_centerMousePos.y) {
OsQueuePut(OS_INPUT_MOUSE_MOVE_RELATIVE, 0, point.x - s_centerMousePos.x, point.y - s_centerMousePos.y, 0);
CenterMouse();
}
} else {
GetCursorPos(&point);
ScreenToClient(hwnd, &point);
OsQueuePut(OS_INPUT_MOUSE_MOVE, 0, point.x, point.y, 0);
SaveMouse(hwnd, point);
}
break;
}
case WM_LBUTTONDOWN:
case WM_RBUTTONDOWN:
case WM_MBUTTONDOWN:
case WM_XBUTTONDOWN: {
int32_t xbutton;
if (HandleMouseDown(message, wparam, &xbutton, hwnd)) {
return xbutton;
}
break;
}
case WM_LBUTTONUP:
if (s_dragging) {
POINT point;
point.x = static_cast<int16_t>(lparam);
point.y = static_cast<int16_t>(lparam >> 16);
ClientToScreen(hwnd, &point);
HandleDragEnd(s_dragHitTest, hwnd, MAKELPARAM(point.x, point.y));
return 0;
}
case WM_RBUTTONUP:
case WM_MBUTTONUP:
case WM_XBUTTONUP: {
int32_t xbutton;
if (HandleMouseUp(message, wparam, &xbutton, hwnd)) {
return xbutton;
}
break;
}
case WM_MOUSEWHEEL: {
POINT point;
if (s_osMouseMode == OS_MOUSE_MODE_RELATIVE) {
point.x = s_mousePos.x;
point.y = s_mousePos.y;
} else {
GetCursorPos(&point);
}
ScreenToClient(hwnd, &point);
OsQueuePut(OS_INPUT_MOUSE_WHEEL, static_cast<int16_t>(wparam >> 16), point.x, point.y, 0);
return 0;
}
case WM_CAPTURECHANGED: {
if (s_releasingCapture) {
break;
}
s_osButtonState = 0;
POINT point;
GetCursorPos(&point);
ScreenToClient(hwnd, &point);
OsQueuePut(OS_INPUT_CAPTURE_CHANGED, 0, point.x, point.y, 0);
return 0;
}
case WM_IME_SETCONTEXT:
OsQueuePut(OS_INPUT_IME, 0, 0, 0, 0);
lparam = 0;
break;
case WM_IME_NOTIFY:
switch (wparam) {
case IMN_CHANGECANDIDATE:
OsQueuePut(OS_INPUT_IME, 4, 0, static_cast<int32_t>(lparam), 0);
break;
case IMN_CLOSECANDIDATE:
OsQueuePut(OS_INPUT_IME, 5, 0, 0, 0);
break;
case IMN_OPENCANDIDATE:
OsQueuePut(OS_INPUT_IME, 3, 0, static_cast<int32_t>(lparam), 0);
break;
case IMN_SETCONVERSIONMODE:
OsQueuePut(OS_INPUT_KEY_UP, KEY_LSHIFT, 0, 0, 0);
OsQueuePut(OS_INPUT_KEY_UP, KEY_RSHIFT, 0, 0, 0);
OsQueuePut(OS_INPUT_IME, 0, 0, 0, 0);
break;
case IMN_SETOPENSTATUS:
OsQueuePut(OS_INPUT_IME, 0, 0, 0, 0);
break;
default:
break;
}
break;
case WM_IME_CONTROL:
case WM_IME_COMPOSITIONFULL:
case WM_IME_SELECT:
return 0;
case WM_USER + 3: {
int32_t xbutton;
if (DispatchMouseButtonChanges(hwnd, message, wparam, &xbutton)) {
return xbutton;
}
break;
}
default:
break;
}
intptr_t result;
if (s_chainWindowProc) {
result = s_chainWindowProc(window, message, wparam, lparam);
} else {
result = DefWindowProcA(hwnd, message, wparam, lparam);
}
if (timer) {
KillTimer(hwnd, 0);
}
return result;
}
#endif