Files
SatyandClaude Opus 5.5 2e418f9e08 Client bring-up: glue screen, EULA/TOS, shutdown chain, LCD, x64 fixes
- Stand-in client reaches the glue screens (intro movie, EULA/TOS accept,
  login screen) at 16:9; stand-ins are report-only on x64
- Ports on the startup/idle path: GlueScriptEvents/CharacterSelection/
  CharacterCreation/RealmList/AccountMsg/VideoOptions _Scripts, CGlueMgr
  (Initialize/Resume/Idle/Accept*/Shutdown), ClientServices, NetClient/
  WowConnection, DBCache + instances, WorldParam/World/Map/Liquid/Weather/
  shadow, InputControl, Scrn, ConsoleClient, SysMessage, LoadingScreen,
  SystemRegisterFunctions, CGameTime, Screen::GetAspectRatio
- Shutdown chain: BeginCloseGame, DestroyEngineCallback, DBCache save/
  destroy, SpellVisuals/Effect/World/Glue teardown
- Logitech LCD no-device path in Ui/UILCD/Windows (Windows-only dir);
  lgLcd is a stub library in ThirdParty/lgLcd
- CVar and console commands split into <Module>_CVar.cpp / _Console.cpp
- DivxDecoder.dll (Win32, original) and XvidDecoder.dll (x64, port with
  vendored xvidcore) both copied to the build folder
- Warden: Win32 faithful port, Win64 stub
- x64 fixes: lua_newstate gcusage/gctime init, pointer render states reset
  with nullptr, g_rndSeed defined
- 37 class/struct forward-declaration mismatches fixed (false stand-ins)

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
2026-09-27 21:47:34 +02:00

578 lines
19 KiB
C++

