Files
wowdecomp/WoW/Source/Ui/WorldFrame.cpp
T
SatyandClaude Opus 5.5 eabc5d8997 Port the logic fixes from the msvc80 branch
Behaviour fixes found while byte-matching against 12340, without the
VS2005 code-shape rewrites:
- 272502f5 logic bugs (MapObjDef 0x80 flag, D3D texop, PostReenable, ...)
- 3002c17f case-sensitive KNOWNDANCES/DECLINEDWORD keys, DynamicObject
  GetTransportGUID, CShadowCache::Initialize
- OpenGl IStateSyncEnables fill/line, DsSet integer value tests
- FriendList tail padding, HandleSpellEventSound severity, selection
  index -1, negative spell id in HasPetSpell
- operator delete null checks, FMOD MemoryFile seek clamp, SErr
  HeapAlloc flags
- WOWCLIENT_CRASH_LOG option

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
2026-10-15 15:18:17 +02:00

2533 lines
78 KiB
C++

#include "WorldFrame.h"
#include "Engine/Source/Base/ConvertUTF.h"
#include <cstring>
#include <typeinfo>
#include "Engine/Source/Base/Coordinate.h"
#include "Engine/Source/Base/Status.h"
#include "Engine/Source/ConsoleBase/ConsoleVar.h"
#include "Engine/Source/Event/CKeyEvent.h"
#include "Engine/Source/Event/CMouseEvent.h"
#include "Engine/Source/Event/Event.h"
#include "Engine/Source/FFX/EffectGlow.h"
#include "Engine/Source/FFX/FFX.h"
#include "Engine/Source/Frame/CRenderBatch.h"
#include "Engine/Source/Frame/CSimpleTop.h"
#include "Engine/Source/FrameScript/FrameScript.h"
#include "Engine/Source/FrameXML/FrameXML.h"
#include "Engine/Source/Gx/CGxDevice/CGxDevice.h"
#include "Engine/Source/Gx/CGxTexFlags.h"
#include "Engine/Source/Gx/Gx.h"
#include "Engine/Source/Gxu/Gxu.h"
#include "Engine/Source/Model2/M2Scene.h"
#include "Engine/Source/Os/Time.h"
#include "Engine/Source/Os/TimeManager.h"
#include "Engine/Source/Services/Camera.h"
#include "Engine/Source/Services/SysMessage.h"
#include "Engine/Source/Services/Texture.h"
#include "Engine/Source/ShaderEffect/ShaderEffect.h"
#include "Engine/Source/Tempest/C4Vector.h"
#include "Engine/Source/Tempest/CAaBox.h"
#include "Engine/Source/Tempest/CImVector.h"
#include "Engine/Source/lua-5.1/src/lua.h"
#include "WoW/Common/TextureCache.h"
#include "WoW/Source/Client.h"
#include "WoW/Source/DB/DBClient/DBClient.h"
#include "WoW/Source/DB/Rec/MapRec.h"
#include "WoW/Source/DB/Rec/ScreenEffectRec.h"
#include "WoW/Source/DB/Rec/SpellRec.h"
#include "WoW/Source/Game/GameClient/FFXEffects.h"
#include "WoW/Source/Game/GameClient/PassFogSeed.h"
#include "WoW/Source/Game/GameClient/PlayerName.h"
#include "WoW/Source/Game/GameClient/ProjectTex.h"
#include "WoW/Source/Game/GameClient/WorldText.h"
#include "WoW/Source/Game/GameTime.h"
#include "WoW/Source/Magic/MagicClient/SpellVisuals.h"
#include "WoW/Source/Magic/MagicClient/Spell_C.h"
#include "WoW/Source/Object/ObjectClient/AuraData.h"
#include "WoW/Source/Object/ObjectClient/Corpse_C.h"
#include "WoW/Source/Object/ObjectClient/DynamicObject_C.h"
#include "WoW/Source/Object/ObjectClient/Effect_C.h"
#include "WoW/Source/Object/ObjectClient/GameObject_C.h"
#include "WoW/Source/Object/ObjectClient/Missile_C.h"
#include "WoW/Source/Object/ObjectClient/Player_C.h"
#include "WoW/Source/Object/ObjectClient/Unit_C.h"
#include "WoW/Source/Object/ObjectClient/VehiclePassenger_C.h"
#include "WoW/Source/Object/ObjectClient/Vehicle_C.h"
#include "WoW/Source/ObjectMgrClient/ObjectMgrClient.h"
#include "WoW/Source/SoundInterface/SoundInterface2.h"
#include "WoW/Source/UIUtil/Camera.h"
#include "WoW/Source/UIUtil/Cursor.h"
#include "WoW/Source/UIUtil/InputControl.h"
#include "WoW/Source/UIUtil/PortraitButton.h"
#include "WoW/Source/UIUtil/SmartScreenRect.h"
#include "WoW/Source/UIUtil/Tooltip.h"
#include "WoW/Source/Ui/BattlefieldInfo.h"
#include "WoW/Source/Ui/CGCooldown.h"
#include "WoW/Source/Ui/CGQuestPOIFrame.h"
#include "WoW/Source/Ui/CGWorldStateInfo.h"
#include "WoW/Source/Ui/CharacterModelBase.h"
#include "WoW/Source/Ui/ChatBubbleFrame.h"
#include "WoW/Source/Ui/CommentatorFrame.h"
#include "WoW/Source/Ui/DressUpModelFrame.h"
#include "WoW/Source/Ui/GameUI.h"
#include "WoW/Source/Ui/MailInfo.h"
#include "WoW/Source/Ui/MinimapFrame.h"
#include "WoW/Source/Ui/NamePlateFrame.h"
#include "WoW/Source/Ui/ScriptEvents.h"
#include "WoW/Source/Ui/TabardModelFrame.h"
#include "WoW/Source/Ui/UIBindings.h"
#include "WoW/Source/Ui/UIMacros.h"
#include "WoW/Source/WorldClient/Barrier.h"
#include "WoW/Source/WorldClient/DayNight.h"
#include "WoW/Source/WorldClient/DayNight__DNInfo.h"
#include "WoW/Source/WorldClient/FrameTime.h"
#include "WoW/Source/WorldClient/Map.h"
#include "WoW/Source/WorldClient/MapEntity.h"
#include "WoW/Source/WorldClient/MapWeather.h"
#include "WoW/Source/WorldClient/World.h"
#include <cfloat>
#include <cmath>
#include "WoW/Source/Ui/SpellBookFrame.h"
// STATIC: 0x009F9864
static const uint32_t s_skinCursorModes[2] = { 21, 20 };
// STATIC: 0x009F986C
static const uint32_t s_skinCursorModesUnable[2] = { 47, 46 };
// STATIC: 0x00AC799C
static const char* s_spellShadowTextureNames[2] = { "Interface\\SpellShadow\\Spell-Shadow-Acceptable.blp", "Interface\\SpellShadow\\Spell-Shadow-Unacceptable.blp" };
// STATIC: 0x00AC79A4
static int32_t s_spellShadowStyle = 3;
// STATIC: 0x00B74350
static CTexture* s_spellShadowTexture[2];
// STATIC: 0x00B74370
static float s_spellShadowSize;
// STATIC: 0x00B74380
static C3Vector s_spellShadowPos;
// STATIC: 0x00B74358
static CVar* s_listenerAtCharacterVar;
// STATIC: 0x00B7435C
FFX::Effect* CGWorldFrame::ffxEffectSwirlingFog;
// STATIC: 0x00B74360
FFX::Effect* CGWorldFrame::ffxEffectNetherWorld;
// STATIC: 0x00B74364
FFX::Effect* CGWorldFrame::ffxEffectGlow;
// STATIC: 0x00B74368
FFX::Effect* CGWorldFrame::ffxEffectDeath;
// STATIC: 0x00B7436C
CGWorldFrame* CGWorldFrame::s_currentWorldFrame;
// STATIC: 0x00B74394
CDataAllocator CGWorldFrame::s_worldFrameHeap(sizeof(CGWorldFrame), 1);
// STATIC: 0x00B743A8
static char s_keyNameBuffer[8];
// VERIFY: d8525c88 auto
// OFFSET: 0x004F5960
CGCamera* CGWorldFrame::GetActiveCamera() {
if (CGWorldFrame::s_currentWorldFrame) {
return CGWorldFrame::s_currentWorldFrame->m_camera;
}
return nullptr;
}
// VERIFY: 407a59b7 manual
// OFFSET: 0x004F59F0
void __stdcall CGWorldFrame::CursorTrackObject(CGGameObject_C* object) {
int32_t mode = object->CanChangeCursor();
if (!mode) {
CursorResetMode();
} else if (mode == 53) {
char file[260];
object->GetCursorFile(file, sizeof(file));
CursorSetFromName(file);
} else {
CursorSetMode(mode);
}
}
// VERIFY: 65d31796 auto
// OFFSET: 0x004F5A60
int32_t CGWorldFrame::OnLayerTrackUpdate(const CMouseEvent& evt) {
int32_t result = CSimpleFrame::OnLayerTrackUpdate(evt);
if (!result) {
return result;
}
CGInputControl::GetActive();
return 1;
}
// VERIFY: dce627fd auto
// OFFSET: 0x004F5D20
void CGWorldFrame::OnMouseModeNormal() {
this->m_worldFlags &= ~0x2;
}
// VERIFY: f3392eff auto
// OFFSET: 0x004F5D80
void CGWorldFrame::SetNamePlateUpdate() {
this->m_namePlateFlags |= 0x1;
}
// VERIFY: c20f460f auto
// OFFSET: 0x004F58E0
int32_t CGWorldFrame::CanTargetCorpseSelection(const CGCorpse_C* corpse, uint32_t flags) {
if (Spell_C_IsTargeting()) {
return Spell_C_CanTargetCorpse(corpse);
}
return 1;
}
// VERIFY: 906e0891 auto
// OFFSET: 0x004F6270
static int32_t GetObjectHitTestType(CGObject_C* object) {
if (!object) {
return 0;
}
switch (object->m_obj->m_type) {
case TYPEMASK_OBJECT | TYPEMASK_UNIT:
case TYPEMASK_OBJECT | TYPEMASK_UNIT | TYPEMASK_PLAYER: {
CGUnit_C* unit = static_cast<CGUnit_C*>(object);
if (unit->m_unit->m_unitFieldHealth > 0) {
return 3;
}
return unit->CanBeLooted(OsGetAsyncTimeMs()) ? 2 : 0;
}
case TYPEMASK_OBJECT | TYPEMASK_GAMEOBJECT:
return static_cast<CGGameObject_C*>(object)->CanUse() ? 1 : 0;
case TYPEMASK_OBJECT | TYPEMASK_CORPSE:
return static_cast<CGCorpse_C*>(object)->CanBeLooted() ? 2 : 0;
default:
return 0;
}
}
// VERIFY: d69961a6 auto
// OFFSET: 0x004F6370
static void AddModelToHitTest(CM2Model* model, uint32_t group, void* owner, uint32_t mode) {
if (model->m_fFlags & 0x1) {
if (!model->m_hitTestPrev) {
CM2Model** head = &model->m_scene->m_hitTestList;
model->m_hitTestPrev = head;
model->m_hitTestNext = *head;
*head = model;
if (model->m_hitTestNext) {
model->m_hitTestNext->m_hitTestPrev = &model->m_hitTestNext;
}
}
model->m_hitTestMode = mode;
model->m_hitTestGroup = group;
model->m_hitTestOwner = owner;
}
for (CM2Model* attached = model->m_attachList; attached; attached = attached->m_attachNext) {
if (!attached->m_hitTestPrev) {
AddModelToHitTest(attached, group, reinterpret_cast<void*>(-1), mode);
}
}
}
// VERIFY: 7714957c manual
// OFFSET: 0x004F6400
void CGWorldFrame::AddObjectToHitTestList(CModelRecord* record, uint32_t flags) {
uint32_t group;
if (record->m_guid == this->m_hitGuid) {
group = -1;
} else {
group = GetObjectHitTestType(record->m_object);
}
record->m_object = nullptr;
AddModelToHitTest(record->m_model, group, record, (flags >> 25) & 0x4);
}
// VERIFY: 611dc17c manual
// OFFSET: 0x004F6450
int32_t CGWorldFrame::GetLineSegment(float mouseX, float mouseY, C3Vector* start, C3Vector* end) {
float x = (mouseX - this->m_viewportDDC.minX) / (this->m_viewportDDC.maxX - this->m_viewportDDC.minX);
float y = (mouseY - this->m_viewportDDC.minY) / (this->m_viewportDDC.maxY - this->m_viewportDDC.minY);
if (x < 0.0f || y < 0.0f || x > 1.0f || y > 1.0f) {
return 0;
}
CameraGetLineSegment(x, y, start, end);
C3Vector position = this->m_camera->m_position;
*start += position;
*end += position;
return 1;
}
// VERIFY: 0b3308f3 manual
// OFFSET: 0x004F6650
void CGWorldFrame::GetCameraPosition(C3Vector* position) {
*position = CGWorldFrame::s_currentWorldFrame->m_camera->m_position;
}
// VERIFY: c8cc818e auto
// OFFSET: 0x004F66C0
void CGWorldFrame::OnLayerTrackTerrain(const HITTESTRESULT& result) {
if (!Spell_C_IsTargeting() || !Spell_C_CanTargetTerrain()) {
CursorResetMode();
this->HandleSpriteTrack(WOWGUID());
return;
}
s_spellShadowPos = result.m_point;
CTerrainClickEvent evt;
evt.m_point = s_spellShadowPos;
evt.m_guid = WOWGUID();
if ((result.m_guid.m_guid & 0xF000000000000000ull) == 0x1000000000000000ull && (result.m_guid.m_guid & 0x0FF0000000000000ull) == 0x0FC0000000000000ull) {
CGObject_C* transport = ClntObjMgrObjectPtr(result.m_guid, TYPEMASK_OBJECT, __FILE__, __LINE__);
if (transport) {
evt.m_guid = result.m_guid;
s_spellShadowPos *= transport->GetMatrix();
}
}
Spell_C_SetCursorWorldObjectPosition(s_spellShadowPos);
switch (Spell_C_HandleTerrainRay(evt, true)) {
case 0: {
s_spellShadowStyle = 0;
float radius = Spell_C_GetSpellRadius();
s_spellShadowSize = radius > 20.0f ? 20.0f : Spell_C_GetSpellRadius();
CursorSetMode(2);
break;
}
case 1:
s_spellShadowStyle = 1;
s_spellShadowSize = 0.0f;
CursorSetMode(28);
break;
case 2:
s_spellShadowStyle = 3;
s_spellShadowSize = 0.0f;
CursorSetMode(28);
break;
}
CMapEntity* entity = Spell_C_GetSpellWorldObject();
if (!entity) {
return;
}
CM2Model* model = Spell_C_GetCursorWorldObjectModel();
CAaBox box;
box.b = C3Vector(0.0f, 0.0f, 0.0f);
box.t = C3Vector(0.0f, 0.0f, 0.0f);
CAaSphere sphere;
C3Vector center = { 0.0f, 0.0f, 0.0f };
if (model->IsLoaded(0, 0)) {
box = model->GetBoundingBox();
sphere = model->GetBoundingSphere();
center = sphere.c;
}
C44Matrix matrix;
const C3Vector& position = Spell_C_GetCursorWorldObjectPosition();
matrix.d0 = position.x;
matrix.d1 = position.y;
matrix.d2 = position.z;
matrix.RotateAroundZ(Spell_C_GetCursorWorldObjectFacing());
CMap::ObjectUpdate(entity, matrix, box, sphere, center, false, 0xFFFFFFFF);
World::ObjectSetHidden(entity, s_spellShadowStyle != 0);
}
// VERIFY: 364a9bc8 auto
// OFFSET: 0x004F6680
void CGWorldFrame::GetCameraFacing(C3Vector* facing) {
*facing = CGWorldFrame::s_currentWorldFrame->m_camera->Forward();
}
// VERIFY: 1f9c430b manual
// OFFSET: 0x004F6D20
bool CGWorldFrame::GetScreenCoordinates(const C3Vector& world, C3Vector* screen, uint32_t* result) {
const C3Vector& camera = this->m_camera->m_position;
C4Vector relative;
relative.x = world.x - camera.x;
relative.y = world.y - camera.y;
relative.z = world.z - camera.z;
relative.w = 0.0f;
C4Vector projected = relative * this->m_viewProjection;
if (projected.z < this->m_camera->m_nearZ) {
return false;
}
screen->z = projected.z;
float invW = 1.0f / projected.w;
float ndcX = (projected.x * invW + 1.0f) * 0.5f;
float ndcY = (projected.y * invW + 1.0f) * 0.5f;
float ddcX;
float ddcY;
NDCToDDC(ndcX * (this->m_viewportNDC.maxX - this->m_viewportNDC.minX), ndcY * (this->m_viewportNDC.maxY - this->m_viewportNDC.minY), &ddcX, &ddcY);
if (this->m_rect.minX < 0.0f) {
ddcX -= this->m_rect.minX;
}
if (this->m_rect.minY < 0.0f) {
ddcY -= this->m_rect.minY;
}
screen->x = ddcX;
screen->y = ddcY;
float width = this->m_rect.maxX - this->m_rect.minX;
float height = this->m_rect.maxY - this->m_rect.minY;
if (!result) {
return ddcX >= 0.0f && width >= ddcX && ddcY >= 0.0f && height >= ddcY;
}
uint32_t flags = (ddcX >= 0.0f ? 0x1 : 0) | (ddcY >= 0.0f ? 0x2 : 0) | (width >= ddcX ? 0x4 : 0) | (height >= ddcY ? 0x8 : 0);
*result = flags;
return flags == 0xF;
}
// VERIFY: aaab1f42 manual
// OFFSET: 0x004F6F50
void CGWorldFrame::SetCameraTarget(CGObject_C* target, int32_t freeLook) {
this->m_camera->SetTarget(target, freeLook);
if (target && (target->m_obj->m_type & TYPEMASK_UNIT)) {
static_cast<CGUnit_C*>(target)->OnVehicleCameraPossiblyNeeded();
}
}
// VERIFY: 412d637a manual
// OFFSET: 0x004F6F90
void CGWorldFrame::ClearTrackedObjects() {
if (this->m_trackedEffectGuidA) {
CGObject_C* object = ClntObjMgrObjectPtr(this->m_trackedEffectGuidA, TYPEMASK_OBJECT, __FILE__, __LINE__);
if (object) {
object->RenderTargetSelection();
}
this->m_trackedEffectGuidA = WOWGUID();
}
if (this->m_trackedEffectGuidB) {
CGObject_C* object = ClntObjMgrObjectPtr(this->m_trackedEffectGuidB, TYPEMASK_OBJECT, __FILE__, __LINE__);
if (object) {
object->RenderPetTargetSelection();
}
this->m_trackedEffectGuidB = WOWGUID();
}
}
// VERIFY: 8d2db281 manual
// OFFSET: 0x004F7350
int32_t CGWorldFrame::IsUnitLegalSelection(CGUnit_C* unit, uint32_t flags) {
if (!(flags & 0x20)) {
if (unit->IsActivePlayer()) {
return 0;
}
WOWGUID activePlayer = ClntObjMgrGetActivePlayer();
if (unit->IsPossessedBy(activePlayer)) {
return 0;
}
}
if (flags & 0xF0000) {
CGPlayer_C* player = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(ClntObjMgrGetActivePlayer(), TYPEMASK_PLAYER, __FILE__, __LINE__));
uint32_t friends = flags & 0x40000;
if (friends && !player->CanAssist(unit, false)) {
return (flags & 0x800000) && unit->m_unit->m_unitFieldCharmedby && player->CanAttack(unit);
}
if (!((flags & 0x10000) && player->IsInMyPartyOrRaid(unit)) && !((flags & 0x20000) && player->IsInMyParty(unit)) && !(friends && player->CanAssist(unit, false)) && !((flags & 0x80000) && player->CanAttack(unit))) {
return 0;
}
}
if (flags & 0x300000) {
if (unit->m_unit->m_unitFieldHealth > 0 ? !(flags & 0x100000) : !(flags & 0x200000)) {
return 0;
}
}
if ((flags & 0x400000) && unit->GetCreatureType() == 12) {
return 1;
}
if (!Spell_C_IsTargeting()) {
return 1;
}
bool restricted = (unit->m_unit->m_unitFieldFlags >> 8) & 1;
if (restricted) {
SpellRec spell;
if (g_spellDB.GetRecord(Spell_C_GetTargetingSpell(), &spell) && ((spell.m_attributesExC & 0x10000000) || (spell.m_attributesExE & 0x200000))) {
return 1;
}
}
return !restricted;
}
// VERIFY: 120569f0 auto
// OFFSET: 0x004F7530
int32_t CGWorldFrame::IsLegalSelection(CGObject_C* object, uint32_t flags) {
switch (object->m_obj->m_type) {
case TYPEMASK_OBJECT | TYPEMASK_UNIT | TYPEMASK_PLAYER:
if (!(flags & 0x10)) {
return 0;
}
return this->IsUnitLegalSelection(static_cast<CGUnit_C*>(object), flags);
case TYPEMASK_OBJECT | TYPEMASK_UNIT:
if (!(flags & 0x8)) {
return 0;
}
return this->IsUnitLegalSelection(static_cast<CGUnit_C*>(object), flags);
case TYPEMASK_OBJECT | TYPEMASK_GAMEOBJECT:
if (!(flags & 0x4) || (Spell_C_IsTargeting() && !Spell_C_CanTargetObject(static_cast<CGGameObject_C*>(object)))) {
return 0;
}
return 1;
case TYPEMASK_OBJECT | TYPEMASK_CORPSE:
if (!(flags & 0x40)) {
return 0;
}
return this->CanTargetCorpseSelection(static_cast<CGCorpse_C*>(object), flags);
default:
return 0;
}
}
// VERIFY: 4da5a71a manual
// OFFSET: 0x004F7650
uint32_t CGWorldFrame::GetHitTestFilterFlags(int32_t a1) {
if (Spell_C_IsTargeting()) {
uint32_t flags = 0;
if (Spell_C_CanTargetTerrain()) {
flags = 0x3;
}
if (Spell_C_CanTargetObjects()) {
flags |= 0x4;
}
if (Spell_C_CanTargetUnits()) {
flags |= 0x18;
if (Spell_C_CanTargetMe()) {
flags |= 0x20;
}
if (Spell_C_CanTargetParty()) {
flags |= 0x10000;
}
if (Spell_C_CanTargetFriends()) {
flags |= 0x40000;
}
if (Spell_C_CanTargetEnemies()) {
flags |= 0x80000;
}
if (Spell_C_CanTargetRaid()) {
flags |= 0x20000;
}
if (Spell_C_CanTargetDead()) {
flags |= 0x200040;
}
if (Spell_C_CanTargetAlive()) {
flags |= 0x100000;
}
if (Spell_C_CanTargetNonCombatPet()) {
flags |= 0x400000;
}
if (Spell_C_CanTargetPossessedFriends()) {
flags |= 0x800000;
}
}
if (Spell_C_CanTargetFriendCorpses()) {
flags |= 0x40040;
}
if (Spell_C_CanTargetEnemyCorpses()) {
flags |= 0x80040;
}
return flags;
}
CGPlayer_C* player = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(ClntObjMgrGetActivePlayer(), TYPEMASK_PLAYER, __FILE__, __LINE__));
uint32_t flags = 0;
CGUnit_C* mover = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(CGUnit_C::s_activeMover, TYPEMASK_UNIT, __FILE__, __LINE__));
if (mover && mover->CanAutoInteract() && !CGGameUI::m_cursorItemType) {
uint32_t moveFlags = mover->m_movement->m_flags;
flags = 1;
if ((moveFlags & 0x10000000) && !(moveFlags & 0x200000)) {
flags = 3;
}
}
if (player) {
flags |= 0x5C;
}
return flags;
}
// VERIFY: d619b75b manual
// OFFSET: 0x004F7A50
void __stdcall CGWorldFrame::CursorTrackUnit(CGUnit_C* unit) {
CGPlayer_C* player = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(ClntObjMgrGetActivePlayer(), TYPEMASK_PLAYER, __FILE__, __LINE__));
if (!player) {
return;
}
if (((player->m_combatModeFlags & 1) && player->GetTransportGUID() != player->GetFarSightGuid()) || !player->VehicleAllowsInteraction()) {
CGUnit_C* possessed = player->GetPossessedUnit();
if (unit->m_unit->m_unitFieldHealth > 0 && possessed && possessed->CanAttackNow(unit)) {
CursorSetMode(4);
} else {
CursorResetMode();
}
return;
}
float distance = player->GetDistanceToPos(unit->GetPosition());
if (player->CanInteractNow(unit) && unit->m_unit->m_unitNpcFlags) {
float reach = unit->m_unit->m_unitFieldCombatreach + 4.0f;
int32_t unable = reach * reach < distance;
int32_t mode = unit->GetCursorOverride(unable);
if (mode) {
if (mode == 53) {
char file[260];
unit->GetCursorFile(unable, file, sizeof(file));
CursorSetFromName(file);
} else {
CursorSetMode(mode);
}
return;
}
uint32_t flags = unit->m_unit->m_unitNpcFlags;
if (flags & 0x1000) {
CursorSetMode(unable ? 44 : 18);
} else if (flags & 0x10000) {
CursorSetMode(unable ? 48 : 22);
} else if (flags & 0x2000) {
CursorSetMode(unable ? 35 : 9);
} else if (flags & 0x10) {
CursorSetMode(unable ? 36 : 10);
} else if ((flags & 0x4000) || (flags & 0x8000)) {
CursorSetMode(unable ? 32 : 6);
} else if ((flags & 0x20000) || (flags & 0x800000)) {
CursorSetMode(unable ? 29 : 3);
} else if ((flags & 0x40000) || (flags & 0x80000) || unit->IsGuildMaster() || (flags & 0x100000)) {
CursorSetMode(unable ? 32 : 6);
} else if (flags & 0x200000) {
CursorSetMode(unable ? 29 : 3);
} else if (flags & 0x400000) {
CursorSetMode(unable ? 32 : 6);
} else if (flags & 0x80) {
CursorSetMode(unable ? 34 : 8);
} else if (flags & 0x1) {
CursorSetMode(unable ? 32 : 6);
} else if (flags & 0x1000000) {
CursorSetMode(unable ? 31 : 5);
} else if (unit->CanBeSpellClickedByLocalPlayer(player)) {
CursorSetMode(unable ? 52 : 26);
} else {
CursorResetMode();
}
return;
}
if (unit->CanBeLooted(FrameTime::s_curTimeMs)) {
if (player->CanLoot(unit) || player->m_lootTarget == unit->m_obj->m_guid) {
CursorSetMode(CGGameUI::IsAutoLooting() ? 16 : 8);
} else {
CursorSetMode(CGGameUI::IsAutoLooting() ? 42 : 34);
}
return;
}
if ((unit->m_unit->m_unitFieldFlags & 0x4000000) && CGSpellBook::GetSkinningSpell(unit) && !((unit->m_obj->m_type & TYPEMASK_PLAYER) && player->CanAssist(unit, false))) {
float minRange;
float maxRange;
Spell_C::GetSpellRange(player, CGSpellBook::GetSkinningSpell(unit), &minRange, &maxRange, unit);
if (unit->m_obj->m_type & TYPEMASK_PLAYER) {
if (maxRange * maxRange < distance) {
CursorSetMode(s_skinCursorModesUnable[player->GetPVPFactionIndex()]);
} else {
CursorSetMode(s_skinCursorModes[player->GetPVPFactionIndex()]);
}
return;
}
switch (unit->GetSkinningType()) {
case 0:
CursorSetMode(maxRange * maxRange < distance ? 38 : 12);
return;
case 1:
CursorSetMode(maxRange * maxRange < distance ? 39 : 13);
return;
case 2:
CursorSetMode(maxRange * maxRange < distance ? 37 : 11);
return;
case 3:
CursorSetMode(maxRange * maxRange < distance ? 37 : 11);
return;
default:
CursorResetMode();
return;
}
}
if (!player->CanAttackNow(unit) || (player->m_unit->m_unitFieldFlags & 0x20000) || !CGGameUI::m_hasControl) {
CursorResetMode();
return;
}
float range = player->GetMeleeRange(unit);
if (range * range < distance) {
CursorSetMode(30);
} else {
CursorSetMode(4);
}
}
// VERIFY: 3106c989 manual
// OFFSET: 0x004F8000
void __stdcall CGWorldFrame::CursorTrackCorpse(CGCorpse_C* corpse) {
CGPlayer_C* player = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(ClntObjMgrGetActivePlayer(), TYPEMASK_PLAYER, __FILE__, __LINE__));
if (!player) {
return;
}
C3Vector corpsePosition = corpse->GetPosition();
C3Vector position = player->GetPosition();
float dx = position.x - corpsePosition.x;
float dy = position.y - corpsePosition.y;
float dz = position.z - corpsePosition.z;
float distance = dx * dx + dz * dz + dy * dy;
if (corpse->CanBeLooted()) {
if (player->CanLoot(corpse) || player->m_lootTarget == corpse->m_obj->m_guid) {
CursorSetMode(CGGameUI::IsAutoLooting() ? 16 : 8);
} else {
CursorSetMode(CGGameUI::IsAutoLooting() ? 42 : 34);
}
return;
}
const CGUnit_C* asUnit = reinterpret_cast<const CGUnit_C*>(corpse);
if ((corpse->m_corpse->m_corpseFieldFlags & 0x20) && CGSpellBook::GetSkinningSpell(asUnit) && !player->CanAssist(corpse)) {
float minRange;
float maxRange;
Spell_C::GetSpellRange(player, CGSpellBook::GetSkinningSpell(asUnit), &minRange, &maxRange, nullptr);
if (maxRange * maxRange < distance) {
CursorSetMode(s_skinCursorModesUnable[player->GetPVPFactionIndex()]);
} else {
CursorSetMode(s_skinCursorModes[player->GetPVPFactionIndex()]);
}
return;
}
CursorResetMode();
}
// VERIFY: 92cbc82b manual
// OFFSET: 0x004F8190
void CGWorldFrame::OnLayerTrackObject(const HITTESTRESULT& result) {
if (this->m_worldFlags & 0x2) {
this->HandleSpriteTrack(WOWGUID());
return;
}
if (Spell_C_IsTargeting()) {
WOWGUID guid = result.m_guid;
CursorSetMode(Spell_C::HandleSpriteRay(guid, true) ? 2 : 28);
this->HandleSpriteTrack(result.m_guid);
return;
}
CGPlayer_C* player = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(ClntObjMgrGetActivePlayer(), TYPEMASK_PLAYER, __FILE__, __LINE__));
CGObject_C* object = ClntObjMgrObjectPtr(result.m_guid, TYPEMASK_OBJECT, __FILE__, __LINE__);
if (!player || !object || !object->CanHighlight()) {
CursorResetMode();
this->HandleSpriteTrack(WOWGUID());
return;
}
if (result.m_distance == 0.0f) {
CursorResetMode();
this->HandleSpriteTrack(result.m_guid);
return;
}
switch (object->m_obj->m_type) {
case TYPEMASK_OBJECT | TYPEMASK_ITEM:
CursorSetMode(8);
break;
case TYPEMASK_OBJECT | TYPEMASK_UNIT:
case TYPEMASK_OBJECT | TYPEMASK_UNIT | TYPEMASK_PLAYER:
CGWorldFrame::CursorTrackUnit(static_cast<CGUnit_C*>(object));
break;
case TYPEMASK_OBJECT | TYPEMASK_GAMEOBJECT:
CGWorldFrame::CursorTrackObject(static_cast<CGGameObject_C*>(object));
break;
case TYPEMASK_OBJECT | TYPEMASK_CORPSE:
CGWorldFrame::CursorTrackCorpse(static_cast<CGCorpse_C*>(object));
break;
default:
CursorResetMode();
break;
}
this->HandleSpriteTrack(result.m_guid);
}
// VERIFY: f0b2f3d4 manual
// OFFSET: 0x004F77C0
CGWorldFrameUnkObj::CGWorldFrameUnkObj() {
for (int32_t i = 0; i < 16; i++) {
CGWorldFrameUnkObjSomeElement& element = this->m_elements[i];
element.unk_0014 = 0.0f;
element.unk_0018 = 0.0f;
element.unk_001C = 0.0f;
element.unk_0020 = 0.0f;
element.unk_0024 = 0.0f;
element.unk_0028 = 0.0f;
element.unk_002C = 0.0f;
element.unk_0030 = 0.0f;
element.unk_0034 = 0.0f;
element.unk_0038 = 0.0f;
}
for (int32_t i = 0; i < 13; i++) {
this->m_tail[i] = 0.0f;
}
}
// VERIFY: 9d07413d manual
// OFFSET: 0x004F8660
void CGWorldFrame::SetPlayerFadeCameraValue(uint8_t value) {
if (this->m_camera->m_targetGUID == ClntObjMgrGetActivePlayer()) {
Player_C_SetPlayerRenderDisabled(value != 0);
}
CGUnit_C* unit = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(this->m_camera->m_targetGUID, TYPEMASK_UNIT, __FILE__, __LINE__));
if (!unit) {
return;
}
if ((unit->m_vehicle && unit->m_vehicle->m_vehicleRec) || (unit->m_vehiclePassenger && unit->m_vehiclePassenger->m_state == 3)) {
unit = unit->m_vehiclePassenger ? unit->m_vehiclePassenger->GetStoredRootVehicleUnit() : unit->FindRootVehicle(nullptr);
if (!unit) {
return;
}
}
unit->SetMaxAlpha(value * (1.0f / 255.0f));
}
// VERIFY: 4da3f8e7 manual
// OFFSET: 0x004F8770
void CGWorldFrame::UpdateScreenEffectParams() {
if (FFX::s_effect != CGWorldFrame::ffxEffectGlow) {
return;
}
float glow = DayNight::GetInfo()->m_bands.m_glow * 255.0f + 512.0f;
uint8_t glowLevel = *reinterpret_cast<uint32_t*>(&glow) >> 14;
int32_t underwater = 0;
uint8_t minimum = 0;
uint8_t level = minimum;
if (ClntObjMgrGetCurrent()) {
CGPlayer_C* player = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(ClntObjMgrGetActivePlayer(), TYPEMASK_PLAYER, __FILE__, __LINE__));
if (player) {
float drunk = player->GetDrunknessTurnValue() * 255.0f + 512.0f;
uint8_t drunkLevel = *reinterpret_cast<uint32_t*>(&drunk) >> 14;
if (World::SceneCamLiquidStatus(nullptr)) {
minimum = 84;
underwater = 1;
}
level = drunkLevel > minimum ? drunkLevel : minimum;
}
}
int32_t params[3] = { underwater, glowLevel, level };
CGWorldFrame::ffxEffectGlow->SetParameters(3, params);
}
// VERIFY: b33f52c2 manual
// OFFSET: 0x004F9310
void CGWorldFrame::MoveToFreeList(TSList<CModelRecord, TSGetLink<CModelRecord> >* list) {
for (CModelRecord* record = list->Head(); record; record = list->Next(record)) {
if (record->m_model) {
record->m_model->Release();
record->m_model = nullptr;
}
}
this->m_freeModelList.Combine(list, 2, nullptr);
}
// VERIFY: abfda7eb manual
// OFFSET: 0x004F9410
bool CGWorldFrame::HitTestModelList(const C3Vector& start, const C3Vector& end) {
C44Matrix view;
CGxMatrixStack& stack = g_theGxDevicePtr->m_xforms[GxXform_View];
view = stack.m_mtx[stack.m_level];
C3Vector camera = this->m_camera->m_position;
C3Vector viewStart = (start - camera) * view;
C3Vector viewEnd = (end - camera) * view;
World::s_m2Scene->BeginHitTest();
for (CModelRecord* record = this->m_modelList.Head(); record; record = this->m_modelList.Next(record)) {
AddModelToHitTest(record->m_model, 0, record, 0);
}
float t = 1.0f;
return World::s_m2Scene->EndHitTest(viewStart, viewEnd, t, 0) != nullptr;
}
// VERIFY: 7c925d58 manual
// OFFSET: 0x004F9550
uint64_t CGWorldFrame::FindClosestModel(const C3Vector& start, const C3Vector& end, uint32_t flags, float* distance) {
C44Matrix view;
CGxMatrixStack& stack = g_theGxDevicePtr->m_xforms[GxXform_View];
view = stack.m_mtx[stack.m_level];
C3Vector camera = this->m_camera->m_position;
C3Vector viewStart = (start - camera) * view;
C3Vector viewEnd = (end - camera) * view;
TSList<CModelRecord, TSGetLink<CModelRecord> > lowPriority;
uint32_t time = OsGetAsyncTimeMs();
World::s_m2Scene->BeginHitTest();
int32_t allowsTerrain = Spell_C_TargetingSpellAllowsTerrain();
for (CModelRecord* record = this->m_modelList.Head(); record;) {
CModelRecord* next = this->m_modelList.Next(record);
CGObject_C* object = ClntObjMgrObjectPtr(record->m_guid, TYPEMASK_OBJECT, __FILE__, __LINE__);
if (object && this->IsLegalSelection(object, flags) && (object->CanHighlight() || allowsTerrain)) {
record->m_object = object;
if ((object->m_obj->m_type & TYPEMASK_UNIT) && static_cast<CGUnit_C*>(object)->IsLowPrioritySelection(time)) {
lowPriority.LinkToTail(record);
} else {
this->AddObjectToHitTestList(record, flags);
}
}
record = next;
}
float t = 1.0f;
CModelRecord* hit = static_cast<CModelRecord*>(World::s_m2Scene->EndHitTest(viewStart, viewEnd, t, 1));
if (!hit) {
World::s_m2Scene->BeginHitTest();
for (CModelRecord* record = lowPriority.Head(); record; record = lowPriority.Next(record)) {
this->AddObjectToHitTestList(record, flags);
}
t = 1.0f;
hit = static_cast<CModelRecord*>(World::s_m2Scene->EndHitTest(viewStart, viewEnd, t, 1));
}
this->m_modelList.Combine(&lowPriority, 2, nullptr);
if (!hit) {
return 0;
}
C3Vector delta = viewEnd - viewStart;
float hitDistance = sqrt(delta.x * delta.x + delta.y * delta.y + delta.z * delta.z) * t;
hit->m_distance = hitDistance;
*distance = hitDistance;
return hit->m_guid.m_guid;
}
// VERIFY: d0d131d0 manual
// OFFSET: 0x004F9930
int32_t CGWorldFrame::HitTest(const C3Vector& start, const C3Vector& end, uint32_t flags, HITTESTRESULT* result) {
C3Vector hitPoint = { 0.0f, 0.0f, 0.0f };
float t = 1.0f;
float objectDistance = 0.0f;
WOWGUID collision = WOWGUID();
uint32_t worldFlags = (flags & 0x2) ? 0x1020124 : 0x1000124;
C3Vector point = end;
C3Vector direction = point - start;
float length = direction.x * direction.x + direction.y * direction.y + direction.z * direction.z;
if (fabs(length) >= 0.00000023841858f) {
length = sqrt(length);
float inverse = 1.0f / length;
direction.x *= inverse;
direction.y *= inverse;
direction.z *= inverse;
}
int32_t hitWorld = World::Intersect(start, point, &hitPoint, &t, worldFlags, nullptr) != 0;
if (hitWorld) {
if (t < -0.001f || t > 1.001f || !_finite(t)) {
DebugLog("CWorld::Intersect() returned a bogus value for terrDist: %f", static_cast<double>(t));
}
length *= t;
collision = s_lastCollisionGUID;
point.x = direction.x * length + start.x;
point.y = direction.y * length + start.y;
point.z = direction.z * length + start.z;
t = length;
}
WOWGUID model = WOWGUID();
if (flags & 0x7C) {
model.m_guid = this->FindClosestModel(start, point, flags, &objectDistance);
if (model) {
if (objectDistance < -0.001f || !_finite(objectDistance)) {
DebugLog("CGWorldFrame::FindClosestModel() returned a bogus value for objDist: %f", static_cast<double>(objectDistance));
}
length = objectDistance;
point.x = direction.x * objectDistance + start.x;
point.y = direction.y * objectDistance + start.y;
point.z = objectDistance * direction.z + start.z;
}
}
uint32_t terrain = flags & 0x3;
if (terrain) {
t = 1.0f;
if (World::Intersect(start, point, &hitPoint, &t, 0x100151, nullptr)) {
if (t < -0.001f || t > 1.001f || !_finite(t)) {
DebugLog("CWorld::Intersect() returned a bogus value for terrDist: %f", static_cast<double>(t));
}
length *= t;
collision = s_lastCollisionGUID;
hitWorld = 1;
point.x = direction.x * length + start.x;
point.y = direction.y * length + start.y;
point.z = direction.z * length + start.z;
t = length;
}
}
C3Vector screen;
screen.z = 0.0f;
if (this->GetScreenCoordinates(point, &screen, nullptr)) {
g_theGxDevicePtr->CursorSetDepth(screen.z);
}
if (model) {
result->m_distance = objectDistance;
result->m_point = point;
result->m_guid = model;
return 2;
}
if (!hitWorld) {
return 0;
}
if (collision) {
result->m_point = point;
CGObject_C* object = ClntObjMgrObjectPtr(collision, TYPEMASK_OBJECT, __FILE__, __LINE__);
if (object) {
result->m_guid = collision;
if (object->IsTransport()) {
C44Matrix inverse = object->GetMatrix().AffineInverse();
result->m_point *= inverse;
}
} else {
result->m_guid = WOWGUID();
}
result->m_distance = t;
return 3;
}
result->m_point = point;
result->m_distance = t;
result->m_guid = WOWGUID();
return terrain != 0;
}
// VERIFY: 53a93536 auto
// OFFSET: 0x004F9DA0
int32_t CGWorldFrame::HitTestPoint(float x, float y, int32_t a3, HITTESTRESULT* result) {
if (!(CGInputControl::GetActive()->m_mouseModeFlags & 0x1)) {
return 0;
}
CGxDevice* device = g_theGxDevicePtr;
C44Matrix projection;
C44Matrix view;
projection = device->m_projection;
CGxMatrixStack& stack = device->m_xforms[GxXform_View];
view = stack.m_mtx[stack.m_level];
this->m_camera->SetupWorldProjection(this->m_viewportDDC);
int32_t kind = 0;
uint32_t flags = this->GetHitTestFilterFlags(a3);
if (flags) {
C3Vector start = { 0.0f, 0.0f, 0.0f };
C3Vector end = { 0.0f, 0.0f, 0.0f };
if (this->GetLineSegment(x, y, &start, &end)) {
result->m_segStart = start;
result->m_segEnd = end;
kind = this->HitTest(start, end, flags, result);
if (kind >= 2) {
this->m_hitGuid = result->m_guid;
} else {
this->MoveToFreeList(&this->m_hitModelList);
this->m_hitGuid = WOWGUID();
}
}
}
g_theGxDevicePtr->XformSetProjection(projection);
g_theGxDevicePtr->XformSetView(view);
return kind;
}
// VERIFY: 21cb1ac2 auto
// OFFSET: 0x004FA5D0
void CGWorldFrame::UnitClear() {
this->MoveToFreeList(&this->m_modelList);
this->MoveToFreeList(&this->m_hitModelList);
}
// VERIFY: 0cec28f7 manual
// OFFSET: 0x004FABD0
CGWorldFrame::CGWorldFrame(CSimpleFrame* parent) : CSimpleFrame(parent) {
this->unk_02C0 = 1;
this->unk_02C4 = 1;
this->m_trackedGuid = WOWGUID();
this->m_hitGuid = WOWGUID();
this->m_defaultActionHit.m_guid = WOWGUID();
this->m_defaultActionHit.m_point = { 0.0f, 0.0f, 0.0f };
this->m_defaultActionHit.m_distance = 0.0f;
this->m_defaultActionHit.m_segStart = { 0.0f, 0.0f, 0.0f };
this->m_defaultActionHit.m_segEnd = { 0.0f, 0.0f, 0.0f };
this->m_defaultActionPointDDC = { 0.0f, 0.0f };
this->m_worldFlags = (this->m_worldFlags & ~0x3) | 0x1;
this->m_viewportDDC = { 0.0f, 0.0f, 0.0f, 0.0f };
this->m_viewportNDC = { 0.0f, 0.0f, 0.0f, 0.0f };
this->m_namePlateFlags = 0;
CGWorldFrame::s_currentWorldFrame = this;
this->SetFrameStrata(FRAME_STRATA_WORLD);
this->EnableEvent(SIMPLE_EVENT_KEY, -1);
this->EnableEvent(SIMPLE_EVENT_MOUSE, -1);
this->EnableEvent(SIMPLE_EVENT_MOUSEWHEEL, -1);
memset(this->m_keyDown, 0, sizeof(this->m_keyDown));
memset(this->m_mouseDown, 0, sizeof(this->m_mouseDown));
this->m_camera = new (__FILE__, __LINE__) CGCamera();
s_listenerAtCharacterVar = CVar::Lookup("Sound_ListenerAtCharacter");
this->unk_02C0 = 5;
CStatus status;
for (uint32_t i = 0; i < sizeof(s_spellShadowTexture) / sizeof(s_spellShadowTexture[0]); i++) {
s_spellShadowTexture[i] = TextureCreate(s_spellShadowTextureNames[i], CGxTexFlags(GxTex_Linear), &status, 1);
SysMsgAdd(&status);
}
EventRegisterEx(EVENT_ID_IDLE, CGWorldFrame::Update, this, -1000.0f);
FFX::Init();
CGWorldFrame::ffxEffectGlow = new (__FILE__, __LINE__) EffectGlow();
CGWorldFrame::ffxEffectDeath = new (__FILE__, __LINE__) EffectDeath();
CGWorldFrame::ffxEffectNetherWorld = new (__FILE__, __LINE__) EffectNetherWorld();
CGWorldFrame::ffxEffectSwirlingFog = new (__FILE__, __LINE__) EffectSwirlingFog();
CGWorldFrame::UpdateScreenEffect();
}
// VERIFY: 74e81b7f auto
// OFFSET: 0x0050F3F0
CSimpleFrame* CGWorldFrame::Create(CSimpleFrame* parent) {
void* data = CGWorldFrame::s_worldFrameHeap.GetData(0, typeid(CGWorldFrame).raw_name(), SLOG_OBJECT);
return data ? new (data) CGWorldFrame(parent) : nullptr;
}
// INLINED
void CGWorldFrame::operator delete(void* ptr) {
if (ptr) {
CGWorldFrame::s_worldFrameHeap.PutData(ptr, nullptr, 0);
}
}
// VERIFY: ee139ec8 auto
// OFFSET: 0x00521040
void CGWorldFrame::RegisterFrames() {
FrameXML_RegisterFactory("WorldFrame", CGWorldFrame::Create, true);
FrameXML_RegisterFactory("GameTooltip", CGTooltip::Create, false);
FrameXML_RegisterFactory("Cooldown", CGCooldown::Create, false);
FrameXML_RegisterFactory("Minimap", CGMinimapFrame::Create, false);
FrameXML_RegisterFactory("PlayerModel", CGCharacterModelBase::Create, false);
FrameXML_RegisterFactory("DressUpModel", CGDressUpModelFrame::Create, false);
FrameXML_RegisterFactory("TabardModel", CGTabardModelFrame::Create, false);
FrameXML_RegisterFactory("QuestPOIFrame", CGQuestPOIFrame::Create, false);
}
// VERIFY: d1740d14 manual
// OFFSET: 0x004F7020
void CGWorldFrame::SetScreenEffect(int32_t effect) {
ScreenEffectRec* rec = g_screenEffectDB.GetRecord(effect);
if (!rec) {
DayNight::ClearOverrideFog();
FFX::SetEffect(CGWorldFrame::ffxEffectGlow);
DayNight::ClearOverrideLightParamsID();
SI2::SetOverrideZoneSounds(0, 0);
return;
}
switch (rec->m_effect) {
case 0:
DayNight::ClearOverrideFog();
FFX::SetEffect(CGWorldFrame::ffxEffectGlow);
break;
case 1:
DayNight::ClearOverrideFog();
FFX::SetEffect(CGWorldFrame::ffxEffectDeath);
break;
case 2: {
CImVector color;
if (FFX::s_cvarFFX->m_intValue) {
color.b = 0xFF;
color.g = 0xFF;
color.r = 0xFF;
color.a = 0xFF;
} else {
color.b = 0x63;
color.g = 0x4C;
color.r = 0x4C;
color.a = 0xFF;
}
DayNight::SetOverrideFog(0.7f, 150.0f, color, 0);
FFX::SetEffect(CGWorldFrame::ffxEffectNetherWorld);
break;
}
case 3:
if (g_theGxDevicePtr->DeviceApi()) {
DayNight::ClearOverrideFog();
PassFogSeed::DeviceRestoredCallback();
CGWorldFrame::ffxEffectSwirlingFog->SetParameters(3, rec->m_param);
FFX::SetEffect(CGWorldFrame::ffxEffectSwirlingFog);
} else {
DayNight::ClearOverrideFog();
FFX::SetEffect(CGWorldFrame::ffxEffectGlow);
}
break;
default:
break;
}
DayNight::SetOverrideLightParamsID(rec->m_lightParamsID);
SI2::SetOverrideZoneSounds(rec->m_soundAmbienceID, rec->m_zoneMusicID);
}
// VERIFY: 01c7ec1b manual
// OFFSET: 0x004F8730
int32_t CGWorldFrame::Update(const void* data, void* param) {
CGPlayer_C* player = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(ClntObjMgrGetActivePlayer(), TYPEMASK_PLAYER, __FILE__, __LINE__));
if (player) {
player->UpdateActiveMoverDisplay(OsGetAsyncTimeMs());
}
return 1;
}
// VERIFY: 256f3626 manual
// OFFSET: 0x004F88B0
void CGWorldFrame::UpdateScreenEffect() {
CGPlayer_C* player = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(ClntObjMgrGetActivePlayer(), TYPEMASK_PLAYER, __FILE__, __LINE__));
if (player) {
SpellRec spell;
for (uint32_t i = player->GetAuraCount(); i > 0; i--) {
AuraData* aura = player->GetAura(i - 1);
if (!aura->m_spellId || !g_spellDB.GetRecord(aura->m_spellId, &spell)) {
continue;
}
for (uint32_t j = 0; j < 3; j++) {
if (spell.m_effectAura[j] == 260) {
CGWorldFrame::SetScreenEffect(spell.m_effectMiscValue[j]);
return;
}
}
}
if ((player->m_player->m_playerFlags & 0x10) && CGBattlefieldInfo::m_instanceType != 4) {
CGWorldFrame::SetScreenEffect(1);
return;
}
if (player->m_player->m_playerFieldBytes2 & 0x40000000) {
CGWorldFrame::SetScreenEffect(81);
return;
}
}
CGWorldFrame::SetScreenEffect(0);
}
// VERIFY: 8df0efa3 manual
// OFFSET: 0x004F5A90
void CGWorldFrame::OnFrameSizeChanged(const CRect& rect) {
this->CSimpleFrame::OnFrameSizeChanged(rect);
this->m_viewportDDC = this->m_rect;
this->m_viewportDDC.minX = this->m_viewportDDC.minX > 0.0f ? this->m_viewportDDC.minX : 0.0f;
this->m_viewportDDC.minY = this->m_viewportDDC.minY > 0.0f ? this->m_viewportDDC.minY : 0.0f;
this->m_viewportDDC.maxX = NDCToDDCWidth(1.0f) > this->m_viewportDDC.maxX ? this->m_viewportDDC.maxX : NDCToDDCWidth(1.0f);
this->m_viewportDDC.maxY = NDCToDDCHeight(1.0f) > this->m_viewportDDC.maxY ? this->m_viewportDDC.maxY : NDCToDDCHeight(1.0f);
if (this->m_camera) {
this->m_camera->SetScreenAspect(this->m_viewportDDC);
}
DDCToNDC(this->m_rect.minX, this->m_rect.minY, &this->m_viewportNDC.minX, &this->m_viewportNDC.minY);
DDCToNDC(this->m_rect.maxX, this->m_rect.maxY, &this->m_viewportNDC.maxX, &this->m_viewportNDC.maxY);
this->m_viewportNDC.minX = this->m_viewportNDC.minX > 0.0f ? this->m_viewportNDC.minX : 0.0f;
this->m_viewportNDC.minY = this->m_viewportNDC.minY > 0.0f ? this->m_viewportNDC.minY : 0.0f;
this->m_viewportNDC.maxX = this->m_viewportNDC.maxX < 1.0f ? this->m_viewportNDC.maxX : 1.0f;
this->m_viewportNDC.maxY = this->m_viewportNDC.maxY < 1.0f ? this->m_viewportNDC.maxY : 1.0f;
}
// VERIFY: 0cb92e2e manual
// OFFSET: 0x004F6560
static int32_t ObjectCollisionProc(WOWGUID* guid, uintptr_t param, World::ObjectCollisionData* data, uint32_t flags) {
CGObject_C* object = ClntObjMgrObjectPtr(*guid, TYPEMASK_OBJECT, __FILE__, __LINE__);
if (!object || !object->IsCollidable(flags) || !(object->m_obj->m_type & TYPEMASK_GAMEOBJECT)) {
return 0;
}
data->m_model = object->GetObjectModel();
data->m_bounds = static_cast<CGGameObject_C*>(object)->GetWorldBounds();
data->m_scale = object->GetTrueScale();
data->m_mat = object->GetMatrix();
uint64_t transport = object->GetTransportGUID();
if (transport) {
guid->m_guid = transport;
}
return 1;
}
// VERIFY: bed13d63 manual
// OFFSET: 0x004F6970
static int32_t UnitUpdateProc(WOWGUID guid, void* param) {
CGObject_C* object = ClntObjMgrObjectPtr(guid, TYPEMASK_OBJECT, __FILE__, __LINE__);
if (!object) {
return 1;
}
switch (object->m_obj->m_type) {
case TYPEMASK_OBJECT | TYPEMASK_UNIT:
case TYPEMASK_OBJECT | TYPEMASK_UNIT | TYPEMASK_PLAYER:
static_cast<CGUnit_C*>(object)->UpdateDisplay(FrameTime::s_curTimeMs);
break;
case TYPEMASK_OBJECT | TYPEMASK_GAMEOBJECT:
static_cast<CGGameObject_C*>(object)->UpdateDisplay(FrameTime::s_curTimeMs);
break;
case TYPEMASK_OBJECT | TYPEMASK_DYNAMICOBJECT:
static_cast<CGDynamicObject_C*>(object)->UpdateDisplay(FrameTime::s_curTimeMs);
break;
default:
break;
}
return 1;
}
// VERIFY: bee9c240 manual
// OFFSET: 0x004F6A40
static int32_t UnitPostAnimateProc(WOWGUID guid, void* param) {
CGObject_C* object = ClntObjMgrObjectPtr(guid, TYPEMASK_OBJECT, __FILE__, __LINE__);
if (object && (object->m_obj->m_type & TYPEMASK_UNIT)) {
static_cast<CGUnit_C*>(object)->PostAnimate(static_cast<CGWorldFrame*>(param));
}
return 1;
}
// VERIFY: f55fe239 manual
// OFFSET: 0x004F6A90
static C3Vector GetFacingVector(CGObject_C* object) {
float facing = object->GetFacing();
return C3Vector(cosf(facing), sinf(facing), 0.0f);
}
// VERIFY: 5b70d219 manual
// OFFSET: 0x004F8A40
static void DrawSpellCursorShadow(uint32_t a1) {
if (!s_spellShadowTexture[s_spellShadowStyle]) {
return;
}
CGxTex* texture = TextureGetGxTex(s_spellShadowTexture[s_spellShadowStyle], 0, nullptr);
if (!texture) {
return;
}
if (Spell_C_GetSpellWorldObject() && !s_spellShadowStyle) {
return;
}
float size = s_spellShadowSize;
if (size == 0.0f) {
size = 1.3888888f;
}
CAaBox box;
box.t = C3Vector(s_spellShadowPos.x + size, s_spellShadowPos.y + size, s_spellShadowPos.z + 2.0f);
box.b = C3Vector(s_spellShadowPos.x - size, s_spellShadowPos.y - size, s_spellShadowPos.z - 2.0f);
g_theGxDevicePtr->RsPush();
GxRsSet(GxRs_Lighting, 0);
GxRsSet(GxRs_DepthWrite, 0);
GxRsSet(GxRs_BlendingMode, 2);
GxUpdateAlphaRef(GxRs_AlphaRef);
g_theGxDevicePtr->RsSet(GxRs_Texture0, texture);
g_theGxDevicePtr->RsSet(GxRs_Texture1, ProjectTex2dGetAddFadeTex());
GxRsSet(GxRs_ColorOp0, 0);
GxRsSet(GxRs_AlphaOp0, 0);
GxRsSet(GxRs_ColorOp1, 0);
GxRsSet(GxRs_AlphaOp1, 0);
CImVector color;
color.b = 0xFF;
color.g = 0xFF;
color.r = 0xFF;
color.a = 0xFF;
ProjectTex::Render2d(box, color, nullptr, 0.5f, a1, 5, 0.4f);
g_theGxDevicePtr->RsPop();
}
// VERIFY: b5c2c6d4 manual
// OFFSET: 0x004F8410
void CGWorldFrame::UpdateDayNight(float deltaSec) {
DayNight::DNInfo* info = DayNight::GetInfo();
info->m_farClip = this->m_camera->m_farZ;
info->m_deltaSec = deltaSec;
info->m_timeSec = OsGetAsyncTimeMs() * 0.001f;
info->m_cameraPos = this->m_camera->m_position;
info->m_cameraDir = this->m_camera->Forward();
float scale = 1.0f / sqrtf(info->m_cameraDir.z * info->m_cameraDir.z + info->m_cameraDir.y * info->m_cameraDir.y + info->m_cameraDir.x * info->m_cameraDir.x);
info->m_cameraDir.x = info->m_cameraDir.x * scale;
info->m_cameraDir.y = info->m_cameraDir.y * scale;
info->m_cameraDir.z = scale * info->m_cameraDir.z;
CGObject_C* target = ClntObjMgrObjectPtr(this->m_camera->m_targetGUID, TYPEMASK_OBJECT, __FILE__, __LINE__);
if (target) {
info->m_lightRefPos = target->GetPosition();
} else {
info->m_lightRefPos = info->m_cameraPos;
}
WOWGUID activePlayer = ClntObjMgrGetActivePlayer();
CGPlayer_C* player = activePlayer ? static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(activePlayer, TYPEMASK_PLAYER, __FILE__, __LINE__)) : nullptr;
if (player) {
info->m_playerPos = player->GetPosition();
}
if (player && (player->m_unit->m_unitFieldFlags & 0x100000) && (player->m_player->m_playerFlags & 0x20000)) {
info->m_timeOfDay = 0;
info->m_dayProgression = 0.5f;
info->m_day = 0.0f;
} else {
info->m_timeOfDay = g_clientGameTime.GetHourAndMinutes();
info->m_dayProgression = g_clientGameTime.GameTimeGetDayProgression();
info->m_day = static_cast<float>(g_clientGameTime.GetDaysSinceEpoch());
}
MapRec* map = g_mapDB.GetRecord(World::QueryMapId());
if (map->m_timeOfDayOverride != -1) {
info->m_timeOfDay = 0;
info->m_dayProgression = map->m_timeOfDayOverride * (1.0f / 1440.0f);
info->m_day = 0.0f;
if (info->m_dayProgression < 0.0f || info->m_dayProgression > 1.0f) {
SysMsgPrintf(STATUS_ERROR, "Invalid time of day override in Map ID %d. TOD = %d.", World::QueryMapId(), map->m_timeOfDayOverride);
info->m_dayProgression = 0.5f;
}
}
info->m_weatherIntensity = World::s_weather->m_densityBlend * World::s_weather->m_fogIntensity;
}
// VERIFY: 1381402d manual
// OFFSET: 0x004F8D10
void CGWorldFrame::UpdateObject(CGObject_C* object, uint32_t flags) {
CM2Model* model = object->GetObjectModel();
if (!model) {
return;
}
int32_t render = 0;
int32_t a3 = 0;
object->ShouldRender(flags, render, a3);
int32_t visible = render || a3 ? 0 : 1;
object->PreAnimate(this);
if (!object->Animate(this->m_elapsedSec)) {
return;
}
if ((object->m_obj->m_type & (TYPEMASK_UNIT | TYPEMASK_GAMEOBJECT | TYPEMASK_CORPSE)) && visible && !(object->m_modelFlags & 0x100000)) {
CModelRecord* record;
if (this->m_freeModelList.IsEmpty()) {
record = this->m_modelList.NewNode(2, 0, 0);
} else {
record = this->m_freeModelList.Head();
this->m_freeModelList.UnlinkNode(record);
this->m_modelList.LinkToTail(record);
}
CM2Model* recordModel = object->GetObjectModel();
record->m_model = recordModel;
recordModel->m_refCount++;
record->m_guid = object->m_obj->m_guid;
}
uint32_t bit = visible & 1;
if (model->m_attachParent) {
model->m_fFlags = (model->m_fFlags & ~0x80) | (bit << 7);
} else {
model->m_fFlags = (model->m_fFlags & ~0x8) | (bit << 3);
}
if (model->m_attachParent) {
model->m_fFlags = (model->m_fFlags & ~0x20000) | (bit << 17);
} else {
model->m_fFlags = (model->m_fFlags & ~0x10000) | (bit << 16);
}
}
// VERIFY: 2ea40d3b manual
// OFFSET: 0x004F8EA0
void CGWorldFrame::OnWorldRender() {
CRect window = { 0.0f, 0.0f, 0.0f, 0.0f };
g_theGxDevicePtr->CapsWindowSize(window);
if (0.0f == window.maxY - window.minY || window.maxX - window.minX == 0.0f) {
return;
}
if (!(this->m_viewportNDC.maxY > this->m_viewportNDC.minY && this->m_viewportNDC.maxX > this->m_viewportNDC.minX)) {
return;
}
g_theGxDevicePtr->RsPush();
GxRsSet(GxRs_Multisample, 1);
CGWorldFrame::UpdateScreenEffectParams();
FFX::Start();
CRect fullViewport = { 0.0f, 0.0f, 1.0f, 1.0f };
if (this->m_viewportNDC != fullViewport) {
CImVector black;
black.b = 0x00;
black.g = 0x00;
black.r = 0x00;
black.a = 0xFF;
GxSceneClear(3, black);
}
if (CWorld::enables & 0x20000000) {
g_theGxDevicePtr->MasterEnableSet(GxMasterEnable_PolygonFill, 0);
}
float minX = 0.0f;
float minY = 0.0f;
float minZ = 0.0f;
float maxX = 0.0f;
float maxY = 0.0f;
float maxZ = 0.0f;
GxXformViewport(minX, maxX, minY, maxY, minZ, maxZ);
CGxTex* renderTarget;
g_theGxDevicePtr->DeviceGetRenderTarget(GxBuffers_Color, renderTarget);
float width = maxX - minX;
float height = maxY - minY;
float top;
float bottom;
if (renderTarget) {
top = 1.0f - this->m_viewportNDC.minY;
bottom = 1.0f - this->m_viewportNDC.maxY;
} else {
top = this->m_viewportNDC.maxY;
bottom = this->m_viewportNDC.minY;
}
GxXformSetViewport(width * this->m_viewportNDC.minX + minX, this->m_viewportNDC.maxX * width + minX, height * bottom + minY, top * height + minY, minZ, CWorld::s_unk_ADEEE4);
TextureCacheResetLoadCount();
PlayerNameUpdateEarly();
if (this->m_namePlateFlags & 0x2) {
CGUnit_C::NamePlateSetResortAll(true);
this->m_namePlateFlags &= ~0x2;
}
CShaderEffect::UpdateProjMatrix();
CWorld::Render(this->m_camera->m_position, this->m_elapsedSec);
CMap::RenderFootprints();
ClntObjMgrEnumVisibleObjects(UnitPostAnimateProc, this);
CGUnit_C::NamePlateSetResortAll(false);
CGUnit_C::NamePlateUpdateLevels(false);
CGUnit_C::NamePlateUpdateColor(false);
if (this->m_namePlateFlags & 0x1) {
SmartScreenRectClearGrid(0);
CGUnit_C::UnitNameplatesReposition(this);
this->m_namePlateFlags &= ~0x1;
}
CM2Scene* scene = World::s_m2Scene;
if (!scene) {
return;
}
scene->SetFloat18(-CWorld::s_unk_CD7758);
scene->m_passMask = CWorld::m_M2PassMask;
scene->Draw(M2PASS_0);
if (s_spellShadowStyle < 2) {
DrawSpellCursorShadow(0x200122);
}
GxuSortDrawList(GxuCat_0, GxuSort_VtxStream, *World::GetCamPos());
GxuFlushDrawList(GxuCat_0, *World::GetCamPos());
CWorldScene::RenderDetailDoodads();
if (World::SceneCamLiquidStatus(nullptr)) {
CWorldScene::RenderBarriers(this->m_elapsedSec);
scene->Draw(M2PASS_1);
CWorldScene::RenderWeather();
CWorldScene::RenderLiquidPass();
scene->Draw(M2PASS_2);
} else {
scene->Draw(M2PASS_2);
CWorldScene::RenderLiquidPass();
CWorldScene::RenderWeather();
CWorldScene::RenderBarriers(this->m_elapsedSec);
scene->Draw(M2PASS_1);
}
if (s_spellShadowStyle < 2) {
DrawSpellCursorShadow(0x20000);
}
SpellVisualsTick();
SpellVisualsRender();
CGUnit_C::RenderMissileTrajectoryTargetingTexture();
this->ClearTrackedObjects();
CWorldScene::RenderParticulate();
GxuSortDrawList(GxuCat_1, GxuSort_B2F, *World::GetCamPos());
GxuFlushDrawList(GxuCat_1, *World::GetCamPos());
DayNight::RenderGlares();
PlayerNameUpdateLate();
if (CWorld::enables & 0x20000000) {
GxMasterEnableSet(GxMasterEnable_PolygonFill, 1);
}
g_theGxDevicePtr->RsPop();
SmartScreenRectClearGrid(1);
CGChatBubbleFrame::OnWorldRender(this);
GxXformSetViewport(minX, maxX, minY, maxY, minZ, maxZ);
FFX::Finish();
CVehiclePassenger_C::PostRenderUpdateAll();
}
// VERIFY: 79b17fb9 manual
// OFFSET: 0x004F9F70
int32_t CGWorldFrame::ObjectEnumProc(void* param, uint32_t flags, uint64_t guid, uintptr_t a4) {
CGWorldFrame* frame = CGWorldFrame::s_currentWorldFrame;
CGObject_C* object = ClntObjMgrObjectPtr(WOWGUID{ guid }, TYPEMASK_OBJECT, __FILE__, __LINE__);
if (!object) {
return 1;
}
if (flags & 4) {
object->m_modelFlags |= 0x800000;
} else {
object->m_modelFlags &= ~0x800000;
}
if (!(object->m_modelFlags & 0x10000) && object->IsReadyToDraw()) {
frame->UpdateObject(object, flags);
return 1;
}
if (object->GetObjectModel()) {
CM2Model* model = object->GetObjectModel();
if (model->m_attachParent) {
model->m_fFlags &= ~0x80;
} else {
model->m_fFlags &= ~0x8;
}
if (model->m_attachParent) {
model->m_fFlags &= ~0x20000;
} else {
model->m_fFlags &= ~0x10000;
}
}
return 1;
}
// VERIFY: 5ab100e2 manual
// OFFSET: 0x004FA040
void CGWorldFrame::OnLayerUpdate(float elapsedSec) {
this->CSimpleFrame::OnLayerUpdate(elapsedSec);
CGChatBubbleFrame::OnWorldLayerUpdate();
CSimpleTop* top = this->m_simpleTop;
HITTESTRESULT hit;
hit.m_point = C3Vector(0.0f, 0.0f, 0.0f);
hit.m_guid = WOWGUID();
hit.m_distance = 0.0f;
hit.m_segStart = C3Vector(0.0f, 0.0f, 0.0f);
hit.m_segEnd = C3Vector(0.0f, 0.0f, 0.0f);
int32_t kind = -1;
CSimpleFrame* focus = top->m_mouseFocus;
if (focus == this) {
C2Vector ddc = { 0.0f, 0.0f };
NDCToDDC(top->m_mousePosition.m_x, top->m_mousePosition.m_y, &ddc.x, &ddc.y);
if (Spell_C_IsTargeting() && Spell_C_CanTargetTerrain() && !Spell_C_CanTargetUnits()) {
CGUnit_C::ClearNamePlateFocus();
} else {
CGUnit_C::SetNamePlateFocus(ddc);
}
if (CGNamePlateFrame::GetNamePlateFocus()) {
kind = 2;
hit.m_guid = CGNamePlateFrame::GetNamePlateFocus()->m_guid;
} else {
kind = this->HitTestPoint(ddc.x, ddc.y, 1, &hit);
}
} else if (focus && (focus->m_layoutFlags & 0x10000)) {
lua_State* L = FrameScript_GetContext();
const char* savedTaint = lua_tainted;
if (++lua_taintexpected && !lua_taintedclosure) {
lua_tainted = nullptr;
}
lua_rawgeti(L, LUA_REGISTRYINDEX, FrameScript_GetErrorHandlerReference());
lua_pushstring(L, "SecureButton_GetModifiedUnit");
lua_rawget(L, LUA_GLOBALSINDEX);
if (!focus->m_luaRegistered) {
focus->RegisterScriptObject(nullptr);
}
lua_rawgeti(L, LUA_REGISTRYINDEX, focus->m_luaObjectRef);
lua_pushstring(L, CGUIMacros::m_macroRunning);
if (!lua_pcall(L, 2, 1, -4)) {
const char* token = lua_tolstring(L, -1, nullptr);
if (token && !lua_tainted && Script_GetGUIDFromToken(token, hit.m_guid, false)) {
kind = 2;
}
}
lua_settop(L, -3);
if (lua_taintexpected && !lua_taintedclosure) {
lua_tainted = savedTaint;
}
if (--lua_taintexpected <= 0) {
lua_taintexpected = 0;
}
}
s_spellShadowStyle = 3;
switch (kind) {
case 0:
if (Spell_C_IsTargeting()) {
CursorSetMode(28);
} else {
CursorResetMode();
}
this->HandleSpriteTrack(WOWGUID());
break;
case 1:
this->OnLayerTrackTerrain(hit);
break;
case 2:
this->OnLayerTrackObject(hit);
break;
case 3: {
CGGameObject_C* gameObject = static_cast<CGGameObject_C*>(ClntObjMgrObjectPtr(hit.m_guid, TYPEMASK_GAMEOBJECT, __FILE__, __LINE__));
if (!gameObject || gameObject->m_gameObject->m_typeID != 33 || Spell_C_CanTargetTerrain()) {
this->OnLayerTrackTerrain(hit);
break;
}
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
if (player && gameObject->m_obj->m_guid.m_guid == World::QueryObjectParentParam64(player->m_worldObject)) {
this->OnLayerTrackTerrain(hit);
break;
}
this->OnLayerTrackObject(hit);
break;
}
default:
break;
}
CGInputControl::GetActive()->OnUpdate(elapsedSec);
this->m_elapsedSec = elapsedSec;
CGGameUI::UpdateInteractTarget();
CGGameUI::UpdateCorpseDistance();
CGGameUI::UpdateAreaSpiritHealerDistance();
CGMailInfo::UpdatePendingMail(elapsedSec);
}
// VERIFY: b7190175 manual
// OFFSET: 0x004FA5F0
void CGWorldFrame::OnWorldUpdate() {
float elapsedSec = this->m_elapsedSec;
CGPlayer_C* player = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(ClntObjMgrGetActivePlayer(), TYPEMASK_PLAYER, __FILE__, __LINE__));
if (CGUnit_C::s_activeMover) {
CGObject_C* mover = ClntObjMgrObjectPtr(CGUnit_C::s_activeMover, TYPEMASK_UNIT, __FILE__, __LINE__);
if (mover) {
CBarrier::SetViewerPos(mover->GetPosition());
}
}
CGObject_C* target = ClntObjMgrObjectPtr(this->m_camera->m_targetGUID, TYPEMASK_OBJECT, __FILE__, __LINE__);
if (player && player->IsCommentatorUberOrInArena()) {
if (this->m_camera->m_targetGUID) {
this->m_camera->SetTarget(nullptr, 0);
}
CGCommentator::s_Commentator.OnUpdate(this->m_elapsedSec);
} else if (!ClntObjMgrObjectPtr(this->m_camera->m_targetGUID, TYPEMASK_OBJECT, __FILE__, __LINE__) && !ClntObjMgrObjectPtr(this->m_camera->m_guid0090, TYPEMASK_OBJECT, __FILE__, __LINE__)) {
CGPlayer_C* activePlayer = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(ClntObjMgrGetActivePlayer(), TYPEMASK_PLAYER, __FILE__, __LINE__));
if (activePlayer) {
if (activePlayer->m_combatModeFlags & 0x1) {
activePlayer->ToggleFarSight(nullptr);
}
this->m_camera->SetTarget(activePlayer, 0);
activePlayer->OnVehicleCameraPossiblyNeeded();
}
}
if (target && target->m_worldObject) {
CWorldScene::SetCameraTarget(target->m_worldObject, WOWGUID{ target->GetTransportGUID() });
}
CVehiclePassenger_C::UpdateAll(FrameTime::s_curTimeMs);
CGCamera::UpdateCallback(nullptr, this->m_camera);
CGCamera* camera = this->m_camera;
C3Vector camPos = camera->m_position;
C3Vector forward = camera->Forward();
C3Vector camTarget = C3Vector(camera->m_position.x + forward.x, camera->m_position.y + forward.y, camera->m_position.z + forward.z);
this->m_camera->SetupWorldProjection(this->m_viewportDDC);
this->UpdateDayNight(elapsedSec);
if (!this->m_camera->HasModelCamera() && s_listenerAtCharacterVar && s_listenerAtCharacterVar->m_intValue) {
CGObject_C* focus = CGObject_C::GetFocusObject();
if (focus) {
// STATIC: 0x00B743B8
static C3Vector s_listenerUp = C3Vector(0.0f, 0.0f, 1.0f);
C3Vector facing = (focus->m_obj->m_type & TYPEMASK_UNIT) ? GetFacingVector(focus) : this->m_camera->Forward();
// STATIC: 0x00B743B4
static CVar* s_listenerBackDist = CVar::Lookup("Sound_ListenerBackDist");
// STATIC: 0x00B743B0
static CVar* s_listenerUpDist = CVar::Lookup("Sound_ListenerUpDist");
float backDist = 2.0f;
float upDist = 4.0f;
if (s_listenerBackDist) {
backDist = s_listenerBackDist->m_floatValue;
}
if (s_listenerUpDist) {
upDist = s_listenerUpDist->m_floatValue;
}
C3Vector offset = C3Vector(facing.x * backDist, facing.y * backDist, backDist * facing.z);
C3Vector listener;
if (focus->m_worldModel && (focus->m_worldModel->m_fFlags & 0x8000)) {
listener = focus->m_worldModel->GetWorldPosition() - offset;
listener.z = listener.z + upDist;
} else {
C3Vector position = focus->GetPosition();
listener = C3Vector(position.x - offset.x, position.y - offset.y, position.z - offset.z + upDist);
}
SI2::SetListenerAttributes(&listener, &facing, &s_listenerUp, nullptr);
} else {
C3Vector up = this->m_camera->Up();
C3Vector cameraForward = this->m_camera->Forward();
SI2::SetListenerAttributes(&camPos, &cameraForward, &up, nullptr);
}
} else {
C3Vector up = this->m_camera->Up();
C3Vector cameraForward = this->m_camera->Forward();
SI2::SetListenerAttributes(&camPos, &cameraForward, &up, nullptr);
}
CGObject_C::UpdateAllObjectEffectManagers();
UpdatePendingPortraits();
this->MoveToFreeList(&this->m_modelList);
this->MoveToFreeList(&this->m_hitModelList);
ClntObjMgrEnumVisibleObjects(UnitUpdateProc, nullptr);
World::SetObjectCollisionCallback(ObjectCollisionProc);
CEffect::CleanUpStaticLists();
CMissile::UpdateStaticLists();
Spell_C_ExpireDestLocSpellCasts(FrameTime::s_curTimeMs);
Spell_C_UpdateInTransitList();
C3Vector position = (this->m_camera->m_model || !target) ? camPos : target->GetPosition();
CWorld::Update(&camPos, &camTarget, &position);
C44Matrix viewProjection;
GxXformViewProj(viewProjection);
if (viewProjection != this->m_viewProjection) {
this->m_namePlateFlags |= 0x2;
this->m_viewProjection = viewProjection;
}
ClientUpdateTaxiBenchmarkMode();
SI2::UpdateTaxiSounds(elapsedSec);
SI2::DSP_MakeDSPsExpire(elapsedSec);
CGUnit_C* mover = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(CGUnit_C::s_activeMover, TYPEMASK_UNIT, __FILE__, __LINE__));
if (mover) {
mover->UpdateMissileTrajectory();
}
CGUnit_C::UpdateAllSmoothFacing();
CheckEventWorldStateUITimerUpdate();
}
// VERIFY: 09c5961f manual
// OFFSET: 0x004FAF90
void CGWorldFrame::RenderWorld(void* param) {
CGWorldFrame* worldFrame = static_cast<CGWorldFrame*>(param);
C44Matrix projection;
C44Matrix view;
projection = g_theGxDevicePtr->m_projection;
GxXformView(view);
worldFrame->OnWorldUpdate();
PlayerNameUpdateWorldText();
worldFrame->OnWorldRender();
WorldTextRenderBatch();
g_theGxDevicePtr->XformSetProjection(projection);
g_theGxDevicePtr->XformSetView(view);
CShaderEffect::UpdateProjMatrix();
}
// VERIFY: 3e6634ba auto
// OFFSET: 0x004FB080
void CGWorldFrame::OnFrameRender(CRenderBatch* batch, uint32_t layer) {
this->CSimpleFrame::OnFrameRender(batch, layer);
if (!layer) {
batch->QueueCallback(CGWorldFrame::RenderWorld, this);
}
}
// VERIFY: 1cd14340 auto
// OFFSET: 0x004F5D30
void CGWorldFrame::OnMouseModeRelative() {
WOWGUID tracked = this->m_trackedGuid;
this->m_worldFlags |= 0x2;
if (tracked) {
CObjectTrackEvent evt;
evt.m_guid = WOWGUID();
evt.m_prevGuid = tracked;
CGGameUI::HandleSpriteTrack(evt);
this->m_trackedGuid = WOWGUID();
}
}
// VERIFY: bef9479f manual
// OFFSET: 0x004F7880
void CGWorldFrame::PerformDefaultAction(MOUSEBUTTON button) {
CGPlayer_C* player = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(ClntObjMgrGetActivePlayer(), TYPEMASK_PLAYER, __FILE__, __LINE__));
if (!player || player->m_unit->m_unitFieldCharmedby) {
CWorldClickEvent evt;
evt.m_segStart = C3Vector(0.0f, 0.0f, 0.0f);
evt.m_button = button;
evt.m_segEnd = C3Vector(0.0f, 0.0f, 0.0f);
CGGameUI::HandleWorldClick(evt);
return;
}
CGNamePlateFrame* namePlate = CGNamePlateFrame::GetNamePlateFocus();
if (namePlate) {
if (button == 1) {
CGGameUI::OnSpriteLeftClick(namePlate->m_guid);
} else {
CGGameUI::OnSpriteRightClick(namePlate->m_guid);
}
return;
}
switch (this->m_defaultActionHitKind) {
case 0: {
CWorldClickEvent evt;
evt.m_segStart = this->m_defaultActionHit.m_segStart;
evt.m_segEnd = this->m_defaultActionHit.m_segEnd;
evt.m_button = button;
CGGameUI::HandleWorldClick(evt);
break;
}
case 1:
case 3: {
CTerrainClickEvent evt;
uint32_t high = static_cast<uint32_t>(this->m_defaultActionHit.m_guid.m_guid >> 32);
if ((high & 0xF0000000) == 0x10000000 && (high & 0xFF00000) == 0xFC00000) {
evt.m_guid = this->m_defaultActionHit.m_guid;
} else {
evt.m_guid = WOWGUID();
}
evt.m_point = this->m_defaultActionHit.m_point;
evt.m_button = button;
CGGameUI::HandleTerrainClick(evt);
break;
}
case 2: {
CSpriteClickEvent evt;
evt.m_guid = this->m_defaultActionHit.m_guid;
evt.m_button = button;
CGGameUI::HandleSpriteClick(evt);
break;
}
default:
break;
}
}
// VERIFY: 46a37201 auto
// OFFSET: 0x004F5980
int32_t CGWorldFrame::HandleSpriteTrack(WOWGUID guid) {
WOWGUID tracked = this->m_trackedGuid;
if (guid == tracked) {
return 0;
}
CObjectTrackEvent evt;
evt.m_guid = guid;
evt.m_prevGuid = tracked;
CGGameUI::HandleSpriteTrack(evt);
this->m_trackedGuid = guid;
return 1;
}
// VERIFY: 15b5df38 manual
// OFFSET: 0x004F5FB0
static const char* KeyCodeToString(KEY key) {
if (key - 33 <= 0xDE) {
sputu8(key, s_keyNameBuffer);
return s_keyNameBuffer;
}
switch (key) {
case KEY_NONE:
return "NONE";
case KEY_LSHIFT:
return "LSHIFT";
case KEY_RSHIFT:
return "RSHIFT";
case KEY_LCONTROL:
return "LCTRL";
case KEY_RCONTROL:
return "RCTRL";
case KEY_LALT:
return "LALT";
case KEY_RALT:
return "RALT";
case KEY_SPACE:
return "SPACE";
case KEY_NUMPAD0:
case KEY_NUMPAD1:
case KEY_NUMPAD2:
case KEY_NUMPAD3:
case KEY_NUMPAD4:
case KEY_NUMPAD5:
case KEY_NUMPAD6:
case KEY_NUMPAD7:
case KEY_NUMPAD8:
case KEY_NUMPAD9:
SStrPrintf(s_keyNameBuffer, sizeof(s_keyNameBuffer), "NUMPAD%d", key - KEY_NUMPAD0);
return s_keyNameBuffer;
case KEY_NUMPAD_PLUS:
return "NUMPADPLUS";
case KEY_NUMPAD_MINUS:
return "NUMPADMINUS";
case KEY_NUMPAD_MULTIPLY:
return "NUMPADMULTIPLY";
case KEY_NUMPAD_DIVIDE:
return "NUMPADDIVIDE";
case KEY_NUMPAD_DECIMAL:
return "NUMPADDECIMAL";
case KEY_NUMPAD_EQUALS:
return "NUMPADEQUALS";
case KEY_ESCAPE:
return "ESCAPE";
case KEY_ENTER:
return "ENTER";
case KEY_BACKSPACE:
return "BACKSPACE";
case KEY_TAB:
return "TAB";
case KEY_LEFT:
return "LEFT";
case KEY_UP:
return "UP";
case KEY_RIGHT:
return "RIGHT";
case KEY_DOWN:
return "DOWN";
case KEY_INSERT:
return "INSERT";
case KEY_DELETE:
return "DELETE";
case KEY_HOME:
return "HOME";
case KEY_END:
return "END";
case KEY_PAGEUP:
return "PAGEUP";
case KEY_PAGEDOWN:
return "PAGEDOWN";
case KEY_CAPSLOCK:
return "CAPSLOCK";
case KEY_NUMLOCK:
return "NUMLOCK";
case KEY_PRINTSCREEN:
return "PRINTSCREEN";
case KEY_F1:
case KEY_F2:
case KEY_F3:
case KEY_F4:
case KEY_F5:
case KEY_F6:
case KEY_F7:
case KEY_F8:
case KEY_F9:
case KEY_F10:
case KEY_F11:
case KEY_F12:
case KEY_F14:
case KEY_F15:
case KEY_F16:
case KEY_F17:
case KEY_F18:
case KEY_F19:
SStrPrintf(s_keyNameBuffer, sizeof(s_keyNameBuffer), "F%d", key - KEY_F1 + 1);
return s_keyNameBuffer;
default:
return "UNKNOWN";
}
}
// VERIFY: 00570459 auto
// OFFSET: 0x004F5C10
void CGWorldFrame::OnLayerCursorExit(int32_t a2, int32_t a3) {
this->CSimpleFrame::OnLayerCursorExit(a2, a3);
WOWGUID tracked = this->m_trackedGuid;
if (tracked) {
CObjectTrackEvent evt;
evt.m_guid = WOWGUID();
evt.m_prevGuid = tracked;
CGGameUI::HandleSpriteTrack(evt);
this->m_trackedGuid = WOWGUID();
}
CursorResetMode();
s_spellShadowStyle = 3;
}
// VERIFY: f81c29ba auto
// OFFSET: 0x004F6AE0
int32_t CGWorldFrame::OnLayerKeyDown(const CKeyEvent& evt) {
if (this->CSimpleFrame::OnLayerKeyDown(evt)) {
return 1;
}
KEY key = evt.m_data.m_key;
if (key >= KEY_LAST) {
return 0;
}
if (key <= KEY_RALT) {
FrameScript_SignalEvent(SCRIPT_EVENT_MODIFIER_STATE_CHANGED, "%s%d", KeyCodeToString(key), 1);
return 1;
}
KEYDOWNSTATE& state = this->m_keyDown[key];
if (!CGUIBindings::KeyEventToString(evt, state.m_keyString, sizeof(state.m_keyString))) {
return 0;
}
state.m_modifiers = evt.m_data.m_metaKeyState;
return CGUIBindings::s_bindings->ExecKey(state.m_modifiers, state.m_keyString, 1, 1, static_cast<BINDING_MODE>(4));
}
// VERIFY: e0914772 manual
// OFFSET: 0x004F6B70
int32_t CGWorldFrame::OnLayerKeyUp(const CKeyEvent& evt) {
if (this->CSimpleFrame::OnLayerKeyUp(evt)) {
return 1;
}
KEY key = evt.m_data.m_key;
if (key >= KEY_LAST) {
return 0;
}
if (key <= KEY_RALT) {
FrameScript_SignalEvent(SCRIPT_EVENT_MODIFIER_STATE_CHANGED, "%s%d", KeyCodeToString(key), 0);
return 1;
}
KEYDOWNSTATE& state = this->m_keyDown[key];
int32_t result = 0;
if (!state.m_keyString[0]) {
state.m_modifiers = 0;
CGUIBindings::KeyEventToString(evt, state.m_keyString, sizeof(state.m_keyString));
}
if (state.m_keyString[0]) {
state.m_modifiers |= evt.m_data.m_metaKeyState;
result = CGUIBindings::s_bindings->ExecKey(state.m_modifiers, state.m_keyString, 0, 1, static_cast<BINDING_MODE>(4));
state.m_keyString[0] = 0;
}
return result;
}
// VERIFY: 0965c168 auto
// OFFSET: 0x004F6C10
int32_t CGWorldFrame::OnLayerMouseDown(const CMouseEvent& evt, const char* btn) {
if (this->CSimpleFrame::OnLayerMouseDown(evt, btn) || CGGameUI::HandleMouseDown(evt)) {
return 1;
}
KEYDOWNSTATE& state = this->m_mouseDown[MouseButtonToIndex(evt.m_data.m_button)];
if (!CGUIBindings::MouseEventToString(evt, state.m_keyString, sizeof(state.m_keyString))) {
return 0;
}
state.m_modifiers = evt.m_data.m_metaKeyState;
return CGUIBindings::s_bindings->ExecKey(state.m_modifiers, state.m_keyString, 1, 1, static_cast<BINDING_MODE>(4));
}
// VERIFY: 513360ba manual
// OFFSET: 0x004F6C90
int32_t CGWorldFrame::OnLayerMouseUp(const CMouseEvent& evt, const char* btn) {
if (this->CSimpleFrame::OnLayerMouseUp(evt, btn)) {
return 1;
}
KEYDOWNSTATE& state = this->m_mouseDown[MouseButtonToIndex(evt.m_data.m_button)];
int32_t result = 0;
if (!state.m_keyString[0]) {
state.m_modifiers = 0;
CGUIBindings::MouseEventToString(evt, state.m_keyString, sizeof(state.m_keyString));
}
if (state.m_keyString[0]) {
state.m_modifiers |= evt.m_data.m_metaKeyState;
result = CGUIBindings::s_bindings->ExecKey(state.m_modifiers, state.m_keyString, 0, 1, static_cast<BINDING_MODE>(4));
state.m_keyString[0] = 0;
}
return result;
}
// VERIFY: 14a0e78a manual
// OFFSET: 0x004FA570
int32_t CGWorldFrame::SetupDefaultAction() {
NDCToDDC(this->m_simpleTop->m_mousePosition.m_x, this->m_simpleTop->m_mousePosition.m_y, &this->m_defaultActionPointDDC.x, &this->m_defaultActionPointDDC.y);
this->m_defaultActionHitKind = this->HitTestPoint(this->m_defaultActionPointDDC.x, this->m_defaultActionPointDDC.y, 0, &this->m_defaultActionHit);
return this->m_defaultActionHitKind;
}
// VERIFY: 4cfa29e1 manual
// OFFSET: 0x004F5C80
int32_t CGWorldFrame::OnLayerMouseWheel(const CMouseEvent& evt) {
if (this->CSimpleFrame::OnLayerMouseWheel(evt) || !evt.m_data.m_wheelAmount) {
return 1;
}
char binding[32];
if (!CGUIBindings::MouseEventToString(evt, binding, sizeof(binding))) {
return 0;
}
int32_t down = CGUIBindings::s_bindings->ExecKey(evt.m_data.m_metaKeyState, binding, 1, 1, static_cast<BINDING_MODE>(4));
return CGUIBindings::s_bindings->ExecKey(evt.m_data.m_metaKeyState, binding, 0, 1, static_cast<BINDING_MODE>(4)) + down;
}
// VERIFY: 548e1cb9 manual
// OFFSET: 0x004F5910
int32_t CGWorldFrame::MissileEnumProc(void* param, uint32_t flags, uint64_t guid, uintptr_t a4) {
CMissile* missile = reinterpret_cast<CMissile*>(a4);
return !missile || missile->m_mapEntity != nullptr;
}
// VERIFY: c40ba1e3 auto
// OFFSET: 0x004F5930
int32_t CGWorldFrame::SpellEffectEnumProc(void* param, uint32_t flags, uint64_t guid, uintptr_t a4) {
CEffect* effect = reinterpret_cast<CEffect*>(a4);
if (effect) {
effect->UpdateWorldObject(CGWorldFrame::s_currentWorldFrame->m_elapsedSec, flags);
}
return 1;
}
// VERIFY: 57ad68af manual
// OFFSET: [0x004FA390, 0x004FAF60]
CGWorldFrame::~CGWorldFrame() {
EventUnregisterEx(EVENT_ID_IDLE, CGWorldFrame::Update, this, 0xFFFFFFFF);
EventSetMouseMode(MOUSE_MODE_NORMAL, 0);
CGWorldFrame::s_currentWorldFrame = nullptr;
for (uint32_t i = 0; i < sizeof(s_spellShadowTexture) / sizeof(s_spellShadowTexture[0]); i++) {
if (s_spellShadowTexture[i]) {
HandleClose(reinterpret_cast<HOBJECT>(s_spellShadowTexture[i]));
}
s_spellShadowTexture[i] = nullptr;
}
SmartScreenRectShutdown();
Spell_C_ClearInTransitList();
this->m_modelList.Clear();
this->m_hitModelList.Clear();
this->m_freeModelList.Clear();
delete this->m_camera;
this->m_camera = nullptr;
if (CGWorldFrame::ffxEffectGlow) {
delete CGWorldFrame::ffxEffectGlow;
}
if (CGWorldFrame::ffxEffectDeath) {
delete CGWorldFrame::ffxEffectDeath;
}
if (CGWorldFrame::ffxEffectNetherWorld) {
delete CGWorldFrame::ffxEffectNetherWorld;
}
if (CGWorldFrame::ffxEffectSwirlingFog) {
delete CGWorldFrame::ffxEffectSwirlingFog;
}
FFX::Destroy();
}