#include <cstdint>
#include <cstdio>
#include <cstring>
#include "ConsoleDevice.h"
#include "Engine/Source/ConsoleBase/ConsoleVar.h"
#include "Engine/Source/ConsoleBase/IConsole.h"
#include "Engine/Source/Gx/CGxDevice/CGxDevice.h"
#include "Engine/Source/Gx/CGxDevice/Types.h"
#include "Engine/Source/Gx/CGxFormat.h"
#include "Engine/Source/Gx/Gx.h"
#include "Engine/Source/Os/Input.h"
#include "Engine/Source/Storm/H/storm.h"
#include "WoW/Source/Client.h"
#include "WoW/Source/Hardware.h"
// STATIC: 0x00CABA98
static CVar* s_cvGxStereoEnabled;
// STATIC: 0x00CABA9C
static CVar* s_cvGxRefresh;
// STATIC: 0x00CABAA0
CVar* s_cvGxMaximize;
// STATIC: 0x00CABAA4
static CVar* s_cvGxMultisample;
// STATIC: 0x00CABAA8
static CVar* s_cvGxCursor;
// STATIC: 0x00CABAAC
static CVar* s_cvGxStereoSeparation;
// STATIC: 0x00CABAB0
static CVar* s_cvGxMultisampleQuality;
// STATIC: 0x00CABAB4
static CVar* s_cvGxResolution;
// STATIC: 0x00CABAB8
CVar* s_cvHwDetect;
// STATIC: 0x00CABABC
static CVar* s_cvGxOverride;
// STATIC: 0x00CABAC0
CVar* s_cvGxFixLag;
// STATIC: 0x00CABAC4
static CVar* s_cvMaxFPS;
// STATIC: 0x00CABAEC
static CVar* s_cvGxVSync;
// STATIC: 0x00CABB30
CVar* s_cvVideoOptionsVersion;
// STATIC: 0x00CABB34
static CVar* s_cvGxStereoConvergence;
// STATIC: 0x00CABB6C
static CVar* s_cvMaxFPSBk;
// STATIC: 0x00CABB70
static CVar* s_cvGxTripleBuffer;
// STATIC: 0x00CABB74
static CVar* s_cvGxDepthBits;
// STATIC: 0x00CABB78
static CVar* s_cvGxColorBits;
// STATIC: 0x00CABBA0
static CVar* s_cvGxApi;
// STATIC: 0x00CABBA4
static CVar* s_cvGxAspect;
// STATIC: 0x00CABBA8
CVar* s_cvFixedFunction;
// STATIC: 0x00CABBAC
static CVar* s_cvWidescreen;
// STATIC: 0x00CABBB0
CVar* s_cvGxWindow;
// STATIC: 0x00CABBB4
static CVar* s_cvWindowResizeLock;
// VERIFY: b2a180e4 auto
// OFFSET: 0x00769240
static bool CVGxColorBitsCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
switch (SStrToInt(value)) {
case 16:
s_requestedFormat.m_colorFormat = CGxFormat::Fmt_Rgb565;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
case 24:
s_requestedFormat.m_colorFormat = CGxFormat::Fmt_ArgbX888;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
case 30:
s_requestedFormat.m_colorFormat = CGxFormat::Fmt_Argb2101010;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
default:
ConsoleWrite("Color bits must be 16, 24, or 30", DEFAULT_COLOR);
return false;
}
}
// VERIFY: 1b589d62 auto
// OFFSET: 0x007692D0
static bool CVGxDepthBitsCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
switch (SStrToInt(value)) {
case 16:
s_requestedFormat.m_depthFormat = CGxFormat::Fmt_Ds160;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
case 24:
s_requestedFormat.m_depthFormat = CGxFormat::Fmt_Ds24X;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
case 32:
s_requestedFormat.m_depthFormat = CGxFormat::Fmt_Ds320;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
default:
ConsoleWrite("Depth bits must be 16, 24, or 32", DEFAULT_COLOR);
return false;
}
}
// VERIFY: fd54fc0b manual
// OFFSET: 0x00769360
static bool CVGxTripleBufferCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
uint32_t tripleBuffer = SStrToInt(value);
if (tripleBuffer >= 2) {
ConsoleWrite("TripleBuffer must be 0 or 1", DEFAULT_COLOR);
return false;
}
s_requestedFormat.m_backBufferCount = (tripleBuffer != 0) + 1;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
}
// VERIFY: 1b35a664 auto
// OFFSET: 0x007693B0
static bool CVGxApiCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
for (int32_t api = GxApi_OpenGl; api < GxApis_Last; api++) {
if (GxApiSupported(static_cast<EGxApi>(api)) && !SStrCmpI(value, g_gxApiNames[api], STORM_MAX_STR)) {
ConsoleWrite("GxApi set pending gxRestart", DEFAULT_COLOR);
return true;
}
}
char message[1024] = "unsupported api, must be one of ";
bool first = true;
for (int32_t api = GxApi_OpenGl; api < GxApis_Last; api++) {
if (!GxApiSupported(static_cast<EGxApi>(api))) {
continue;
}
if (!first) {
strcat(message, ", ");
}
strcat(message, "'");
strcat(message, g_gxApiNames[api]);
strcat(message, "'");
first = false;
}
ConsoleWrite(message, DEFAULT_COLOR);
return false;
}
// VERIFY: 05847e9e auto
// OFFSET: 0x00769520
static bool CVGxVSyncCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
s_requestedFormat.m_vsync = SStrToInt(value);
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
}
// VERIFY: b82579a5 auto
// OFFSET: 0x00769550
static bool CVGxWindowCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
s_requestedFormat.m_window = SStrToInt(value) != 0;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
}
// VERIFY: 88a23b6c auto
// OFFSET: 0x00769580
static bool CVGxAspectCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
s_requestedFormat.m_aspect = SStrToInt(value) != 0;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
}
// VERIFY: f09230be auto
// OFFSET: 0x007695B0
static bool CVGxMaximizeCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
s_requestedFormat.m_maximize = SStrToInt(value) != 0;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
}
// VERIFY: 5986dd1d auto
// OFFSET: 0x007695E0
static bool CVGxCursorCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
s_requestedFormat.m_hwCursor = SStrToInt(value) != 0;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
}
// VERIFY: 93f25d19 manual
// OFFSET: 0x00769610
static bool CVGxMultisampleCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
int32_t multisample = SStrToInt(value);
if (multisample <= 1) {
multisample = 1;
} else if (multisample >= 16) {
multisample = 16;
}
s_requestedFormat.m_multisampleCount = multisample;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
}
// VERIFY: 1bcaf62f auto
// OFFSET: 0x00769650
static bool CVGxMultisampleQualityCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
float quality = SStrToFloat(value);
if (quality < 0.0f) {
quality = 0.0f;
} else if (quality >= 1.0f) {
quality = 1.0f;
}
s_requestedFormat.m_multisampleQuality = quality;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
}
// VERIFY: c1f4a85d auto
// OFFSET: 0x007696A0
static bool CVGxFixLagCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
s_requestedFormat.m_fixLag = SStrToInt(value) != 0;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
}
// VERIFY: 34058bc1 auto
// OFFSET: 0x00769810
static bool CVGxOverrideCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
ConsoleGxOverride(value);
return true;
}
// VERIFY: b867ad47 auto
// OFFSET: 0x00769830
static bool CVGxMaxFPSCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
uint32_t maxFPS = SStrToInt(value);
if (maxFPS - 1 <= 6) {
maxFPS = 8;
}
GxSetMaxFPS(maxFPS);
return true;
}
// VERIFY: f691ee8b auto
// OFFSET: 0x00769860
static bool CVGxMaxFPSBkCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
uint32_t maxFPSBk = SStrToInt(value);
if (maxFPSBk - 1 <= 6) {
maxFPSBk = 8;
}
GxSetMaxFPSBk(maxFPSBk);
return true;
}
// VERIFY: 7d022997 auto
// OFFSET: 0x00769890
static bool CVGxWindowResizeLockCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
OsInputSetWindowResizeLock(SStrToInt(value));
return true;
}
// VERIFY: 1bd7dbb1 auto
// OFFSET: 0x007698B0
bool UpdateGxCVars() {
s_cvGxColorBits->Update();
s_cvGxDepthBits->Update();
s_cvGxWindow->Update();
s_cvGxResolution->Update();
s_cvGxRefresh->Update();
s_cvGxTripleBuffer->Update();
s_cvGxApi->Update();
s_cvGxVSync->Update();
s_cvGxAspect->Update();
s_cvGxMaximize->Update();
s_cvGxCursor->Update();
s_cvGxMultisample->Update();
s_cvGxMultisampleQuality->Update();
return s_cvGxFixLag->Update();
}
// VERIFY: 716d764e auto
// OFFSET: 0x00769950
bool SetGxCVars(const CGxFormat& format) {
char value[1024];
s_cvGxColorBits->Set(s_formatToInt[format.m_colorFormat], true, false, false, true);
s_cvGxDepthBits->Set(s_formatToInt[format.m_depthFormat], true, false, false, true);
SStrPrintf(value, sizeof(value), "%d", format.m_window);
s_cvGxWindow->Set(value, true, false, false, true);
SStrPrintf(value, sizeof(value), "%dx%d", format.m_size.x, format.m_size.y);
s_cvGxResolution->Set(value, true, false, false, true);
SStrPrintf(value, sizeof(value), "%d", format.m_refreshRate);
s_cvGxRefresh->Set(value, true, false, false, true);
s_cvGxTripleBuffer->Set(format.m_backBufferCount > 1 ? "1" : "0", true, false, false, true);
SStrPrintf(value, sizeof(value), "%d", format.m_vsync);
s_cvGxVSync->Set(value, true, false, false, true);
SStrPrintf(value, sizeof(value), "%d", format.m_aspect);
s_cvGxAspect->Set(value, true, false, false, true);
SStrPrintf(value, sizeof(value), "%d", format.m_maximize);
s_cvGxMaximize->Set(value, true, false, false, true);
SStrPrintf(value, sizeof(value), "%d", format.m_hwCursor);
s_cvGxCursor->Set(value, true, false, false, true);
SStrPrintf(value, sizeof(value), "%d", format.m_multisampleCount);
s_cvGxMultisample->Set(value, true, false, false, true);
SStrPrintf(value, sizeof(value), "%f", format.m_multisampleQuality);
s_cvGxMultisampleQuality->Set(value, true, false, false, true);
SStrPrintf(value, sizeof(value), "%d", format.m_fixLag);
s_cvGxFixLag->Set(value, true, false, false, true);
return UpdateGxCVars();
}
// VERIFY: a95866c0 auto
// OFFSET: 0x00769C00
static bool CVGxStereoEnabledCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
s_requestedFormat.m_stereoEnabled = SStrToInt(value) == 1;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
}
// VERIFY: 30f5328f auto
// OFFSET: 0x00769C30
static bool CVGxStereoConvergenceCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
g_theGxDevicePtr->StereoSetConvergence(SStrToFloat(value));
return true;
}
// VERIFY: 75b13ba9 auto
// OFFSET: 0x00769C60
static bool CVGxStereoSeparationCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
g_theGxDevicePtr->StereoSetSeparation(SStrToFloat(value));
return true;
}
// VERIFY: dc6233ea auto
// OFFSET: 0x0076A220
static bool CVGxResolutionCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
int32_t width = -1;
int32_t height = -1;
char separator;
sscanf(value, "%d%c%d", &width, &separator, &height);
if (s_requestedFormat.m_window) {
s_requestedFormat.m_size.x = width;
s_requestedFormat.m_size.y = height;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
}
TSGrowableArray<C2iVector> resolutions;
C2iVector resolution;
if (s_cvWidescreen->m_intValue) {
TSGrowableArray<CGxMonitorMode> modes;
GxAdapterMonitorModes(modes);
C2iVector last = { 0, 0 };
for (uint32_t i = 0; i < modes.Count(); i++) {
const C2iVector& size = modes[i].m_size;
if (static_cast<float>(size.x) / size.y >= 1.248f && size.x >= 640 && size.y >= 480 && (size.x != last.x || size.y != last.y)) {
last = size;
resolutions.New(last);
}
}
}
if (!resolutions.Count()) {
resolution.x = 640;
resolution.y = 480;
resolutions.New(resolution);
resolution.x = 800;
resolution.y = 600;
resolutions.New(resolution);
resolution.x = 1024;
resolution.y = 768;
resolutions.New(resolution);
resolution.x = 1152;
resolution.y = 864;
resolutions.New(resolution);
resolution.x = 1280;
resolution.y = 960;
resolutions.New(resolution);
resolution.x = 1280;
resolution.y = 1024;
resolutions.New(resolution);
resolution.x = 1600;
resolution.y = 1200;
resolutions.New(resolution);
}
uint32_t i;
for (i = 0; i < resolutions.Count(); i++) {
if (width == resolutions[i].x && height == resolutions[i].y) {
break;
}
}
if (i == resolutions.Count()) {
char message[256] = "invalid resolution, must be one of ";
for (uint32_t j = 0; j < resolutions.Count(); j++) {
if (j) {
strcat(message, ", ");
}
if (SStrLen(message) > 100) {
ConsoleWrite(message, DEFAULT_COLOR);
message[0] = '\0';
}
char entry[16];
SStrPrintf(entry, 32, "%dx%d", resolutions[j].x, resolutions[j].y);
strcat(message, entry);
}
ConsoleWrite(message, DEFAULT_COLOR);
return false;
}
s_requestedFormat.m_size.x = width;
s_requestedFormat.m_size.y = height;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
}
// VERIFY: ec771f1a manual
// OFFSET: 0x0076A580
static bool CVGxRefreshCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
uint32_t refreshRate = SStrToUnsigned(value);
TSGrowableArray<CGxMonitorMode> modes;
GxAdapterMonitorModes(modes);
uint32_t i;
for (i = 0; i < modes.Count(); i++) {
if (refreshRate == modes[i].m_refreshRate) {
break;
}
}
if (i == modes.Count()) {
ConsoleWrite("Unsupported refresh rate", DEFAULT_COLOR);
return false;
}
s_requestedFormat.m_refreshRate = refreshRate;
ConsoleWrite("set pending gxRestart", DEFAULT_COLOR);
return true;
}
// VERIFY: 05a0817f auto
// OFFSET: 0x008A1420
static bool CVVideoOptionsVersionCallback(CVar* var, const char* oldValue, const char* value, void* arg) {
return true;
}
// VERIFY: 62bcef94 auto
// OFFSET: 0x00769C90
void RegisterStereoCVars() {
s_cvGxStereoConvergence = CVar::Register("gxStereoConvergence", "Set stereoscopic rendering convergence depth", 1, "1", CVGxStereoConvergenceCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvGxStereoSeparation = CVar::Register("gxStereoSeparation", "Set stereoscopic rendering separation percentage", 1, "25", CVGxStereoSeparationCallback, CATEGORY_GRAPHICS, false, nullptr, false);
g_theGxDevicePtr->AddStereoChangedCallback(StereoChangedCallback);
}
// VERIFY: 8dcc523c auto
// OFFSET: 0x0076A630
void RegisterGxCVars() {
const CGxFormat& format = *s_defaults.m_format;
bool window = s_locale == 4;
char value[260];
s_cvWidescreen = CVar::Register("widescreen", "Allow widescreen support", 0, "1", nullptr, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvGxWindow = CVar::Register("gxWindow", "toggle fullscreen/window", 3, window ? "1" : "0", CVGxWindowCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvGxMaximize = CVar::Register("gxMaximize", "maximize game window", 3, window ? "1" : "0", CVGxMaximizeCallback, CATEGORY_GRAPHICS, false, nullptr, false);
SStrPrintf(value, sizeof(value), "%s", s_formatToInt[format.m_colorFormat]);
s_cvGxColorBits = CVar::Register("gxColorBits", "color bits", 3, value, CVGxColorBitsCallback, CATEGORY_GRAPHICS, false, nullptr, false);
SStrPrintf(value, sizeof(value), "%s", s_formatToInt[format.m_depthFormat]);
s_cvGxDepthBits = CVar::Register("gxDepthBits", "depth bits", 3, value, CVGxDepthBitsCallback, CATEGORY_GRAPHICS, false, nullptr, false);
SStrPrintf(value, sizeof(value), "%dx%d", format.m_size.x, format.m_size.y);
s_cvGxResolution = CVar::Register("gxResolution", "resolution", 3, value, CVGxResolutionCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvGxRefresh = CVar::Register("gxRefresh", "refresh rate", 3, "75", CVGxRefreshCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvGxTripleBuffer = CVar::Register("gxTripleBuffer", "triple buffer", 3, "0", CVGxTripleBufferCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvGxApi = CVar::Register("gxApi", "graphics api", 3, g_gxApiNames[GxDefaultApi()], CVGxApiCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvGxVSync = CVar::Register("gxVSync", "vsync on or off", 3, "1", CVGxVSyncCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvGxAspect = CVar::Register("gxAspect", "constrain window aspect", 3, "1", CVGxAspectCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvGxCursor = CVar::Register("gxCursor", "toggle hardware cursor", 3, "1", CVGxCursorCallback, CATEGORY_GRAPHICS, false, nullptr, false);
SStrPrintf(value, sizeof(value), "%d", s_hardware.m_videoHw->m_multisample);
s_cvGxMultisample = CVar::Register("gxMultisample", "multisample", 3, value, CVGxMultisampleCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvGxMultisampleQuality = CVar::Register("gxMultisampleQuality", "multisample quality", 3, "0.0", CVGxMultisampleQualityCallback, CATEGORY_GRAPHICS, false, nullptr, false);
SStrPrintf(value, sizeof(value), "%d", s_hardware.m_videoHw->m_fixLag);
s_cvGxFixLag = CVar::Register("gxFixLag", "prevent cursor lag", 3, value, CVGxFixLagCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvGxStereoEnabled = CVar::Register("gxStereoEnabled", "Enable stereoscopic rendering", 1, "0", CVGxStereoEnabledCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvGxOverride = CVar::Register("gxOverride", "gx overrides", 1, "", CVGxOverrideCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvMaxFPS = CVar::Register("maxFPS", "Set FPS limit", 1, "200", CVGxMaxFPSCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvMaxFPSBk = CVar::Register("maxFPSBk", "Set background FPS limit", 1, "30", CVGxMaxFPSBkCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvVideoOptionsVersion = CVar::Register("videoOptionsVersion", "Video options version", 3, "0", CVVideoOptionsVersionCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvWindowResizeLock = CVar::Register("windowResizeLock", "prevent resizing in windowed mode", 1, "0", CVGxWindowResizeLockCallback, CATEGORY_GRAPHICS, false, nullptr, false);
s_cvFixedFunction = CVar::Register("fixedFunction", "Force fixed function rendering", 3, "0", nullptr, CATEGORY_GRAPHICS, false, nullptr, false);
}