Files
wowdecomp/WoW/Source/WorldClient/MapObj.cpp
T
SatyandClaude Opus 5.5 9ddddebc34 Port minimap, item moves, cursor, character info, names, nameplates, combat text
- Fix RsSet render-target upload check (indoor rendering corruption)
- Minimap tracking/hover, world map refresh
- Bag/bar item moves, swaps, equip, item sounds, spell on cursor
- Character info stats, titles, model preview
- Unit/player names (PLAYERNAMEDESC render, name strings, raid icons)
- Nameplates: CGNamePlateFrame, CGSimpleHealthBar, unit glue, SmartScreenRect overlap solver
- Floating combat text: WORLDTEXTSTRING, render batch, PlayerName text slots
- Fix unescaped raid-icon texture path in PlayerNameInitialize

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

3059 lines
96 KiB
C++

#include "MapObj.h"
#include "WoW/Source/WorldClient/PolyClipper.h"
#include <cstring>
#include <cmath>
#include "Engine/Source/Base/CDataAllocator.h"
#include "Engine/Source/Base/Handle.h"
#include "Engine/Source/Base/ObjectAlloc.h"
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/SFile.h"
#include "Engine/Source/Gx/CGxBuf.h"
#include "Engine/Source/Gx/CGxDevice/CGxDevice.h"
#include "Engine/Source/Gx/CGxLight.h"
#include "Engine/Source/Gx/CGxTex.h"
#include "Engine/Source/Gx/Gx.h"
#include "Engine/Source/Gx/Types.h"
#include "Engine/Source/Gxu/GxuLight.h"
#include "Engine/Source/Model2/M2Light.h"
#include "Engine/Source/Services/AsyncFile.h"
#include "Engine/Source/Services/Texture.h"
#include "Engine/Source/ShaderEffect/ShaderEffect.h"
#include "Engine/Source/ShaderEffect/ShaderEffectManager.h"
#include "Engine/Source/ShaderEffect/ShadowCache.h"
#include "Engine/Source/Storm/H/storm.h"
#include "Engine/Source/Storm/H/stpl.h"
#include "Engine/Source/Tempest/C2Vector.h"
#include "Engine/Source/Tempest/C3Ray.h"
#include "Engine/Source/Tempest/C3Segment.h"
#include "Engine/Source/Tempest/C3Vector.h"
#include "Engine/Source/Tempest/C44Matrix.h"
#include "Engine/Source/Tempest/C4Plane.h"
#include "Engine/Source/Tempest/C4Vector.h"
#include "Engine/Source/Tempest/CAaBox.h"
#include "Engine/Source/Tempest/CAaSphere.h"
#include "Engine/Source/Tempest/CFrustum.h"
#include "Engine/Source/Tempest/CImVector.h"
#include "Engine/Source/Tempest/CMath.h"
#include "Engine/Source/Tempest/CWFrustum.h"
#include "Engine/Source/Tempest/NTempest.h"
#include "WoW/Source/WorldClient/CMapBaseObjLink.h"
#include "WoW/Source/WorldClient/CPortalView.h"
#include "WoW/Source/WorldClient/CWorldMath.h"
#include "WoW/Source/WorldClient/CWorldOcclusion.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/MapChunk.h"
#include "WoW/Source/WorldClient/MapDoodadDef.h"
#include "WoW/Source/WorldClient/MapLight.h"
#include "WoW/Source/WorldClient/MapObjDef.h"
#include "WoW/Source/WorldClient/MapObjGroup.h"
#include "WoW/Source/WorldClient/MapRenderChunk.h"
#include "WoW/Source/WorldClient/Types.h"
#include "WoW/Source/WorldClient/World.h"
#include "WoW/Source/Ui/MinimapFrame.h"
#include "WoW/Source/Ui/GameUI.h"
#include <new>
#include "Engine/Source/ConsoleBase/ConsoleVar.h"
// STATIC: 0x00AEE008
uint32_t CMapObj::s_unk_AEE008 = 2;
// STATIC: 0x00ADFF50
static int32_t s_portalExtCount = 2048;
// STATIC: 0x00D1BEE8
static TSGrowableArray<C3Vector> s_portalVerts;
// STATIC: 0x00D1C3D4
CShaderEffect* CMapObj::s_unifiedShaders[7];
// STATIC: 0x00D1C3F0
CShaderEffect* CMapObj::s_classicShaders[7];
// STATIC: 0x00D1C40C
uint32_t* CMapObj::occluderHeap;
// STATIC: 0x00D1C454
TSHashTable<CMapObj, HASHKEY_NONE> CMapObj::mapObjHash;
// STATIC: 0x00D1C410
int32_t CMapObj::bPoolsDirty;
// STATIC: 0x00D1C41C
CMapObjDef* s_stampedMapObjDef;
// STATIC: 0x00D1C424
uint32_t s_portalStamp;
// STATIC: 0x00D1C428
static HASHKEY_NONE s_mapObjHashKey;
// STATIC: 0x00D1BED8
RENDER_CALLBACK CMapObj::gRenderCallback;
// STATIC: 0x00D1BEDC
void* CMapObj::gRenderUserParam;
// STATIC: 0x00ADFE44
int32_t CMapObj::s_renderMode = 5;
// STATIC: 0x00CFBEC4
void (CMapObj::*CMapObj::s_renderGroupExterior)(CMapObjGroup* group, uint32_t index);
// STATIC: 0x00CFBECC
void (CMapObj::*CMapObj::s_renderGroupInterior)(CMapObjGroup* group, uint32_t index);
// STATIC: 0x00ADFE50
C44Matrix s_modelViewProj;
// STATIC: 0x00ADFE90
C44Matrix s_viewProj;
// STATIC: 0x00ADFED0
C44Matrix s_modelView;
// STATIC: 0x00ADFF10
C44Matrix s_mapObjToWorld;
// STATIC: 0x00ADFF54
SPortalExt s_portalExt[2048];
// STATIC: 0x00CFBEB8
int32_t s_curGroupIsInterior;
// STATIC: 0x00CFBEBC
int32_t s_cullStateValid;
// STATIC: 0x00CFBEC0
int32_t s_interiorPass;
// STATIC: 0x00D1BEE4
uint32_t s_maxPortalDepth = 10;
// STATIC: 0x00D1C42C
C3Vector s_camPosLocal;
// STATIC: 0x00D1C438
C3Vector s_camTargetLocal;
// STATIC: 0x00D1C444
C4Plane s_camPlaneLocal;
// STATIC: 0x00CFBEA8
static int32_t s_shadowInterior;
// STATIC: 0x00CFBEB0
static int32_t s_fogMode;
// STATIC: 0x00D1BEF8
static uint32_t s_lastSidnColor;
// STATIC: 0x00D1BEFC
static uint32_t s_emissiveAmbient;
// STATIC: 0x00CFBEAC
int32_t CMapObj::s_lightingMode;
// STATIC: 0x00D1BEE0
static uint32_t s_smolVertCacheSize;
// STATIC: 0x00D1BF00
static SMOLiquidVert s_smolVertCache[64];
// VERIFY: 05ab90b4 auto
// OFFSET: 0x007A6140
World::TriData::Batch* World::TriData::AllocBatch() {
if (World::TriData::nBatches + 1 >= 32) {
World::TriData::statusFlags |= 1;
return nullptr;
}
Batch* batch = &World::TriData::batches[World::TriData::nBatches++];
batch->m_matrix = nullptr;
batch->m_vertexList = nullptr;
batch->m_normalList = nullptr;
batch->unk_000C = 0;
batch->m_indices = nullptr;
batch->m_faceIndices = nullptr;
batch->m_indexCount = 0;
batch->m_faceCount = 0;
batch->m_minVertexIndex = 0;
batch->m_maxVertexIndex = 0;
batch->m_def = nullptr;
batch->m_minVertexIndex = 0xFFFF;
return batch;
}
// VERIFY: dd78a681 manual
// OFFSET: 0x007A6190
uint16_t* __stdcall World::TriData::AllocIndices(uint32_t count) {
uint32_t cursor = World::TriData::indexCursor;
if (cursor + count >= 0xC000) {
World::TriData::statusFlags |= 1;
return nullptr;
}
World::TriData::indexCursor += count;
return &World::TriData::indexPool[cursor];
}
// VERIFY: b6bac718 auto
// OFFSET: 0x007A6B40
void CMapObj::SetGroupRenderCallback(RENDER_CALLBACK callback, void* param) {
CMapObj::gRenderCallback = callback;
CMapObj::gRenderUserParam = param;
}
// VERIFY: ade70db6 auto
// OFFSET: 0x007A6B60
void CMapObj::InvokeRenderCallback(uint32_t groupNum) {
if (this->GetGroup(groupNum, 0) && CMapObj::gRenderCallback) {
CMapObj::gRenderCallback(groupNum, CMapObj::gRenderUserParam);
}
}
// VERIFY: dd043936 manual
// OFFSET: 0x007A6E00
void CMapObj::SetupMapObjDefCull(C44Matrix& mat, C44Matrix& invMat, C3Vector& worldPos, C3Vector& camTarget) {
C44Matrix world;
C3Vector offset(-worldPos.x, -worldPos.y, -worldPos.z);
world.Translate(offset);
world = mat * world;
GxXformSet(GxXform_World, world);
s_camPosLocal = worldPos * invMat;
s_camTargetLocal = camTarget * invMat;
C3Vector dir;
dir.x = s_camTargetLocal.x - s_camPosLocal.x;
dir.y = s_camTargetLocal.y - s_camPosLocal.y;
dir.z = s_camTargetLocal.z - s_camPosLocal.z;
float lengthSq = dir.z * dir.z + dir.y * dir.y + dir.x * dir.x;
if (lengthSq > 0.0001f) {
float scale = 1.0f / sqrtf(lengthSq);
dir.x *= scale;
dir.y *= scale;
dir.z = scale * dir.z;
}
s_camPlaneLocal.n = dir;
s_camPlaneLocal.d = -(s_camPosLocal.x * dir.x + s_camPosLocal.y * dir.y + s_camPosLocal.z * dir.z);
GxXformViewProj(s_viewProj);
C44Matrix view;
GxXformView(view);
s_modelView = world * view;
s_modelViewProj = world * s_viewProj;
s_mapObjToWorld = mat;
if (this->m_interiorGroupCount == 0xFFFF) {
for (uint32_t i = 0; i < static_cast<uint32_t>(this->m_groupInfoCount); i++) {
if (!(this->m_groupInfo[i].m_flags & 0x10008)) {
this->m_interiorGroupCount++;
}
}
}
s_cullStateValid = 1;
}
// VERIFY: 2166e3e8 manual
// OFFSET: 0x007A70D0
float CMapObj::CalcPortalFarthestDistance(SMOPortal* portal) {
float farthest = 0.0f;
C3Vector* verts = &this->m_portalVertexList[portal->m_startVertex];
for (uint32_t i = 0; i < portal->m_count; i++) {
float dist = verts[i].y * s_camPlaneLocal.n.y + verts[i].z * s_camPlaneLocal.n.z + verts[i].x * s_camPlaneLocal.n.x + s_camPlaneLocal.d;
if (dist > farthest) {
farthest = dist;
}
}
return farthest;
}
// VERIFY: ceb264eb manual
// OFFSET: 0x007A7210
void CMapObj::ClassifyPortalPlane(SMOPortal* portal, SPortalExt* portalExt) {
float dist = portal->m_plane.n.y * s_camPosLocal.y + portal->m_plane.n.z * s_camPosLocal.z + portal->m_plane.n.x * s_camPosLocal.x + portal->m_plane.d;
if (dist > -0.01f && dist < 0.01f && NTempest::Intersect(s_camPosLocal, &this->m_portalVertexList[portal->m_startVertex], portal->m_count, portal->m_plane.n.MajorAxis())) {
portalExt->m_flags |= 0x2;
}
}
// VERIFY: 2cc1b7e1 manual
// OFFSET: 0x007A72A0
void __stdcall CWorldScene::ClipVerts(C3Vector* verts, uint32_t count, C3Vector** outVerts, uint32_t* outCount) {
static C3Vector s_clipVerts[32];
static int32_t s_sides[17];
static float s_dists[17];
C3Vector* buffers[2] = { &s_clipVerts[0], &s_clipVerts[16] };
uint32_t counts[2] = { count, 0 };
for (uint32_t i = 0; i < count; i++) {
s_clipVerts[i] = verts[i];
}
for (uint32_t plane = 0; ; ) {
uint32_t src = plane & 1;
uint32_t dst = (plane - 1) & 1;
C3Vector* in = buffers[src];
uint32_t inCount = counts[src];
C4Plane& clip = CWorldScene::s_clipFrustum.planes[plane];
for (uint32_t i = 0; i < inCount; i++) {
float dist = in[i].x * clip.n.x + in[i].z * clip.n.z + in[i].y * clip.n.y + clip.d;
s_dists[i] = dist;
if (dist > 0.0001f) {
s_sides[i] = 1;
} else if (dist >= -0.0001f) {
s_sides[i] = 0;
} else {
s_sides[i] = 2;
}
}
s_sides[inCount] = s_sides[0];
s_dists[inCount] = s_dists[0];
if (!inCount) {
break;
}
C3Vector* out = buffers[dst];
uint32_t outCount2 = 0;
for (uint32_t i = 0; i < inCount; i++) {
if (s_sides[i] == 0) {
out[outCount2++] = in[i];
continue;
}
if (s_sides[i] == 1) {
out[outCount2++] = in[i];
}
if (s_sides[i + 1] && s_sides[i + 1] != s_sides[i]) {
C3Vector& next = in[(i + 1) % inCount];
float t = s_dists[i] / (s_dists[i] - s_dists[i + 1]);
out[outCount2].x = (next.x - in[i].x) * t + in[i].x;
out[outCount2].y = (next.y - in[i].y) * t + in[i].y;
out[outCount2].z = t * (next.z - in[i].z) + in[i].z;
outCount2++;
}
}
if (!outCount2) {
break;
}
counts[dst] = outCount2;
*outCount = outCount2;
if (++plane >= 5) {
*outVerts = buffers[dst];
return;
}
}
*outVerts = nullptr;
*outCount = 0;
}
// VERIFY: 0d20ad08 manual
// OFFSET: 0x007A7630
bool CMapObj::CullBatch(SMOBatch* batch) {
C3Vector t(batch->m_tx, batch->m_ty, batch->m_tz);
CAaBox box;
box.b.x = batch->m_bx;
box.t = t;
box.b.y = batch->m_by;
box.b.z = batch->m_bz;
return CWorldScene::FrustumCull(&box);
}
// VERIFY: bd88db75 auto
// OFFSET: 0x007A7B00
static void __stdcall WriteLiquidVertex(CMapObjGroup* group, const C44Matrix& matrix, const C3Vector& vertex, const SMOLiquidVert* liquidVert, const CImVector* color, int32_t magma, float texCoord1U, int32_t* unused, uint32_t stride, C3Vector** position, C3Vector** normal, CImVector** vertexColor, C2Vector** texCoord0, C2Vector** texCoord1) {
DepthCoordTable* depthTable = CMap::GetDepthCoordTable(group->m_liquidType);
if (*position) {
**position = vertex * matrix;
*position = reinterpret_cast<C3Vector*>(reinterpret_cast<uint8_t*>(*position) + stride);
}
if (*normal) {
(*normal)->x = 0.0f;
(*normal)->y = 0.0f;
(*normal)->z = 1.0f;
*normal = reinterpret_cast<C3Vector*>(reinterpret_cast<uint8_t*>(*normal) + stride);
}
if (*vertexColor) {
CImVector value;
if (g_theGxDevicePtr->Caps().m_colorFormat == GxCF_rgba) {
value.b = color->r;
value.g = color->g;
value.r = color->b;
value.a = color->a;
} else {
value = *color;
}
**vertexColor = value;
*vertexColor = reinterpret_cast<CImVector*>(reinterpret_cast<uint8_t*>(*vertexColor) + stride);
}
if (*texCoord0) {
if (magma) {
(*texCoord0)->x = liquidVert->m_magmaVert.m_s * 0.00390625f;
(*texCoord0)->y = liquidVert->m_magmaVert.m_t * 0.00390625f;
} else {
C44Matrix rotation = matrix;
rotation.d0 = 0.0f;
rotation.d1 = 0.0f;
rotation.d2 = 0.0f;
rotation.d3 = 1.0f;
C3Vector local;
local.x = vertex.x - group->m_liquidCorner.x;
local.y = vertex.y - group->m_liquidCorner.y;
local.z = vertex.z - group->m_liquidCorner.z;
C2Vector uv(local * rotation);
(*texCoord0)->x = uv.x * 0.24f;
(*texCoord0)->y = 0.24f * uv.y;
}
*texCoord0 = reinterpret_cast<C2Vector*>(reinterpret_cast<uint8_t*>(*texCoord0) + stride);
}
if (*texCoord1) {
float depth = depthTable ? (*depthTable)[liquidVert->m_waterVert.m_flow1] : 0.0f;
(*texCoord1)->x = texCoord1U;
(*texCoord1)->y = depth;
*texCoord1 = reinterpret_cast<C2Vector*>(reinterpret_cast<uint8_t*>(*texCoord1) + stride);
}
}
// VERIFY: be9e0132 manual
// OFFSET: 0x007A7E50
static void* PolyClipVtxLerpTexCoords(const void* a, const void* b, float t) {
const uint16_t* from = static_cast<const uint16_t*>(a);
const uint16_t* to = static_cast<const uint16_t*>(b);
uint16_t* vert = reinterpret_cast<uint16_t*>(&s_smolVertCache[s_smolVertCacheSize++]);
vert[0] = static_cast<uint16_t>(from[0] + (to[0] - from[0]) * t);
vert[1] = static_cast<uint16_t>(t * (to[1] - from[1]) + from[1]);
return vert;
}
// VERIFY: 734af3f1 manual
// OFFSET: 0x007A7F00
static void* PolyClipVtxLerpDepth(const void* a, const void* b, float t) {
const uint8_t* from = static_cast<const uint8_t*>(a);
const uint8_t* to = static_cast<const uint8_t*>(b);
uint8_t* vert = reinterpret_cast<uint8_t*>(&s_smolVertCache[s_smolVertCacheSize++]);
vert[0] = static_cast<uint8_t>(from[0] + (to[0] - from[0]) * t);
return vert;
}
// VERIFY: 7cd73fec manual
// OFFSET: 0x007A7F60
uint16_t CMapObj::ClipGroupGeometry(CMapObjGroup* group, const C44Matrix& matrix, const CImVector* color, int32_t magma, float texCoord1U, uint32_t stride, C3Vector** position, C3Vector** normal, CImVector** vertexColor, C2Vector** texCoord0, C2Vector** texCoord1, uint16_t** indices, uint16_t baseVertex) {
uint16_t nextIndex = baseVertex;
uint16_t vertexCount = 0;
void* (*lerp)(const void*, const void*, float) = *texCoord1 ? PolyClipVtxLerpDepth : PolyClipVtxLerpTexCoords;
SMOPortalRef* refs = &this->m_portalRefList[group->m_portalStart];
SMOLTile* tile = group->m_liquidTileList;
for (int32_t y = 0; y < group->m_liquidTiles.y; y++) {
for (int32_t x = 0; x < group->m_liquidTiles.x; x++, tile++) {
if ((tile->m_flags & 0xF) == 0xF || !(tile->m_flags & 0x80)) {
continue;
}
int32_t row0 = y * group->m_liquidVerts.x;
int32_t row1 = row0 + group->m_liquidVerts.x;
int32_t corners[4] = { x + row0, x + row1, x + row1 + 1, x + row0 + 1 };
int32_t offsets[4][2] = { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 1, 0 } };
PolyClipper clipper;
C3Vector points[4];
for (uint32_t i = 0; i < 4; i++) {
SMOLiquidVert* liquidVert = &group->m_liquidVertexList[corners[i]];
points[i].x = (x + offsets[i][0]) * 4.1666665f + group->m_liquidCorner.x;
points[i].y = 4.1666665f * (y + offsets[i][1]) + group->m_liquidCorner.y;
points[i].z = liquidVert->m_waterVert.m_height;
clipper.AddVertex(points[i], liquidVert);
}
clipper.Begin();
for (int32_t p = 0; p < group->m_portalCount; p++) {
SMOPortalRef& ref = refs[p];
CMapObjGroup* other = this->GetGroup(ref.m_groupIndex, 0);
if (other && other->m_liquidCorner.x < points[2].x && other->m_liquidCorner.y < points[2].y && other->m_liquidTiles.x * 4.1666665f + other->m_liquidCorner.x > points[0].x && 4.1666665f * other->m_liquidTiles.y + other->m_liquidCorner.y > points[0].y) {
clipper.Clip(this->m_portalList[ref.m_portalIndex].m_plane, ref.m_side);
}
}
clipper.End();
s_smolVertCacheSize = 0;
int32_t started = 0;
for (PCResultsIterator it = clipper.GetResults(lerp); !it.HasFinished(); it.Next()) {
C3Vector vertex(0.0f, 0.0f, 0.0f);
const void* data;
it.GetVertex(vertex, data);
if (!started) {
*(*indices)++ = nextIndex;
started = 1;
}
int32_t unused;
WriteLiquidVertex(group, matrix, vertex, static_cast<const SMOLiquidVert*>(data), color, magma, texCoord1U, &unused, stride, position, normal, vertexColor, texCoord0, texCoord1);
vertexCount++;
*(*indices)++ = nextIndex;
nextIndex++;
}
if (started) {
*(*indices)++ = nextIndex - 1;
}
}
}
return vertexCount;
}
// VERIFY: 228c7c03 auto
// OFFSET: 0x007A8430
void CMapObj::SetEmissiveAmbient(CImVector color) {
s_emissiveAmbient = *reinterpret_cast<uint32_t*>(&color);
}
// VERIFY: b05f7aa9 manual
// OFFSET: 0x007A8440
static void SetShaderFogFromDayNight(int32_t mode) {
if (s_fogMode == mode) {
return;
}
s_fogMode = mode;
if (!mode) {
CShaderEffect::SetFogEnabled(0);
return;
}
DayNight::DNInfo* info = DayNight::GetInfo();
DNFogInfo* fog = (mode & 0x2) ? &info->m_fog : &info->m_fogInterior;
CImVector black;
*reinterpret_cast<uint32_t*>(&black) = 0xFF000000;
CImVector color = (mode & 0x4) ? black : fog->m_color;
CShaderEffect::SetFogParams(fog->m_start, fog->m_end, fog->m_density, color);
CShaderEffect::SetFogEnabled(1);
}
// VERIFY: 3cc915d8 auto
// OFFSET: 0x007A84D0
void CMapObj::SelectWorldShaders() {
if (!CShaderEffect::s_enableShaders) {
return;
}
uint32_t shadow = CShaderEffect::s_shadowValue;
if (shadow > 2) {
shadow = 2;
}
uint32_t vertexPermute = (CMapObj::s_lightingMode != 0) + 2 * (CWorldScene::s_fogPermute + 15 * shadow);
CShaderEffect::SetShaders(vertexPermute, CShaderEffect::SelectShadowShader());
}
// VERIFY: 0016a158 manual
// OFFSET: 0x007A8520
void CMapObj::UpdateMaterials() {
DayNight::DNInfo* info = DayNight::GetInfo();
for (uint32_t i = 0; i < static_cast<uint32_t>(this->m_materialsCount); i++) {
if (this->m_materialList[i].m_flags & 0x10) {
this->m_materialList[i].m_frameSidnColor = this->m_materialList[i].m_sidnColor;
int32_t scale = CMath::fint_(info->m_curve0 * 255.0f - 0.5f);
CImVector& color = this->m_materialList[i].m_frameSidnColor;
uint8_t r = static_cast<uint8_t>((scale * color.r) >> 8);
uint8_t g = static_cast<uint8_t>((scale * color.g) >> 8);
uint8_t b = static_cast<uint8_t>((scale * color.b) >> 8);
color.b = b;
color.g = g;
color.r = r;
color.a = 0;
}
}
}
// VERIFY: b4a27992 manual
// OFFSET: 0x007A85E0
uint32_t CMapObj::TransformAndClipVerts(uint32_t noOcclusion, C3Vector* verts, uint32_t vertCount, C3Vector& offset, C3Vector*& clippedVerts, uint32_t& clippedCount) {
static C3Vector s_worldVerts[12];
if (vertCount > 12) {
vertCount = 12;
}
for (uint32_t i = 0; i < vertCount; i++) {
C3Vector vert(verts[i].x + offset.x, verts[i].y + offset.y, offset.z + verts[i].z);
s_worldVerts[i] = vert;
s_worldVerts[i] = s_worldVerts[i] * s_mapObjToWorld;
}
if (CWorldOcclusion::GetClipVolumeCount() && !noOcclusion && CWorldOcclusion::QueryVolumes(s_worldVerts, vertCount)) {
clippedVerts = nullptr;
clippedCount = 0;
return 1;
}
CWorldScene::ClipVerts(s_worldVerts, vertCount, &clippedVerts, &clippedCount);
if (clippedCount < 3) {
clippedVerts = nullptr;
clippedCount = 0;
return 1;
}
for (uint32_t i = 0; i < clippedCount; i++) {
C4Vector vert;
vert.x = clippedVerts[i].x - CWorldScene::s_activeWorldView.x;
vert.y = clippedVerts[i].y - CWorldScene::s_activeWorldView.y;
vert.z = clippedVerts[i].z - CWorldScene::s_activeWorldView.z;
vert.w = 1.0f;
vert = vert * s_viewProj;
float w = 0.0001f;
if (vert.w >= 0.0001f) {
w = vert.w;
} else {
vert.w = 0.0001f;
}
float scale = 1.0f / w;
clippedVerts[i].x = scale * vert.x;
clippedVerts[i].y = scale * vert.y;
clippedVerts[i].z = vert.z;
}
return 0;
}
// VERIFY: d30bcd8f manual
// OFFSET: 0x007A8940
void CMapObj::SetEmissiveColor(CImVector color) {
color.a = 0;
uint32_t value = *reinterpret_cast<uint32_t*>(&color);
if (s_lastSidnColor == value) {
return;
}
s_lastSidnColor = value;
CImVector diffuse;
*reinterpret_cast<uint32_t*>(&diffuse) = 0xFF7F7F7F;
if (CShaderEffect::s_enableShaders) {
C3Vector& specular = CMap::s_mapLight->m_light.m_specColor;
C4Vector specularConst;
specularConst.x = specular.x;
specularConst.y = specular.y;
specularConst.z = specular.z;
specularConst.w = 14.0f;
C4Vector colors[2] = { C4Vector(diffuse), C4Vector(color) };
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Vertex, 28, &colors[0].x, 2);
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Vertex, 13, &specularConst.x, 1);
} else {
GxRsSet(GxRs_MatDiffuse, static_cast<int32_t>(0xFF7F7F7F));
GxRsSet(GxRs_MatEmissive, static_cast<int32_t>(value));
}
}
// VERIFY: 7e911082 manual
// OFFSET: 0x007A8B10
void CMapObjGroup::SetLighting(CMapObjGroup* group, uint32_t mode) {
if (CMapObj::s_lightingMode == mode) {
return;
}
CMapObj::s_lightingMode = mode;
DayNight::DNInfo* info = DayNight::GetInfo();
C3Vector ambient(0.0f, 0.0f, 0.0f);
C3Vector diffuse(0.0f, 0.0f, 0.0f);
switch (mode) {
case 1:
diffuse = C3Vector(info->m_light1.m_diffuse.r * 0.0039215689f, info->m_light1.m_diffuse.g * 0.0039215689f, info->m_light1.m_diffuse.b * 0.0039215689f);
ambient = C3Vector(info->m_light1.m_ambient.r * 0.0039215689f, info->m_light1.m_ambient.g * 0.0039215689f, 0.0039215689f * info->m_light1.m_ambient.b);
break;
case 2:
diffuse = C3Vector(info->m_light1.m_mid0.r * 0.0039215689f, info->m_light1.m_mid0.g * 0.0039215689f, info->m_light1.m_mid0.b * 0.0039215689f);
ambient = C3Vector(info->m_light1.m_mid1.r * 0.0039215689f, info->m_light1.m_mid1.g * 0.0039215689f, 0.0039215689f * info->m_light1.m_mid1.b);
break;
case 3: {
CImVector& color = group->m_parent->m_argbColor;
ambient = C3Vector(color.r * 0.0039215689f, color.g * 0.0039215689f, 0.0039215689f * color.b);
break;
}
default:
break;
}
CM2Light* light = &CMap::s_mapLight->m_light;
if (CShaderEffect::s_enableShaders) {
if (mode) {
C44Matrix view;
GxXformView(view);
C3Vector dir = TransformDirection(light->m_dir, view);
C4Vector ambientConst;
ambientConst.x = ambient.x;
ambientConst.y = ambient.y;
ambientConst.z = ambient.z;
ambientConst.w = 0.0f;
C4Vector diffuseConst;
diffuseConst.x = diffuse.x;
diffuseConst.y = diffuse.y;
diffuseConst.z = diffuse.z;
diffuseConst.w = 0.0f;
C4Vector dirConst;
dirConst.x = dir.x;
dirConst.y = dir.y;
dirConst.z = dir.z;
dirConst.w = 0.0f;
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Vertex, 9, &ambientConst.x, 1);
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Vertex, 10, &ambientConst.x, 1);
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Vertex, 11, &diffuseConst.x, 1);
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Vertex, 12, &dirConst.x, 1);
} else {
static C4Vector s_unlit = [] {
C4Vector unlit;
unlit.x = 0.0f;
unlit.y = 0.0f;
unlit.z = 0.0f;
unlit.w = 0.5f;
return unlit;
}();
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Vertex, 11, &s_unlit.x, 1);
}
} else if (mode) {
GxRsSet(GxRs_Lighting, static_cast<int32_t>(1));
C3Vector dirColor = light->m_dirColor;
C3Vector ambColor = light->m_ambColor;
light->m_dirColor = diffuse;
light->m_ambColor = ambient;
light->GxLightSet(0);
light->m_dirColor = dirColor;
light->m_ambColor = ambColor;
} else {
GxRsSet(GxRs_Lighting, static_cast<int32_t>(0));
}
}
// VERIFY: 725c9d38 auto
// OFFSET: 0x007A8F20
void CMapObj::AddExteriorPortalView(SMOPortal* portal, SMOPortalRef* ref, SPortalExt* ext, uint32_t destIsExterior) {
uint16_t flags = ext->m_flags;
if (flags & 0x4) {
return;
}
flags |= 0x4;
ext->m_flags = flags;
C3Vector offset(portal->m_plane.n.x * 0.01f, portal->m_plane.n.y * 0.01f, 0.01f * portal->m_plane.n.z);
if (ref->m_side > 0) {
offset = C3Vector(-offset.x, -offset.y, -offset.z);
}
C3Vector* clipped = nullptr;
uint32_t clippedCount = 0;
ext->m_flags |= this->TransformAndClipVerts((flags >> 4) & 1, &this->m_portalVertexList[portal->m_startVertex], portal->m_count, offset, clipped, clippedCount);
if (clippedCount > 2) {
CPortalView view;
CWorldScene::CalcScreenRectFromVerts(view.m_rect, clipped, clippedCount);
view.m_rect.minX = (view.m_rect.minX + 1.0f) * 0.5f;
view.m_rect.maxX = (view.m_rect.maxX + 1.0f) * 0.5f;
view.m_rect.minY = (view.m_rect.minY + 1.0f) * 0.5f;
view.m_rect.maxY = 0.5f * (view.m_rect.maxY + 1.0f);
view.m_maxViewDepth = this->CalcPortalFarthestDistance(portal);
CWorldScene::PushExteriorPortalView(&view);
CWorldScene::MergeIntoWorldRect(&view);
if (destIsExterior) {
CWorldScene::MergeIntoFrustumRect(&view);
}
}
}
// VERIFY: 9de874f4 manual
// OFFSET: 0x007A9090
void CMapObj::TransformPortal(SMOPortal* portal, SPortalExt* portalExt) {
this->ClassifyPortalPlane(portal, portalExt);
C3Vector* clipped = nullptr;
uint32_t clippedCount = 0;
uint16_t flags = portalExt->m_flags;
if (!(flags & 0x2)) {
C3Vector offset(0.0f, 0.0f, 0.0f);
portalExt->m_flags |= this->TransformAndClipVerts((flags >> 4) & 1, &this->m_portalVertexList[portal->m_startVertex], portal->m_count, offset, clipped, clippedCount);
}
if (portalExt->m_flags & 0x2) {
portalExt->m_rect.minX = -1.0f;
portalExt->m_rect.maxX = 1.0f;
portalExt->m_rect.maxY = 1.0f;
portalExt->m_rect.minY = -1.0f;
} else if (portalExt->m_flags & 0x1) {
portalExt->m_rect.minX = 3.4028235e38f;
portalExt->m_rect.maxX = -3.4028235e38f;
portalExt->m_rect.maxY = -3.4028235e38f;
portalExt->m_rect.minY = 3.4028235e38f;
} else {
CWorldScene::CalcScreenRectFromVerts(portalExt->m_rect, clipped, clippedCount);
}
}
// VERIFY: b0d6c3f6 auto
// OFFSET: 0x007A9160
void CWorldScene::SetupLighting(CM2Lighting* lighting, C3Vector* view) {
if (CShaderEffect::s_enableShaders) {
CWorldScene::s_fogPermute = lighting->m_lightCount;
if (CWorldScene::s_fogPermute) {
LocalLights localLights;
CShaderEffect::ComputeLocalLights(&localLights, CWorldScene::s_fogPermute, lighting->m_lights, view);
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Vertex, 17, reinterpret_cast<float*>(&localLights), 11);
}
} else {
lighting->SetupGxLights(view);
}
s_emissiveAmbient = 0;
}
// VERIFY: fbeb8080 auto
// OFFSET: 0x007A9200
void CMapObj::AddInteriorPortalView(SMOPortal* portal, SMOPortalRef* ref, SPortalExt* ext, TSGrowableArray<CPortalView>* views) {
uint16_t flags = ext->m_flags;
if (flags & 0xC) {
return;
}
C3Vector offset(portal->m_plane.n.x * 0.01f, portal->m_plane.n.y * 0.01f, 0.01f * portal->m_plane.n.z);
if (ref->m_side > 0) {
offset = C3Vector(-offset.x, -offset.y, -offset.z);
}
C3Vector* clipped = nullptr;
uint32_t clippedCount = 0;
ext->m_flags |= this->TransformAndClipVerts((flags >> 4) & 1, &this->m_portalVertexList[portal->m_startVertex], portal->m_count, offset, clipped, clippedCount);
if (clippedCount > 2) {
CPortalView view;
CWorldScene::CalcScreenRectFromVerts(view.m_rect, clipped, clippedCount);
C3Vector* dst = &s_portalVerts.m_data[s_portalVerts.m_count];
view.m_vertCount = clippedCount;
view.m_rect.minX = (view.m_rect.minX + 1.0f) * 0.5f;
view.m_verts = dst;
view.m_rect.maxX = (view.m_rect.maxX + 1.0f) * 0.5f;
view.m_rect.minY = (view.m_rect.minY + 1.0f) * 0.5f;
view.m_rect.maxY = 0.5f * (view.m_rect.maxY + 1.0f);
s_portalVerts.SetCount(clippedCount + s_portalVerts.m_count);
memcpy(dst, clipped, sizeof(C3Vector) * clippedCount);
views->Add(1, &view);
}
ext->m_flags |= 0x8;
}
// VERIFY: 8052ccf3 manual
// OFFSET: 0x007A9380
void CMapObj::UnifiedRender(CMapObjGroup* group, uint32_t index) {
group->m_timer = 0.0f;
group->AllocVB();
group->SetIndexVB();
group->SetVertexVB();
g_theGxDevicePtr->RsPush();
s_fogMode = -1;
CMapObj::s_lightingMode = -1;
s_lastSidnColor = 0xFFFFFFFF;
s_shadowInterior = -1;
if (!CShaderEffect::s_enableShaders) {
GxRsSet(GxRs_ColorMaterial, static_cast<int32_t>(2));
}
int32_t fogMode = 2 - (s_curGroupIsInterior != 0);
CGxTex* defaultTex = nullptr;
if (CMap::s_isStreamingMode) {
defaultTex = TextureGetGxTex(CWorldScene::s_defaultTexture, 1, nullptr);
}
for (uint32_t i = 0; i < static_cast<uint32_t>(group->m_batchListCount); i++) {
SMOBatch& batch = group->m_batchList[i];
if (!index) {
batch.m_flags &= 0xF;
}
if ((batch.m_flags & 0xF0) || CMapObj::CullBatch(&batch)) {
continue;
}
batch.m_flags |= 0xF0;
SMOMaterial& material = this->m_materialList[batch.m_texture];
CTexture* texture = material.Textures()[0];
CGxTex* gxTex0 = TextureGetGxTex(texture, 0, nullptr);
if (!gxTex0) {
if (!defaultTex) {
continue;
}
gxTex0 = defaultTex;
}
CGxTex* gxTex1 = nullptr;
if (material.Textures()[1]) {
gxTex1 = TextureGetGxTex(material.Textures()[1], 0, nullptr);
if (!gxTex1) {
if (!defaultTex) {
continue;
}
gxTex1 = defaultTex;
}
}
uint32_t shader = material.m_shader;
if (!shader && !material.m_blendMode && !TextureIsOpaque(texture)) {
shader = 4;
}
GxRsSet(GxRs_Culling, static_cast<int32_t>((material.m_flags & 0x4) == 0));
uint32_t sidn = (material.m_flags & 0x10) ? *reinterpret_cast<uint32_t*>(&material.m_frameSidnColor) : 0;
uint32_t sum = s_emissiveAmbient + sidn;
uint32_t carry = (sum ^ s_emissiveAmbient ^ sidn) & 0x1010100;
uint32_t saturated = (carry - (carry >> 8)) | (sum - carry);
CImVector emissive = *reinterpret_cast<CImVector*>(&saturated);
emissive.g >>= 1;
emissive.b >>= 1;
emissive.r >>= 1;
CMapObj::SetEmissiveColor(emissive);
GxTexSetWrap(gxTex0, static_cast<EGxTexWrapMode>((material.m_flags & 0x40) == 0), static_cast<EGxTexWrapMode>((material.m_flags & 0x80) == 0));
CShaderEffect* effect = CMapObj::s_unifiedShaders[shader];
g_theGxDevicePtr->RsSet(GxRs_Texture0, gxTex0);
g_theGxDevicePtr->RsSet(GxRs_Texture1, gxTex1);
effect->SetCurrent();
if (i >= group->m_transparencyBatchesCount) {
if (group->m_flags & 0x48) {
CMapObjGroup::SetLighting(group, (material.m_flags & 0x1) == 0);
if (s_shadowInterior) {
s_shadowInterior = 0;
CShadowCache::SetShadowMapGenericInterior(0);
CShaderEffect::s_shadowValue = CShadowCache::GetShadowValue();
}
SetShaderFogFromDayNight(2);
} else {
if (material.m_flags & 0x20) {
CMapObjGroup::SetLighting(group, 2);
} else {
CMapObjGroup::SetLighting(group, 3);
}
if (s_shadowInterior != 1) {
s_shadowInterior = 1;
CShadowCache::SetShadowMapGenericInterior(1);
CShaderEffect::s_shadowValue = CShadowCache::GetShadowValue() != 0;
}
SetShaderFogFromDayNight(fogMode);
}
GxRsSet(GxRs_BlendingMode, static_cast<int32_t>(material.m_blendMode));
CShaderEffect::SetAlphaRefDefault();
CMapObj::SelectWorldShaders();
CGxBatch draw;
draw.m_primType = GxPrim_Triangles;
draw.m_start = batch.m_indexStart;
draw.m_count = batch.m_indexCount;
draw.m_minIndex = batch.m_vertexStart;
draw.m_maxIndex = batch.m_vertexEnd;
g_theGxDevicePtr->Draw(&draw, 1);
continue;
}
SetShaderFogFromDayNight((material.m_flags & 0x2) == 0 ? fogMode : 0);
if (s_shadowInterior) {
s_shadowInterior = 0;
CShadowCache::SetShadowMapGenericInterior(0);
CShaderEffect::s_shadowValue = CShadowCache::GetShadowValue();
}
if (CShaderEffect::s_enableShaders) {
CMapObjGroup::SetLighting(group, (material.m_flags & 0x1) ? 0 : ((material.m_flags & 0x20) != 0) + 1);
SetShaderFogFromDayNight(~material.m_flags & 0x2);
GxRsSet(GxRs_BlendingMode, static_cast<int32_t>(9));
CShaderEffect::SetAlphaRefDefault();
CMapObj::SelectWorldShaders();
CGxBatch draw;
draw.m_primType = GxPrim_Triangles;
draw.m_start = batch.m_indexStart;
draw.m_count = batch.m_indexCount;
draw.m_minIndex = batch.m_vertexStart;
draw.m_maxIndex = batch.m_vertexEnd;
g_theGxDevicePtr->Draw(&draw, 1);
CMapObjGroup::SetLighting(group, 3);
SetShaderFogFromDayNight((material.m_flags & 0x2) == 0 ? fogMode : 0);
if (s_shadowInterior != 1) {
s_shadowInterior = 1;
CShadowCache::SetShadowMapGenericInterior(1);
CShaderEffect::s_shadowValue = CShadowCache::GetShadowValue() != 0;
}
GxRsSet(GxRs_BlendingMode, static_cast<int32_t>(7));
CShaderEffect::SetAlphaRefDefault();
CMapObj::SelectWorldShaders();
CGxBatch draw2;
draw2.m_primType = GxPrim_Triangles;
draw2.m_start = batch.m_indexStart;
draw2.m_count = batch.m_indexCount;
draw2.m_minIndex = batch.m_vertexStart;
draw2.m_maxIndex = batch.m_vertexEnd;
g_theGxDevicePtr->Draw(&draw2, 1);
continue;
}
GxRsSet(GxRs_ColorMaterial, static_cast<int32_t>(0));
group->SetTransparencyVB();
CMapObjGroup::SetLighting(group, (material.m_flags & 0x1) ? 0 : ((material.m_flags & 0x20) != 0) + 1);
SetShaderFogFromDayNight((material.m_flags & 0x2) ? 0 : 6);
GxRsSet(GxRs_BlendingMode, static_cast<int32_t>(9));
CShaderEffect::SetAlphaRefDefault();
CGxBatch draw;
draw.m_primType = GxPrim_Triangles;
draw.m_start = batch.m_indexStart;
draw.m_count = batch.m_indexCount;
draw.m_minIndex = batch.m_vertexStart;
draw.m_maxIndex = batch.m_vertexEnd;
g_theGxDevicePtr->Draw(&draw, 1);
CMapObjGroup::SetLighting(group, 3);
SetShaderFogFromDayNight((material.m_flags & 0x2) ? 0 : (fogMode | 4));
GxRsSet(GxRs_BlendingMode, static_cast<int32_t>(7));
CShaderEffect::SetAlphaRefDefault();
CGxBatch draw2;
draw2.m_primType = GxPrim_Triangles;
draw2.m_start = batch.m_indexStart;
draw2.m_count = batch.m_indexCount;
draw2.m_minIndex = batch.m_vertexStart;
draw2.m_maxIndex = batch.m_vertexEnd;
g_theGxDevicePtr->Draw(&draw2, 1);
group->SetVertexVB();
CMapObjGroup::SetLighting(group, 0);
SetShaderFogFromDayNight((material.m_flags & 0x2) == 0 ? fogMode : 0);
GxRsSet(GxRs_BlendingMode, static_cast<int32_t>(10));
CShaderEffect::SetAlphaRefDefault();
CGxBatch draw3;
draw3.m_primType = GxPrim_Triangles;
draw3.m_start = batch.m_indexStart;
draw3.m_count = batch.m_indexCount;
draw3.m_minIndex = batch.m_vertexStart;
draw3.m_maxIndex = batch.m_vertexEnd;
g_theGxDevicePtr->Draw(&draw3, 1);
GxRsSet(GxRs_ColorMaterial, static_cast<int32_t>(2));
}
g_theGxDevicePtr->RsPop();
}
// VERIFY: 9c6db61b manual
// OFFSET: 0x007ABF50
void CMapObj::RenderGroup(int32_t groupIndex, C44Matrix& matrix, TSExplicitList<CWFrustum, offsetof(CWFrustum, m_link)>* frustumList) {
CMapObjGroup* group = this->GetGroup(groupIndex, 0);
DebugLog("%s %s", this->m_wmoName, group->m_groupName);
if (!(group->m_unkLoadedFlag & 0x2)) {
this->AttenTransVerts(group);
}
CShaderEffect::SetGlobalLighting(&CMap::s_mapLight->m_light);
CShaderEffect::UpdateProjMatrix();
uint32_t index = 0;
for (CWFrustum* frustum = frustumList->Head(); frustum; frustum = frustumList->Next(frustum)) {
CWorldScene::FrustumSet(frustum);
CWorldScene::FrustumXform(matrix);
if (group->m_colorVertexList) {
(this->*CMapObj::s_renderGroupInterior)(group, index);
} else {
(this->*CMapObj::s_renderGroupExterior)(group, index);
}
index++;
}
if (CWorld::enables & 0x40000000) {
this->RenderNormals(group);
}
if (CWorld::enables & Enable_Portals) {
this->RenderPortals(group);
}
}
// VERIFY: 73f59e5b manual
// OFFSET: 0x007AC060
void CMapObj::RenderThruPortals(uint32_t groupNum, uint32_t fromGroup, CRect& ndcRect, uint32_t depth, int32_t interior) {
if (depth > s_maxPortalDepth) {
return;
}
CMapObjGroup* group = this->GetGroup(groupNum, 0);
if (!group || (group->m_flags & 0x10000)) {
return;
}
if (interior && (group->m_flags & 0x48)) {
interior = 0;
}
s_curGroupIsInterior = interior;
if (s_interiorPass && (group->m_flags & 0x40000)) {
CWorldScene::s_interiorSkybox = this->m_skybox;
}
if (CMapObj::gRenderCallback) {
CMapObj::gRenderCallback(groupNum, CMapObj::gRenderUserParam);
}
if (!group->m_portalCount) {
return;
}
static TSGrowableArray<CPortalView> s_pendingPortalViews;
static TSGrowableArray<CRect> s_coveredRects;
if (!s_interiorPass && !depth) {
s_pendingPortalViews.SetCount(0);
s_coveredRects.SetCount(0);
}
SMOPortalRef* ref = &this->m_portalRefList[group->m_portalStart];
for (uint32_t i = 0; i < group->m_portalCount; i++, ref++) {
uint32_t destGroup = ref->m_groupIndex;
if (destGroup == 0xFFFF) {
continue;
}
SMOPortal* portal = &this->m_portalList[ref->m_portalIndex];
if (destGroup == fromGroup) {
continue;
}
uint32_t destFlags = this->GetGroupFlags(destGroup);
SPortalExt* ext = &s_portalExt[ref->m_portalIndex];
if (ext->m_stamp != s_portalStamp) {
ext->m_stamp = s_portalStamp;
ext->m_flags = 0;
if (!(destFlags & 0x8) && !(group->m_flags & 0x8)) {
ext->m_flags = 0x10;
}
this->TransformPortal(portal, ext);
}
float side = portal->m_plane.n.y * s_camPosLocal.y + portal->m_plane.n.z * s_camPosLocal.z + portal->m_plane.n.x * s_camPosLocal.x + portal->m_plane.d;
if (ref->m_side < 0) {
side = -side;
}
if (side < 0.0f) {
if (!s_interiorPass && !depth) {
CRect covered;
covered.minY = 0.0f;
covered.minX = 0.0f;
covered.maxY = 1.0f;
covered.maxX = 1.0f;
s_coveredRects.Add(1, &covered);
}
continue;
}
if ((!(ext->m_flags & 0x2) && (ext->m_flags & 0x1)) || ndcRect.maxX < ext->m_rect.minX || ndcRect.minX > ext->m_rect.maxX || ndcRect.maxY < ext->m_rect.minY || ndcRect.minY > ext->m_rect.maxY) {
continue;
}
CRect clip = ext->m_rect;
if (clip.minX < ndcRect.minX) {
clip.minX = ndcRect.minX;
}
if (clip.maxX > ndcRect.maxX) {
clip.maxX = ndcRect.maxX;
}
if (ndcRect.minY > clip.minY) {
clip.minY = ndcRect.minY;
}
if (clip.maxX > ndcRect.maxX) {
clip.maxX = ndcRect.maxX;
}
if (fequalz(clip.minX, clip.maxX, 0.001f) || fequalz(clip.minY, clip.maxY, 0.001f)) {
continue;
}
if (s_interiorPass) {
if (destFlags & 0x50148) {
this->AddExteriorPortalView(portal, ref, ext, destFlags & 0x10008);
if (destFlags & 0x10008) {
continue;
}
}
} else {
if (destFlags & 0x10008) {
continue;
}
if (!depth && s_cullStateValid && !(destFlags & 0x140)) {
this->AddInteriorPortalView(portal, ref, ext, &s_pendingPortalViews);
}
}
CRect one;
one.minY = 1.0f;
one.minX = 1.0f;
one.maxY = 1.0f;
one.maxX = 1.0f;
CRect two;
two.minY = 2.0f;
two.minX = 2.0f;
two.maxY = 2.0f;
two.maxX = 2.0f;
CRect frustumRect = (clip + one) / two;
CWorldScene::FrustumPush();
CWorldScene::FrustumSet(CWorldScene::s_frustumCorners, frustumRect);
this->RenderThruPortals(destGroup, groupNum, clip, depth + 1, interior);
CWorldScene::FrustumPop();
}
if (depth || !s_pendingPortalViews.Count()) {
return;
}
for (uint32_t i = 0; i < s_pendingPortalViews.Count(); i++) {
CPortalView& view = s_pendingPortalViews[i];
uint32_t j;
for (j = 0; j < s_coveredRects.Count(); j++) {
CRect& covered = s_coveredRects[j];
if (view.m_rect.maxX >= covered.minX && view.m_rect.maxY >= covered.minY && view.m_rect.minX <= covered.maxX && view.m_rect.minY <= covered.maxY) {
break;
}
}
if (j >= s_coveredRects.Count()) {
CWorldScene::PushPortalView(&view);
}
}
s_pendingPortalViews.SetCount(0);
s_coveredRects.SetCount(0);
}
// VERIFY: 687366c6 manual
// OFFSET: 0x007AC6A0
void CMapObj::ExteriorRender(CMapObjGroup* group, uint32_t index) {
if (group->m_parent->m_header->m_flags & 0x2) {
this->UnifiedRender(group, index);
return;
}
group->m_timer = 0.0f;
group->AllocVB();
group->SetIndexVB();
group->SetVertexVB();
g_theGxDevicePtr->RsPush();
s_fogMode = -1;
CMapObj::s_lightingMode = -1;
s_lastSidnColor = 0xFFFFFFFF;
s_shadowInterior = -1;
CGxTex* defaultTex = nullptr;
if (CMap::s_isStreamingMode) {
defaultTex = TextureGetGxTex(CWorldScene::s_defaultTexture, 1, nullptr);
}
for (uint32_t i = 0; i < group->m_extBatchCount; i++) {
SMOBatch& batch = group->m_batchList[i];
if (!index) {
batch.m_flags &= 0xF;
}
if ((batch.m_flags & 0xF0) || CMapObj::CullBatch(&batch)) {
continue;
}
batch.m_flags |= 0xF0;
SMOMaterial& material = this->m_materialList[batch.m_texture];
CTexture* texture = material.Textures()[0];
CGxTex* gxTex0 = TextureGetGxTex(texture, 0, nullptr);
if (!gxTex0) {
if (!defaultTex) {
continue;
}
gxTex0 = defaultTex;
}
CGxTex* gxTex1 = defaultTex;
if (material.Textures()[1]) {
gxTex1 = TextureGetGxTex(material.Textures()[1], 0, nullptr);
if (!gxTex1) {
if (!defaultTex) {
continue;
}
gxTex1 = defaultTex;
}
}
uint32_t shader = material.m_shader;
if (!shader && !material.m_blendMode && !TextureIsOpaque(texture)) {
shader = 4;
}
SetShaderFogFromDayNight(~material.m_flags & 0x2);
CMapObjGroup::SetLighting(group, (material.m_flags & 0x1) == 0);
if (group->m_flags & 0x48) {
if (s_shadowInterior) {
s_shadowInterior = 0;
CShadowCache::SetShadowMapGenericInterior(0);
CShaderEffect::s_shadowValue = CShadowCache::GetShadowValue();
}
} else {
if (s_shadowInterior != 1) {
s_shadowInterior = 1;
CShadowCache::SetShadowMapGenericInterior(1);
CShaderEffect::s_shadowValue = CShadowCache::GetShadowValue() != 0;
}
}
GxRsSet(GxRs_Culling, static_cast<int32_t>((material.m_flags & 0x4) == 0));
uint32_t sidn = (material.m_flags & 0x10) ? *reinterpret_cast<uint32_t*>(&material.m_frameSidnColor) : 0;
uint32_t sum = s_emissiveAmbient + sidn;
uint32_t carry = (sum ^ s_emissiveAmbient ^ sidn) & 0x1010100;
uint32_t saturated = (carry - (carry >> 8)) | (sum - carry);
CImVector emissive = *reinterpret_cast<CImVector*>(&saturated);
emissive.g >>= 1;
emissive.b >>= 1;
emissive.r >>= 1;
CMapObj::SetEmissiveColor(emissive);
GxRsSet(GxRs_BlendingMode, static_cast<int32_t>(material.m_blendMode));
CShaderEffect::SetAlphaRefDefault();
GxTexSetWrap(gxTex0, static_cast<EGxTexWrapMode>((material.m_flags & 0x40) == 0), static_cast<EGxTexWrapMode>((material.m_flags & 0x80) == 0));
CShaderEffect* effect = CMapObj::s_classicShaders[shader];
g_theGxDevicePtr->RsSet(GxRs_Texture0, gxTex0);
g_theGxDevicePtr->RsSet(GxRs_Texture1, gxTex1);
effect->SetCurrent();
CMapObj::SelectWorldShaders();
CGxBatch draw;
draw.m_primType = GxPrim_Triangles;
draw.m_start = batch.m_indexStart;
draw.m_count = batch.m_indexCount;
draw.m_minIndex = batch.m_vertexStart;
draw.m_maxIndex = batch.m_vertexEnd;
g_theGxDevicePtr->Draw(&draw, 1);
}
g_theGxDevicePtr->RsPop();
}
// VERIFY: 8a73759b manual
// OFFSET: 0x007AC9F0
void CMapObj::InteriorRender(CMapObjGroup* group, uint32_t index) {
if (group->m_parent->m_header->m_flags & 0x2) {
this->UnifiedRender(group, index);
return;
}
group->m_timer = 0.0f;
group->AllocVB();
group->SetIndexVB();
group->SetVertexVB();
g_theGxDevicePtr->RsPush();
s_fogMode = -1;
CMapObj::s_lightingMode = -1;
s_lastSidnColor = 0xFFFFFFFF;
s_shadowInterior = -1;
int32_t fogMode = 2 - (s_curGroupIsInterior != 0);
CGxTex* defaultTex = nullptr;
if (CMap::s_isStreamingMode) {
defaultTex = TextureGetGxTex(CWorldScene::s_defaultTexture, 1, nullptr);
}
for (uint32_t i = 0; i < static_cast<uint32_t>(group->m_batchListCount); i++) {
SMOBatch& batch = group->m_batchList[i];
if (!index) {
batch.m_flags &= 0xF;
}
if ((batch.m_flags & 0xF0) || CMapObj::CullBatch(&batch)) {
continue;
}
batch.m_flags |= 0xF0;
SMOMaterial& material = this->m_materialList[batch.m_texture];
CTexture* texture = material.Textures()[0];
CGxTex* gxTex0 = TextureGetGxTex(texture, 0, nullptr);
if (!gxTex0) {
if (!defaultTex) {
continue;
}
gxTex0 = defaultTex;
}
CGxTex* gxTex1 = nullptr;
if (material.Textures()[1]) {
gxTex1 = TextureGetGxTex(material.Textures()[1], 0, nullptr);
if (!gxTex1) {
if (!defaultTex) {
continue;
}
gxTex1 = defaultTex;
}
}
uint32_t shader = material.m_shader;
if (!shader && !material.m_blendMode && !TextureIsOpaque(texture)) {
shader = 4;
}
GxRsSet(GxRs_Culling, static_cast<int32_t>((material.m_flags & 0x4) == 0));
uint32_t sidn = (material.m_flags & 0x10) ? *reinterpret_cast<uint32_t*>(&material.m_frameSidnColor) : 0;
uint32_t sum = s_emissiveAmbient + sidn;
uint32_t carry = (sum ^ s_emissiveAmbient ^ sidn) & 0x1010100;
uint32_t saturated = (carry - (carry >> 8)) | (sum - carry);
CImVector emissive = *reinterpret_cast<CImVector*>(&saturated);
emissive.g >>= 1;
emissive.b >>= 1;
emissive.r >>= 1;
CMapObj::SetEmissiveColor(emissive);
GxTexSetWrap(gxTex0, static_cast<EGxTexWrapMode>((material.m_flags & 0x40) == 0), static_cast<EGxTexWrapMode>((material.m_flags & 0x80) == 0));
CShaderEffect* effect = CMapObj::s_classicShaders[shader];
g_theGxDevicePtr->RsSet(GxRs_Texture0, gxTex0);
g_theGxDevicePtr->RsSet(GxRs_Texture1, gxTex1);
effect->SetCurrent();
if (i >= group->m_transparencyBatchesCount) {
bool interiorBatch = i < static_cast<uint32_t>(group->m_transparencyBatchesCount + group->m_intBatchCount);
SetShaderFogFromDayNight((material.m_flags & 0x2) == 0 ? fogMode : 0);
if (interiorBatch) {
CMapObjGroup::SetLighting(group, 0);
} else {
CMapObjGroup::SetLighting(group, ((material.m_flags & 0x20) != 0) + 1);
}
if (s_shadowInterior != 1) {
s_shadowInterior = 1;
CShadowCache::SetShadowMapGenericInterior(1);
CShaderEffect::s_shadowValue = CShadowCache::GetShadowValue() != 0;
}
GxRsSet(GxRs_BlendingMode, static_cast<int32_t>(material.m_blendMode));
CShaderEffect::SetAlphaRefDefault();
CMapObj::SelectWorldShaders();
CGxBatch draw;
draw.m_primType = GxPrim_Triangles;
draw.m_start = batch.m_indexStart;
draw.m_count = batch.m_indexCount;
draw.m_minIndex = batch.m_vertexStart;
draw.m_maxIndex = batch.m_vertexEnd;
g_theGxDevicePtr->Draw(&draw, 1);
continue;
}
if (s_shadowInterior) {
s_shadowInterior = 0;
CShadowCache::SetShadowMapGenericInterior(0);
CShaderEffect::s_shadowValue = CShadowCache::GetShadowValue();
}
CMapObjGroup::SetLighting(group, ((material.m_flags & 0x20) != 0) + 1);
SetShaderFogFromDayNight(~material.m_flags & 0x2);
GxRsSet(GxRs_BlendingMode, static_cast<int32_t>(9));
CShaderEffect::SetAlphaRefDefault();
CMapObj::SelectWorldShaders();
CGxBatch draw;
draw.m_primType = GxPrim_Triangles;
draw.m_start = batch.m_indexStart;
draw.m_count = batch.m_indexCount;
draw.m_minIndex = batch.m_vertexStart;
draw.m_maxIndex = batch.m_vertexEnd;
g_theGxDevicePtr->Draw(&draw, 1);
CMapObjGroup::SetLighting(group, 0);
SetShaderFogFromDayNight((material.m_flags & 0x2) == 0 ? fogMode : 0);
if (s_shadowInterior != 1) {
s_shadowInterior = 1;
CShadowCache::SetShadowMapGenericInterior(1);
CShaderEffect::s_shadowValue = CShadowCache::GetShadowValue() != 0;
}
GxRsSet(GxRs_BlendingMode, static_cast<int32_t>(7));
CShaderEffect::SetAlphaRefDefault();
CMapObj::SelectWorldShaders();
CGxBatch draw2;
draw2.m_primType = GxPrim_Triangles;
draw2.m_start = batch.m_indexStart;
draw2.m_count = batch.m_indexCount;
draw2.m_minIndex = batch.m_vertexStart;
draw2.m_maxIndex = batch.m_vertexEnd;
g_theGxDevicePtr->Draw(&draw2, 1);
}
g_theGxDevicePtr->RsPop();
}
// VERIFY: 9b1bf024 manual
// OFFSET: 0x007AD020
void CMapObj::PrepareUpdate() {
s_portalStamp++;
CWorldScene::s_curMapObjDef = nullptr;
s_stampedMapObjDef = nullptr;
s_portalVerts.SetCount(0);
switch (CMapObj::s_renderMode) {
case 0:
CMapObj::s_renderGroupExterior = &CMapObj::RenderGroupCollisionFaces;
CMapObj::s_renderGroupInterior = &CMapObj::RenderGroupCollisionFaces;
break;
case 1:
CMapObj::s_renderGroupExterior = &CMapObj::RenderGroupDetailFaces;
CMapObj::s_renderGroupInterior = &CMapObj::RenderGroupDetailFaces;
break;
case 2:
CMapObj::s_renderGroupExterior = &CMapObj::RenderGroupRenderFaces;
CMapObj::s_renderGroupInterior = &CMapObj::RenderGroupRenderFaces;
break;
case 3:
CMapObj::s_renderGroupExterior = &CMapObj::RenderGroupTransFaces;
CMapObj::s_renderGroupInterior = &CMapObj::RenderGroupTransFaces;
break;
case 4:
CMapObj::s_renderGroupExterior = &CMapObj::RenderGroupCollidable;
CMapObj::s_renderGroupInterior = &CMapObj::RenderGroupCollidable;
break;
default:
CMapObj::s_renderGroupExterior = &CMapObj::ExteriorRender;
CMapObj::s_renderGroupInterior = &CMapObj::InteriorRender;
if (!(CWorld::enables & Enable_MapObjTex)) {
CMapObj::s_renderGroupInterior = &CMapObj::RenderGroupLightmapTex;
} else if (!(CWorld::enables & Enable_MapObjLight)) {
CMapObj::s_renderGroupInterior = &CMapObj::RenderGroupColorTex;
}
break;
}
CMapObj* mapObj = CMapObj::mapObjHash.m_fulllist.Head();
while (mapObj) {
CMapObj* next = CMapObj::mapObjHash.Next(mapObj);
mapObj->UpdateMaterials();
CMapObjGroup* group = mapObj->m_mapObjGroupList.Head();
while (group) {
CMapObjGroup* nextGroup = mapObj->m_mapObjGroupList.Next(group);
group->m_timer += FrameTime::s_tickTimeSec;
if (group->m_timer > 5.0f) {
group->FreeVB();
}
group = nextGroup;
}
if (!mapObj->m_refCount) {
mapObj->m_flushTimer += FrameTime::s_tickTimeSec;
if (mapObj->m_flushTimer > 10.0f) {
CMapObj::mapObjHash.Unlink(mapObj);
CMap::FreeMapObj(mapObj);
}
}
mapObj = next;
}
if (CMap::s_isStreamingMode) {
CMapObj::ProcessAsyncLoadQueue();
}
}
// VERIFY: d0b199c6 manual
// OFFSET: 0x007AD1F0
void CMapObj::RenderInterior(C44Matrix& mat, C44Matrix& invMat, C3Vector& worldPos, C3Vector& camTarget, TSGrowableArray<uint32_t>* groups) {
this->SetupMapObjDefCull(mat, invMat, worldPos, camTarget);
s_interiorPass = 1;
CWorldScene::s_unk_CD8620 = 0;
if (CWorldScene::s_curMapObjDef != s_stampedMapObjDef) {
s_portalStamp++;
s_stampedMapObjDef = CWorldScene::s_curMapObjDef;
}
CWorldScene::FrustumPush();
CRect ndcRect;
ndcRect.minY = -1.0f;
ndcRect.minX = -1.0f;
ndcRect.maxY = 1.0f;
ndcRect.maxX = 1.0f;
for (uint32_t i = 0; i < groups->Count(); i++) {
CMapObjGroup* group = this->GetGroup(groups->m_data[i], 0);
if (!group) {
continue;
}
if (!(group->m_flags & 0x48)) {
CWorldScene::s_unk_CD8620 = 1;
}
this->RenderThruPortals(groups->m_data[i], 0xFFFF, ndcRect, 0, 1);
}
CWorldScene::FrustumPop();
CAaBox box;
box.b = C3Vector(0.0f, 0.0f, 0.0f);
box.t = C3Vector(0.0f, 0.0f, 0.0f);
for (uint32_t i = 0; i < static_cast<uint32_t>(this->m_groupInfoCount); i++) {
SMOGroupInfo& info = this->m_groupInfo[i];
if (!(info.m_flags & 0x10000)) {
continue;
}
CWorldMath::TransformAABox(mat, info.m_boundingBox, box);
if (CWorldScene::FrustumCull(&box)) {
continue;
}
if (this->GetGroup(i, 0) && CMapObj::gRenderCallback) {
CMapObj::gRenderCallback(i, CMapObj::gRenderUserParam);
}
}
}
// VERIFY: 8c94ba81 auto
// OFFSET: 0x007AD350
void CMapObj::RenderThruPortalsExterior(C44Matrix& mat, C44Matrix& invMat, C3Vector& worldPos, C3Vector& camTarget, CRect& ndcRect, int32_t groupNum) {
this->SetupMapObjDefCull(mat, invMat, worldPos, camTarget);
s_interiorPass = 0;
if (CWorldScene::s_curMapObjDef != s_stampedMapObjDef) {
s_portalStamp++;
s_stampedMapObjDef = CWorldScene::s_curMapObjDef;
}
this->RenderThruPortals(groupNum, 0xFFFF, ndcRect, 0, 0);
}
// VERIFY: cf5959ca auto
// OFFSET: 0x007AE030
void CMapObj::Delete(CMapObj* mapObj) {
if (--mapObj->m_refCount <= 0) {
mapObj->m_flushTimer = 0.0f;
}
}
// VERIFY: 38e3657c auto
// OFFSET: 0x007AE060
void CMapObj::UpdatePools() {
CMapObj::bPoolsDirty = 0;
}
// VERIFY: 1dd1286b auto
// OFFSET: 0x007AE070
void CMapObj::InitPtrs() {
this->m_header = nullptr;
this->m_textureNameList = nullptr;
this->m_groupNameList = nullptr;
this->m_groupInfo = nullptr;
this->m_portalVertexList = nullptr;
this->m_portalList = nullptr;
this->m_portalRefList = nullptr;
this->m_lightList = nullptr;
this->m_doodadSetList = nullptr;
this->m_doodadNameList = nullptr;
this->m_doodadDefList = nullptr;
this->m_fogList = nullptr;
this->m_convexVolumePlanes = nullptr;
this->m_texturesSize = 0;
this->m_groupNameSize = 0;
this->m_groupInfoCount = 0;
this->m_planeVertCount = 0;
this->m_portalsCount = 0;
this->m_portalRefCount = 0;
this->m_ligtsCount = 0;
this->m_doodadSetCount = 0;
this->m_doodadNameSize = 0;
this->m_doodadDefCount = 0;
this->m_fogsCount = 0;
this->m_convexVolumePlaneCount = 0;
}
// VERIFY: 692709d1 manual
// OFFSET: 0x007AE110
void CMapObj::AsyncFailedCallback(CAsyncObject* object) {
void* buffer = object->m_buffer;
AsyncFileReadDestroyObject(object);
SMemFree(buffer, __FILE__, __LINE__, 0);
}
// VERIFY: f7f5970e auto
// OFFSET: 0x007AE1A0
void CMapObj::ReadGroup(uint32_t index) {
this->ReadGroup(index, false);
}
// VERIFY: d92cbc0c auto
// OFFSET: 0x007AE1C0
void CMapObj::WaitLoad() {
while (this->m_asyncObject) {
AsyncFileReadWait(this->m_asyncObject);
}
}
// VERIFY: edb456aa manual
// OFFSET: 0x007AE300
void CMapObj::Init() {
this->m_flushTimer = 0.0f;
this->m_refCount = 0;
this->m_pWmoData = nullptr;
this->m_bbox.b = C3Vector(0.0f, 0.0f, 0.0f);
this->m_distToCamera = 3.4028235e38f;
this->m_bbox.t = C3Vector(0.0f, 0.0f, 0.0f);
this->m_wmoFileSize = 0;
this->m_asyncObject = nullptr;
this->m_isGroupLoaded = 0;
this->m_interiorGroupCount = 0xFFFF;
this->m_materialList = nullptr;
this->m_materialsCount = 0;
this->m_mapObjGroupCount = 0;
this->InitPtrs();
}
// VERIFY: b756cecb manual
// OFFSET: 0x007AE3B0
void CMapObj::Clear() {
int32_t freeData = 1;
if (this->m_asyncObject) {
freeData = AsyncFile::Cancel(this->m_asyncObject, CMapObj::AsyncFailedCallback);
this->m_asyncObject = nullptr;
}
for (uint32_t i = 0; i < static_cast<uint32_t>(this->m_materialsCount); i++) {
for (uint32_t j = 0; j < 2; j++) {
if (this->m_materialList[i].Textures()[j]) {
HandleClose(reinterpret_cast<HOBJECT>(this->m_materialList[i].Textures()[j]));
this->m_materialList[i].Textures()[j] = nullptr;
}
}
}
for (uint32_t i = 0; i < static_cast<uint32_t>(this->m_mapObjGroupCount); i++) {
CMap::FreeMapObjGroup(this->m_mapObjGroupArray[i]);
this->m_mapObjGroupArray[i] = nullptr;
}
this->m_mapObjGroupCount = 0;
this->InitPtrs();
if (this->m_pWmoData) {
if (freeData) {
SMemFree(this->m_pWmoData, __FILE__, __LINE__, 0);
}
this->m_pWmoData = nullptr;
}
this->m_wmoFileSize = 0;
}
// VERIFY: c6f5dc77 manual
// OFFSET: 0x007AE4C0
int32_t CMapObj::IsGroupLoaded(int32_t index) {
if (this->m_isGroupLoaded) {
return this->m_mapObjGroupArray[index]->m_unkLoadedFlag & 1;
}
return 0;
}
// VERIFY: 2a027261 manual
// OFFSET: 0x007AE4F0
int32_t CMapObj::IsGroupLoading(int32_t index) {
return this->m_isGroupLoaded && this->m_mapObjGroupArray[index]->m_asyncObjPtr != nullptr;
}
// VERIFY: bd150d57 manual
// OFFSET: 0x007AE520
void CMapObj::GetBounds(CAaSphere& sphere) {
if (this->m_isGroupLoaded) {
float sumY = this->m_bbox.t.y + this->m_bbox.b.y;
float sumZ = this->m_bbox.t.z + this->m_bbox.b.z;
sphere.c.x = (this->m_bbox.t.x + this->m_bbox.b.x) * 0.5f;
sphere.c.y = sumY * 0.5f;
sphere.c.z = 0.5f * sumZ;
float dz = this->m_bbox.t.z - sphere.c.z;
float dy = this->m_bbox.t.y - sphere.c.y;
float dx = this->m_bbox.t.x - sphere.c.x;
sphere.r = sqrt(dx * dx + (dy * dy + dz * dz));
} else {
sphere.c.x = 0.0f;
sphere.r = 0.0f;
sphere.c.y = 0.0f;
sphere.c.z = 0.0f;
}
}
// VERIFY: ebd0cfad manual
// OFFSET: 0x007AE5E0
void CMapObj::GetBounds(CAaBox* box) {
if (this->m_isGroupLoaded) {
*box = this->m_bbox;
} else {
box->b = C3Vector(0.0f, 0.0f, 0.0f);
box->t = C3Vector(0.0f, 0.0f, 0.0f);
}
}
// VERIFY: 3ce41eea manual
// OFFSET: 0x007AE670
void CMapObj::GetGroupBounds(CAaSphere* sphere, int32_t index) {
if (this->m_isGroupLoaded) {
CAaBox& box = this->m_groupInfo[index].m_boundingBox;
float sumY = box.t.y + box.b.y;
float sumZ = box.t.z + box.b.z;
sphere->c.x = (box.t.x + box.b.x) * 0.5f;
sphere->c.y = sumY * 0.5f;
sphere->c.z = 0.5f * sumZ;
float dz = box.t.z - sphere->c.z;
float dy = box.t.y - sphere->c.y;
float dx = box.t.x - sphere->c.x;
sphere->r = sqrt(dx * dx + (dy * dy + dz * dz));
} else {
sphere->c.x = 0.0f;
sphere->r = 0.0f;
sphere->c.y = 0.0f;
sphere->c.z = 0.0f;
}
}
// VERIFY: a237d260 manual
// OFFSET: 0x007AE720
void CMapObj::GetGroupBounds(CAaBox* box, int32_t index) {
if (this->m_isGroupLoaded) {
*box = this->m_groupInfo[index].m_boundingBox;
} else {
box->b.x = 0.0f;
box->b.y = 0.0f;
box->t.x = 0.0f;
box->b.z = 0.0f;
box->t.y = 0.0f;
box->t.z = 0.0f;
}
}
// VERIFY: edac55fb manual
// OFFSET: 0x007AE7B0
uint32_t CMapObj::GetGroupFlags(int32_t index) {
if (this->m_isGroupLoaded) {
return this->m_groupInfo[index].m_flags;
}
return 0;
}
// VERIFY: 8c25cdca manual
// OFFSET: 0x007AE7E0
bool CMapObj::TestBounds(CAaBox& box) {
return this->m_isGroupLoaded && this->m_bbox.Intersects(box);
}
// VERIFY: 1571ed48 manual
// OFFSET: 0x007AE810
bool CMapObj::ContainsPointInBounds(C3Vector& point) {
return this->m_isGroupLoaded && this->m_bbox.ContainsPoint(point);
}
// VERIFY: 8e7e27fe manual
// OFFSET: 0x007AE840
bool CMapObj::TestBounds(C3Vector& start, C3Vector& end) {
return this->m_isGroupLoaded && CWorldMath::VectorIntersectAABox2(this->m_bbox, start, end);
}
// VERIFY: 735b2379 auto
// OFFSET: 0x007AE880
bool CMapObj::TestGroupBounds(C3Vector& start, C3Vector& end, uint32_t groupNum) {
return this->m_isGroupLoaded && (this->m_mapObjGroupArray[groupNum]->m_unkLoadedFlag & 1) && CWorldMath::VectorIntersectAABox2(this->m_groupInfo[groupNum].m_boundingBox, start, end);
}
// VERIFY: 6fd4dc44 auto
// OFFSET: 0x007AE970
bool CMapObj::GroupBoundingBoxIntersectsSphere(C3Vector& pos, uint32_t groupNum, float radius) {
if (!this->m_isGroupLoaded || !(this->m_mapObjGroupArray[groupNum]->m_unkLoadedFlag & 1)) {
return false;
}
CAaBox& box = this->m_groupInfo[groupNum].m_boundingBox;
if (pos.x + radius < box.b.x || pos.x - radius > box.t.x || pos.y + radius < box.b.y || pos.y - radius > box.t.y || radius + pos.z < box.b.z || pos.z - radius > box.t.z) {
return false;
}
return true;
}
// VERIFY: fa51d8fa manual
// OFFSET: 0x007AEA80
CMapObjGroup* CMapObj::GetGroup(int32_t index, int32_t a3) {
if (!this->m_isGroupLoaded) {
return nullptr;
}
CMapObjGroup* group = this->m_mapObjGroupArray[index];
if (!(group->m_unkLoadedFlag & 1) && !a3) {
return nullptr;
}
return group;
}
// VERIFY: 0d13eb33 auto
// OFFSET: 0x007AEAB0
void CMapObj::WaitLoadGroup(uint32_t index) {
CMapObjGroup* group = this->m_mapObjGroupArray[index];
while (group->m_asyncObjPtr) {
AsyncFileReadWait(group->m_asyncObjPtr);
}
}
// VERIFY: ca64417c auto
// OFFSET: 0x007AEAE0
char* CMapObj::GetGroupName(int32_t index) {
if (this->m_isGroupLoaded) {
CMapObjGroup* group = this->m_mapObjGroupArray[index];
if (group->m_unkLoadedFlag & 1) {
return group->m_groupName;
}
}
return nullptr;
}
// VERIFY: 5d16452e manual
// OFFSET: 0x007AEB10
SMOGroupInfo* CMapObj::GetGroupInfo(int32_t index) {
if (this->m_isGroupLoaded) {
return &this->m_groupInfo[index];
}
return nullptr;
}
// VERIFY: 3afaacbc manual
// OFFSET: 0x007AEC30
int32_t CMapObj::GetDoodadSet(uint32_t index) {
if (!this->m_isGroupLoaded || index >= this->m_doodadDefCount) {
return -1;
}
for (uint32_t i = 0; i < this->m_doodadSetCount; i++) {
SMODoodadSet& set = this->m_doodadSetList[i];
if (set.m_count && index >= set.m_startIdx && index <= set.m_count + set.m_startIdx - 1) {
return i;
}
}
return -1;
}
// VERIFY: 9a315686 auto
// OFFSET: 0x007AF280
bool CMapObj::VectorIntersectPortal(const C3Segment& seg, float* t, uint32_t* groups, int32_t useSphere) {
C3Ray ray;
ray.origin = seg.b;
float dx = seg.t.x - seg.b.x;
float dy = seg.t.y - seg.b.y;
float dz = seg.t.z - seg.b.z;
float length = sqrtf(dz * dz + dy * dy + dx * dx);
float inv = 1.0f / length;
ray.dir = C3Vector(dx * inv, dy * inv, inv * dz);
float maxT = length * *t;
bool found = false;
for (int32_t g = 0; g < this->m_groupInfoCount; g++) {
bool hit;
if (useSphere) {
hit = this->GroupBoundingBoxIntersectsSphere(const_cast<C3Vector&>(seg.b), g, 0.0099999998f);
} else {
if (!this->m_isGroupLoaded || !(this->m_mapObjGroupArray[g]->m_unkLoadedFlag & 1)) {
continue;
}
hit = CWorldMath::VectorIntersectAABox2(this->m_groupInfo[g].m_boundingBox, const_cast<C3Vector&>(seg.b), const_cast<C3Vector&>(seg.t));
}
if (!hit || !this->m_isGroupLoaded) {
continue;
}
CMapObjGroup* group = this->m_mapObjGroupArray[g];
if (!(group->m_unkLoadedFlag & 1)) {
continue;
}
SMOPortalRef* ref = &this->m_portalRefList[group->m_portalStart];
for (int32_t i = 0; i < group->m_portalCount; i++, ref++) {
SMOPortal& portal = this->m_portalList[ref->m_portalIndex];
C3Vector point(0.0f, 0.0f, 0.0f);
float portalT;
if (!NTempest::Intersect(ray, portal.m_plane, &portalT, &point, 0.1f) || portalT < 0.0f || portalT > maxT) {
continue;
}
C3Vector::EAxis axis = portal.m_plane.n.MajorAxis();
if (!NTempest::Intersect(point, &this->m_portalVertexList[portal.m_startVertex], portal.m_count, axis)) {
continue;
}
maxT = portalT;
found = true;
float side = portal.m_plane.n.y * seg.b.y + portal.m_plane.n.z * seg.b.z + portal.m_plane.n.x * seg.b.x + portal.m_plane.d;
if ((side >= 0.0f && ref->m_side <= 0) || (side < 0.0f && ref->m_side > 0)) {
groups[0] = ref->m_groupIndex;
groups[1] = g;
} else {
groups[0] = g;
groups[1] = ref->m_groupIndex;
}
}
}
if (found) {
*t = maxT * inv;
}
return found;
}
// VERIFY: 69522e9c manual
// OFFSET: 0x007AFEE0
void CMapObj::Initialize() {
s_portalStamp = 0;
CWorldScene::s_curMapObjDef = nullptr;
s_stampedMapObjDef = nullptr;
s_portalExtCount = 2048;
s_portalVerts.Reserve(1024, 0);
s_portalVerts.m_chunk = 1024;
CMapObj::s_classicShaders[0] = CShaderEffectManager::GetEffect("MapObjDiffuse");
CMapObj::s_classicShaders[1] = CShaderEffectManager::GetEffect("MapObjSpecular");
CMapObj::s_classicShaders[2] = CShaderEffectManager::GetEffect("MapObjMetal");
CMapObj::s_classicShaders[3] = CShaderEffectManager::GetEffect("MapObjEnv");
CMapObj::s_classicShaders[4] = CShaderEffectManager::GetEffect("MapObjOpaque");
CMapObj::s_classicShaders[5] = CShaderEffectManager::GetEffect("MapObjEnvMetal");
CMapObj::s_classicShaders[6] = nullptr;
CMapObj::s_unifiedShaders[0] = CShaderEffectManager::GetEffect("MapObjUDiffuse");
CMapObj::s_unifiedShaders[1] = CShaderEffectManager::GetEffect("MapObjUSpecular");
CMapObj::s_unifiedShaders[2] = CShaderEffectManager::GetEffect("MapObjUMetal");
CMapObj::s_unifiedShaders[3] = CShaderEffectManager::GetEffect("MapObjUEnv");
CMapObj::s_unifiedShaders[4] = CShaderEffectManager::GetEffect("MapObjUOpaque");
CMapObj::s_unifiedShaders[5] = CShaderEffectManager::GetEffect("MapObjUEnvMetal");
CMapObj::s_unifiedShaders[6] = CShaderEffectManager::GetEffect("MapObjUComposite");
CMapObj::bPoolsDirty = 1;
CMapObj::occluderHeap = new (__FILE__, __LINE__) uint32_t(ObjectAllocAddHeap(sizeof(CMapObjOccluder), 128, "MAPOBJOCC", true));
}
// VERIFY: ff23c0be manual
// OFFSET: 0x007B0160
CMapObjOccluder* CMapObj::AllocOccluderNode(uint32_t* heap) {
uint32_t memHandle;
void* mem = nullptr;
if (!ObjectAlloc(*heap, &memHandle, &mem, false)) {
return nullptr;
}
CMapObjOccluder* occluder = static_cast<CMapObjOccluder*>(mem);
if (occluder) {
occluder->m_start = C3Vector(0.0f, 0.0f, 0.0f);
occluder->m_link.m_prevLink = nullptr;
occluder->m_link.m_next = nullptr;
occluder->m_end = C3Vector(0.0f, 0.0f, 0.0f);
}
occluder->m_memHandle = memHandle;
return occluder;
}
// VERIFY: 81a97e96 auto
// OFFSET: 0x007B01C0
void CMapObj::Destroy() {
CMapObj::ClearCache(1);
CMapObjGroup::Destroy();
for (uint32_t i = 0; i < sizeof(CMapObj::s_classicShaders) / sizeof(CMapObj::s_classicShaders[0]); i++) {
CMapObj::s_classicShaders[i] = nullptr;
}
for (uint32_t i = 0; i < sizeof(CMapObj::s_unifiedShaders) / sizeof(CMapObj::s_unifiedShaders[0]); i++) {
CMapObj::s_unifiedShaders[i] = nullptr;
}
CShaderEffectManager::DestroyAllEffects();
if (CMapObj::occluderHeap) {
SMemFree(CMapObj::occluderHeap, "delete", SLOG_FUNCTION, 0);
CMapObj::occluderHeap = nullptr;
}
}
// VERIFY: e6f8b5e3 manual
// OFFSET: 0x007B0040
void CMapObj::ClearCache(int32_t a1) {
CMapObj* mapObj = CMapObj::mapObjHash.m_fulllist.Head();
while (mapObj) {
CMapObj* next = CMapObj::mapObjHash.Next(mapObj);
if (!mapObj->m_refCount) {
CMapObj::mapObjHash.Unlink(mapObj);
CMap::FreeMapObj(mapObj);
}
mapObj = next;
}
}
// VERIFY: 0c534f5e manual
// OFFSET: 0x007A8800
void CMapObj::SetRenderModeLight() {
CGxLight light;
light.m_flags |= 0x1;
float d = 1.0f / sqrtf(3.0f);
light.m_dir = { d, d, d };
light.m_ambientColor = { 0.33f, 0.33f, 0.33f };
light.m_dirColor = { 0.75f, 0.75f, 0.75f };
light.m_specularColor = { 0.0f, 0.0f, 0.0f };
light.m_constantAttenuation = 0.0f;
light.m_linearAttenuation = 0.0f;
light.m_quadraticAttenuation = 0.0f;
C3Vector origin = { 0.0f, 0.0f, 0.0f };
g_theGxDevicePtr->LightSet(0, light, origin);
g_theGxDevicePtr->LightEnable(0, 1);
g_theGxDevicePtr->LightEnable(0, 1);
for (int i = 1; i < 4; i++)
g_theGxDevicePtr->LightEnable(i, 0);
GxRsSet(GxRs_Lighting, static_cast<int32_t>(1));
}
// VERIFY: 51ea4524 manual
// OFFSET: 0x007AE140
uint32_t CMapObj::CreateWmoIgnoreFlags(uint32_t a1) {
uint32_t result = 0xEE;
if ((a1 & 0x80u) != 0)
return 0x2CA;
if ((a1 & 0x10) != 0)
result = 0xC6;
if ((a1 & 0x20) != 0)
result &= 0xDBu;
if ((a1 & 0x40) == 0)
result &= ~2u;
if ((a1 & 0x4000) == 0)
result &= ~0x40u;
if ((a1 & 0x1000000) != 0) {
if ((a1 & 0x40000000) != 0)
return 0xFFFFFCDB;
else
return result | 0x100;
}
return result;
}
// VERIFY: 688ff659 manual
// OFFSET: 0x0079BBF0
void CMapObj::QueryLiquidSounds(uint32_t groupIndex, uint32_t fromGroup, uint32_t depth, uint32_t* minDepth, const C3Vector& pos, TSGrowableArray<World::LiquidQueryResult>& results) {
if (depth > CMapObj::s_unk_AEE008) {
return;
}
if (!this->GetGroupInfo(groupIndex)->m_boundingBox.ContainsPoint(pos)) {
return;
}
CMapObjGroup* group = this->GetGroup(groupIndex, 0);
if (!group) {
return;
}
if ((group->m_flags & 0x8) && depth < *minDepth) {
*minDepth = depth;
}
group->QueryLiquidSounds(pos, results);
for (uint32_t i = 0; i < static_cast<uint32_t>(group->m_portalCount); i++) {
uint32_t neighbor = this->m_portalRefList[group->m_portalStart + i].m_groupIndex;
if (neighbor != 0xFFFF && neighbor != fromGroup) {
this->QueryLiquidSounds(neighbor, groupIndex, depth + 1, minDepth, pos, results);
}
}
}
// VERIFY: 6114c894 auto
// OFFSET: 0x007A6D70
SMOMaterial* CMapObj::GetLiquidMaterial(int32_t groupIndex) {
CMapObjGroup* group = this->GetGroup(groupIndex, 0);
if (!group) {
return nullptr;
}
return &this->m_materialList[static_cast<uint16_t>(group->m_liquidMaterialId)];
}
// VERIFY: 64db3118 auto
// OFFSET: 0x007AEB90
bool CMapObj::QueryLiquidStatus(uint32_t ignoreFlags, const C3Vector& pos, int32_t* liquidType, float* level) {
for (uint32_t i = 0; i < static_cast<uint32_t>(this->m_groupInfoCount); i++) {
if (!this->m_isGroupLoaded) {
continue;
}
SMOGroupInfo* info = &this->m_groupInfo[i];
if (!info || (ignoreFlags & info->m_flags) || !info->m_boundingBox.ContainsPoint(pos)) {
continue;
}
CMapObjGroup* group = this->m_mapObjGroupArray[i];
if ((group->m_unkLoadedFlag & 0x1) && group->QueryLiquid(pos, liquidType, level)) {
return true;
}
}
return false;
}
// VERIFY: 928e1617 manual
// OFFSET: 0x007A7920
void CMapObj::BuildLiquidIndices(CMapObjGroup* group, const TSGrowableArray<uint8_t>* sharedVerts, uint16_t** indices, uint16_t baseVertex) {
int32_t rowStride = group->m_liquidVerts.x + sharedVerts[0].m_count;
uint16_t lastIndex = 0;
int32_t inStrip = 0;
uint32_t sharedRow = 0;
int32_t outRow = 0;
for (int32_t y = 0; y < group->m_liquidTiles.y; y++) {
int32_t duplicate = 0;
if (sharedRow < sharedVerts[1].m_count && sharedVerts[1].m_data[sharedRow] == y) {
duplicate = 1;
sharedRow++;
}
int32_t nextRow = baseVertex + rowStride;
for (int32_t r = duplicate + 1; r; r--) {
uint16_t top = outRow * rowStride + baseVertex;
uint16_t bottom = nextRow + top;
uint32_t sharedCol = 0;
for (int32_t x = 0; x < group->m_liquidTiles.x; x++) {
uint8_t flags = group->m_liquidTileList[group->m_liquidTiles.x * y + x].m_flags;
int32_t visible = (flags & 0xF) != 0xF && !(flags & 0x80) ? 1 : 0;
int32_t duplicateCol = 0;
if (sharedCol < sharedVerts[0].m_count && sharedVerts[0].m_data[sharedCol] == x) {
duplicateCol = 1;
sharedCol++;
}
uint16_t bottomNext = bottom + 1;
for (int32_t c = duplicateCol + 1; c; c--) {
if (visible) {
if (!inStrip) {
inStrip = 1;
*(*indices)++ = top;
*(*indices)++ = top;
*(*indices)++ = bottom;
}
*(*indices)++ = top + 1;
**indices = bottomNext;
lastIndex = bottomNext;
(*indices)++;
} else if (inStrip) {
**indices = lastIndex;
inStrip = 0;
(*indices)++;
}
top++;
bottom++;
bottomNext++;
}
}
if (inStrip) {
*(*indices)++ = lastIndex;
inStrip = 0;
}
outRow++;
}
}
}
// VERIFY: 5e3b42d7 manual
// OFFSET: 0x007A7CC0
uint16_t CMapObj::BuildLiquidVerts(CMapObjGroup* group, const C44Matrix& matrix, const CImVector* color, int32_t magma, float texCoord1U, const TSGrowableArray<uint8_t>* sharedVerts, uint32_t stride, C3Vector** position, C3Vector** normal, CImVector** vertexColor, C2Vector** texCoord0, C2Vector** texCoord1) {
float y = group->m_liquidCorner.y;
uint32_t sharedRow = 0;
for (int32_t row = 0; row < group->m_liquidVerts.y; row++) {
int32_t duplicateRow = 0;
if (sharedRow < sharedVerts[1].m_count && sharedVerts[1].m_data[sharedRow] == row) {
duplicateRow = 1;
sharedRow++;
}
for (int32_t r = duplicateRow + 1; r; r--) {
float x = group->m_liquidCorner.x;
uint32_t sharedCol = 0;
for (int32_t col = 0; col < group->m_liquidVerts.x; col++) {
const SMOLiquidVert* liquidVert = &group->m_liquidVertexList[group->m_liquidVerts.x * row + col];
C3Vector vertex;
vertex.x = x;
vertex.y = y;
vertex.z = liquidVert->m_waterVert.m_height;
int32_t duplicateCol = 0;
if (sharedCol < sharedVerts[0].m_count && sharedVerts[0].m_data[sharedCol] == col) {
duplicateCol = 1;
sharedCol++;
}
int32_t unused;
for (int32_t c = duplicateCol + 1; c; c--) {
WriteLiquidVertex(group, matrix, vertex, liquidVert, color, magma, texCoord1U, &unused, stride, position, normal, vertexColor, texCoord0, texCoord1);
}
x += 4.1666665f;
}
}
y += 4.1666665f;
}
return (group->m_liquidVerts.x + sharedVerts[0].m_count) * (sharedVerts[1].m_count + group->m_liquidVerts.y);
}
// VERIFY: 44a2f715 manual
// OFFSET: 0x007B0250
CMapObjOccluder* CMapObj::AllocOccluder() {
return CMapObj::AllocOccluderNode(CMapObj::occluderHeap);
}
// VERIFY: 13be7ec2 manual
// OFFSET: 0x007B0260
CMapObj::~CMapObj() {
this->Clear();
}
// VERIFY: 39e97d07 manual
// OFFSET: 0x007B0310
void CMapObj::FreeOccluderEntry(uint32_t* heap, CMapObjOccluder* occluder) {
occluder->m_link.Unlink();
ObjectFree(*heap, occluder->m_memHandle);
}
// VERIFY: cd8a34ce auto
// OFFSET: 0x007B0560
void CMapObj::FreeOccluder(CMapObjOccluder* occluder) {
CMapObj::FreeOccluderEntry(CMapObj::occluderHeap, occluder);
}
// VERIFY: 8e1114de manual
// OFFSET: 0x007B0580
CMapObj::CMapObj() {
this->m_mapObjGroupCount = 512;
this->Init();
}
// VERIFY: 3da651a7 auto
// OFFSET: 0x007B0CC0
CMapObj* CMapObj::Create(char* fileName) {
uint32_t hashval = SStrHash(fileName, 0, 0);
CMapObj* mapObj = CMapObj::mapObjHash.Ptr(hashval, s_mapObjHashKey);
if (mapObj) {
mapObj->m_refCount++;
return mapObj;
}
mapObj = CMap::AllocMapObj();
if (!mapObj->Read(fileName)) {
DebugLog("CMapObj::Create(): mapObj->Read(\"%s\") failed", fileName);
}
CMapObj::mapObjHash.Insert(mapObj, hashval, s_mapObjHashKey);
mapObj->m_refCount = 1;
return mapObj;
}
// VERIFY: 31d2020e auto
// OFFSET: 0x007B3A10
void CMapObjDef::CullMapObjDefGroupFromExterior(CMapObjDefGroup* mapObjDefGroup, CRect* rect, uint32_t skipOcclusion) {
CMapObj::SetGroupRenderCallback(CWorldScene::AddMapObjDefGroupToSortTable, this);
CWorldScene::s_curMapObjDef = this;
CWorldScene::FrustumPush();
CWorldScene::FrustumSet(CWorldScene::s_frustumCorners, *rect);
uint32_t groupFlags = this->m_owner->GetGroupFlags(mapObjDefGroup->m_groupNum);
if (!CWorldScene::FrustumCull(&mapObjDefGroup->m_bbox) && (skipOcclusion || !CWorldOcclusion::QueryBuffer(&mapObjDefGroup->m_bbox, 1))) {
if (groupFlags & 0x10000) {
this->m_owner->InvokeRenderCallback(mapObjDefGroup->m_groupNum);
CWorldScene::FrustumPop();
return;
}
if (groupFlags & 0x8) {
CRect ndcRect;
ndcRect.minY = rect->minY * 2.0f - 1.0f;
ndcRect.minX = rect->minX * 2.0f - 1.0f;
ndcRect.maxY = rect->maxY * 2.0f - 1.0f;
ndcRect.maxX = 2.0f * rect->maxX - 1.0f;
this->m_owner->RenderThruPortalsExterior(this->m_mat, this->m_invMat, CWorldScene::s_activeWorldView, CWorldScene::camTarget, ndcRect, mapObjDefGroup->m_groupNum);
}
}
CWorldScene::FrustumPop();
}
// VERIFY: 7164266f manual
// OFFSET: 0x007BF740
void CMapObj::CreateRefs(CMapObj* mapObj, CMapObjGroup* mapObjGroup, CMapObjDef* mapObjDef, CMapObjDefGroup* mapObjDefGroup) {
for (uint32_t i = 0; i < static_cast<uint32_t>(mapObjGroup->m_doodadRefListCount); i++) {
uint16_t doodadRef = mapObjGroup->m_doodadRefList[i];
int32_t doodadSet = mapObj->GetDoodadSet(doodadRef);
int32_t overrideSet = 0;
if (doodadSet && doodadSet != mapObjDef->m_doodadSet) {
uint32_t j = 0;
while (doodadSet != mapObjDef->m_doodadSetOverrides[j]) {
if (++j >= 3) {
break;
}
}
if (j >= 3) {
continue;
}
overrideSet = doodadSet;
if (!overrideSet) {
continue;
}
}
SMODoodadDef* doodadDef = &mapObj->m_doodadDefList[doodadRef];
CMapDoodadDef* mapDoodadDef = CMap::CreateDoodadDef(doodadRef, doodadDef, &mapObj->m_doodadNameList[doodadDef->m_flags & 0xFFFFFF], mapObjDef->m_hashval + 1, &mapObjDef->m_mat, static_cast<uint16_t>(overrideSet));
CMapBaseObjLink* link = CMap::AllocBaseObjLink(mapDoodadDef);
link->m_ref = mapObjDefGroup;
if (overrideSet) {
mapObjDefGroup->m_doodadDefLinkList.LinkToHead(link);
} else {
mapObjDefGroup->m_doodadDefLinkList.LinkToTail(link);
}
if (!(mapObjDefGroup->m_flags & 0x2) || (mapDoodadDef->m_flags & 0x4)) {
mapDoodadDef->m_diffuseLightScale = 1.0f;
mapDoodadDef->m_flags = static_cast<MapObjFlag>((mapDoodadDef->m_flags & ~0x2) | 0x4);
} else {
mapDoodadDef->m_flags = static_cast<MapObjFlag>(mapDoodadDef->m_flags | 0x2);
}
}
mapObjDefGroup->m_flags = static_cast<MapObjFlag>(mapObjDefGroup->m_flags | 0x8);
}
// VERIFY: 3943554d auto
// OFFSET: 0x007D77C0
void CMapObj::DistFromClosestExtPortal(uint32_t depth, uint32_t flags, CMapObjGroup* group, CMapObjGroup* fromGroup, const C3Vector& pos, float* dist) {
if (depth > 3) {
return;
}
for (int32_t i = 0; i < group->m_portalCount; i++) {
SMOPortalRef& ref = this->m_portalRefList[group->m_portalStart + i];
CMapObjGroup* other = this->m_mapObjGroupArray[ref.m_groupIndex];
if (!other || other == fromGroup) {
continue;
}
if (flags & this->m_groupInfo[ref.m_groupIndex].m_flags) {
SMOPortal& portal = this->m_portalList[ref.m_portalIndex];
float portalDist = NTempest::DistanceFromPolygon(pos, &this->m_portalVertexList[portal.m_startVertex], portal.m_count, portal.m_plane);
if (portalDist < 25.0f && portalDist < *dist) {
*dist = portalDist;
}
} else {
this->DistFromClosestExtPortal(depth + 1, flags, other, group, pos, dist);
}
}
}
// VERIFY: 231987cf manual
// OFFSET: 0x007D8010
float CMapObj::DistFromClosestExtPortal(CMapObjGroup* group, const C3Vector& pos, int32_t exteriorLit) {
uint32_t flags = exteriorLit ? 0x48 : 0x8;
float dist = 3.4028235e38f;
this->DistFromClosestExtPortal(0, flags, group, nullptr, pos, &dist);
return dist;
}
// VERIFY: 484c8c47 manual
// OFFSET: 0x007AEF00
bool CMapObj::GetTris(const CAaBox& box, uint32_t flags, World::TriData* triData, CMapObjDef* mapObjDef) {
bool result = false;
uint16_t ignoreFlags = static_cast<uint16_t>(CMapObj::CreateWmoIgnoreFlags(flags));
for (int32_t i = 0; i < this->m_groupInfoCount; i++) {
const CAaBox& bounds = this->m_groupInfo[i].m_boundingBox;
if (box.t.x < bounds.b.x || box.t.y < bounds.b.y || box.t.z < bounds.b.z || box.b.x > bounds.t.x || box.b.y > bounds.t.y || box.b.z > bounds.t.z) {
continue;
}
if (!this->m_isGroupLoaded) {
continue;
}
CMapObjGroup* group = this->m_mapObjGroupArray[i];
if ((group->m_unkLoadedFlag & 1) && !(group->m_flags & 0x80)) {
result |= group->GetTris(box, flags, ignoreFlags, triData, mapObjDef);
}
}
return result;
}
// VERIFY: d1ce1d3d manual
// OFFSET: 0x007AF000
bool CMapObj::GetLiquidFacets(const CAaBox& box, uint32_t flags, World::FacetData* facets, CMapObjDef* mapObjDef) {
bool result = false;
for (int32_t i = 0; i < this->m_groupInfoCount; i++) {
const CAaBox& bounds = this->m_groupInfo[i].m_boundingBox;
if (box.t.x < bounds.b.x || box.t.y < bounds.b.y || box.t.z < bounds.b.z || box.b.x > bounds.t.x || box.b.y > bounds.t.y || box.b.z > bounds.t.z) {
continue;
}
if (!this->m_isGroupLoaded) {
continue;
}
CMapObjGroup* group = this->m_mapObjGroupArray[i];
if ((group->m_unkLoadedFlag & 1) && !(group->m_flags & 0x400080)) {
result |= group->GetLiquidFacets(box, flags, facets, mapObjDef);
}
}
return result;
}
// VERIFY: d6cd6b2c auto
// OFFSET: 0x007AE920
bool CMapObj::TestGroupBounds(const C3Vector& point, uint32_t groupNum) {
return this->m_isGroupLoaded && (this->m_mapObjGroupArray[groupNum]->m_unkLoadedFlag & 1) && this->m_groupInfo[groupNum].m_boundingBox.ContainsPoint(point);
}
// VERIFY: 15693e65 auto
// OFFSET: 0x007AF200
bool CMapObj::Intersect(C3Vector& start, C3Vector& end, float* distance, uint32_t flags, uint32_t ignoreFlags, uint32_t groupNum, int32_t* hitIndex) {
if (!this->m_isGroupLoaded) {
return false;
}
CMapObjGroup* group = this->m_mapObjGroupArray[groupNum];
if (!(group->m_unkLoadedFlag & 1)) {
return false;
}
C3Segment seg;
seg.b = start;
seg.t = end;
return group->Intersect(seg, distance, flags, static_cast<uint16_t>(ignoreFlags), hitIndex);
}
// VERIFY: d090e248 manual
// OFFSET: 0x007AE8D0
bool CMapObj::TestGroupBounds(CAaBox& box, uint32_t groupNum, int32_t a3) {
return (!a3 || (this->m_isGroupLoaded && (this->m_mapObjGroupArray[groupNum]->m_unkLoadedFlag & 1))) && this->m_groupInfo[groupNum].m_boundingBox.Intersects(box);
}
// VERIFY: aacb9f67 manual
// OFFSET: 0x007AEB40
bool CMapObj::QueryLighting(uint32_t groupNum, const C3Vector& point, uint16_t face, CImVector* color, uint8_t* flag) {
if (!this->m_isGroupLoaded) {
return false;
}
CMapObjGroup* group = this->m_mapObjGroupArray[groupNum];
if (!(group->m_unkLoadedFlag & 1) || (group->m_flags & 0x48)) {
return false;
}
return group->QueryLighting(point, face, color, flag);
}
// VERIFY: 155a20aa manual
// OFFSET: 0x007AF780
bool CMapObj::QueryLighting(uint32_t groupNum, const C3Segment& seg, CImVector* color, uint8_t* flag) {
float dist = 1.0f;
if (!this->m_isGroupLoaded) {
return false;
}
CMapObjGroup* group = this->m_mapObjGroupArray[groupNum];
if (!(group->m_unkLoadedFlag & 1) || (group->m_flags & 0x48)) {
return false;
}
World::TriData triData;
World::TriData::statusFlags = 0;
World::TriData::nBatches = 0;
World::TriData::faceIndexCursor = 0;
World::TriData::indexCursor = 0;
World::TriData::unk_CB7538 = 0;
if (!group->GetTris(seg, &dist, 0, 8, &triData, nullptr)) {
return false;
}
C3Vector point = C3Vector((seg.t.x - seg.b.x) * dist + seg.b.x, (seg.t.y - seg.b.y) * dist + seg.b.y, (seg.t.z - seg.b.z) * dist + seg.b.z);
return group->QueryLighting(point, World::TriData::batches[0].m_faceIndices[0], color, flag);
}
// VERIFY: dd3ad3a2 manual
// OFFSET: 0x007AF0F0
bool CMapObj::GetTris(const CWFrustum& frustum, uint32_t flags, World::TriData* triData, CMapObjDef* mapObjDef) {
bool result = false;
uint16_t ignoreFlags = static_cast<uint16_t>(CMapObj::CreateWmoIgnoreFlags(flags));
CAaBox box = CAaBox::Bounding(frustum.corners, 8);
for (uint32_t i = 0; i < static_cast<uint32_t>(this->m_groupInfoCount); i++) {
const CAaBox& bounds = this->m_groupInfo[i].m_boundingBox;
if (box.t.x < bounds.b.x || box.t.y < bounds.b.y || box.t.z < bounds.b.z || box.b.x > bounds.t.x || box.b.y > bounds.t.y || box.b.z > bounds.t.z) {
continue;
}
if (!this->m_isGroupLoaded) {
continue;
}
CMapObjGroup* group = this->m_mapObjGroupArray[i];
if ((group->m_unkLoadedFlag & 1) && !(group->m_flags & 0x80)) {
result |= group->GetTris(frustum, flags, ignoreFlags, triData, mapObjDef);
}
}
return result;
}
// STATIC: 0x00D1C418
uint32_t CMapObj::sMinimapTag;
// STATIC: 0x00AEE00C
static float s_minimapTexelSize = 0.5f;
// STATIC: 0x00D1C47C
static float s_minimapQuadSize = s_minimapTexelSize * 256.0f;
// VERIFY: 75e1421c manual
// OFFSET: 0x007AE1F0
static uint32_t ComputeAaBoxOutcodeExact(const C3Vector* point, const CAaBox* box) {
float delta[6];
delta[0] = point->x - box->b.x;
delta[1] = point->y - box->b.y;
delta[2] = point->z - box->b.z;
delta[3] = box->t.x - point->x;
delta[4] = box->t.y - point->y;
delta[5] = box->t.z - point->z;
uint32_t bits[6];
memcpy(bits, delta, sizeof(bits));
return (bits[0] >> 31) | ((bits[1] >> 30) & 2) | ((bits[2] >> 29) & 4) | ((bits[3] >> 28) & 8) | ((bits[4] >> 27) & 0x10) | ((bits[5] >> 26) & 0x20);
}
// VERIFY: c28f57e3 manual
// OFFSET: 0x007AF8D0
static void GetMinimapQuads(const CAaBox* bounds, const CAaBox* box, int32_t groupId, TSStackArray<MINIMAPQUADINFO>* quads, uint32_t maxQuads) {
float centerZ = (bounds->t.z + bounds->b.z) * 0.5f;
float inv = 1.0f / s_minimapQuadSize;
float sizeX = (bounds->t.x - bounds->b.x) * inv;
float sizeY = inv * (bounds->t.y - bounds->b.y);
float invLog2 = 1.0f / std::log10(2.0f);
float exponentY = invLog2 * std::log10(sizeY * 256.0f);
uint32_t texelsY;
if ((1u << static_cast<int32_t>(std::ceil(exponentY))) < 256 && (1u << static_cast<int32_t>(std::ceil(exponentY))) < 32) {
texelsY = 32;
} else if ((1u << static_cast<int32_t>(std::ceil(exponentY))) < 256) {
texelsY = 1u << static_cast<int32_t>(std::ceil(exponentY));
} else {
texelsY = 256;
}
float exponentX = std::log10(sizeX * 256.0f) * invLog2;
uint32_t texelsX;
if ((1u << static_cast<int32_t>(std::ceil(exponentX))) < 256 && (1u << static_cast<int32_t>(std::ceil(exponentX))) < 32) {
texelsX = 32;
} else if ((1u << static_cast<int32_t>(std::ceil(exponentX))) < 256) {
texelsX = 1u << static_cast<int32_t>(std::ceil(exponentX));
} else {
texelsX = 256;
}
int32_t countY = static_cast<int32_t>(std::ceil(sizeY));
int32_t countX = static_cast<int32_t>(std::ceil(sizeX));
float stepX = texelsX * s_minimapTexelSize;
float stepY = texelsY * s_minimapTexelSize;
for (int32_t y = 0; y < countY; y++) {
for (int32_t x = 0; x < countX; x++) {
float minX = x * stepX + bounds->b.x;
float minY = y * stepY + bounds->b.y;
float maxX = minX + stepX;
float maxY = minY + stepY;
static float s_border = s_minimapTexelSize + s_minimapTexelSize;
if (!x) {
minX = minX - s_border;
}
if (!y) {
minY = minY - s_border;
}
if (x == countX - 1) {
maxX = maxX + s_border;
}
if (y == countY - 1) {
maxY = maxY + s_border;
}
if (maxX >= box->b.x && maxY >= box->b.y && minX <= box->t.x && minY <= box->t.y && quads->m_count < maxQuads) {
MINIMAPQUADINFO* quad = new (&quads->m_data[quads->m_count++]) MINIMAPQUADINFO();
quad->m_groupId = groupId;
quad->m_y = y;
quad->m_bounds.b = C3Vector(minX, minY, centerZ);
quad->m_bounds.t = C3Vector(maxX, maxY, centerZ);
quad->m_x = x;
}
}
}
}
// VERIFY: eae22eb6 auto
// OFFSET: 0x007AFE70
void CMapObj::GetMinimapQuads(CAaBox* box, TSStackArray<MINIMAPQUADINFO>* quads, uint32_t maxQuads) {
CAaBox bounds = this->m_bbox;
::GetMinimapQuads(&bounds, box, this->m_groupInfoCount, quads, maxQuads);
}
// VERIFY: 905ed32b manual
// OFFSET: 0x007AFC70
void CMapObj::QueryMapObjMinimapGroup(int32_t groupNum, int32_t fromGroup, CAaBox* box, TSStackArray<MINIMAPQUADINFO>* quads, uint32_t maxQuads, int32_t inside, uint32_t flagsMask, uint32_t depth) {
if (!this->m_isGroupLoaded) {
return;
}
CMapObjGroup* group = this->m_mapObjGroupArray[groupNum];
if (!(group->m_unkLoadedFlag & 1)) {
return;
}
if ((inside ? (group->m_flags & 0x48) : (group->m_flags & 0x8)) != flagsMask || group->m_minimapTag == static_cast<int32_t>(CMapObj::sMinimapTag)) {
return;
}
group->m_minimapTag = CMapObj::sMinimapTag;
if (!group->m_bbox.IntersectsXY(*box)) {
return;
}
::GetMinimapQuads(&group->m_bbox, box, groupNum, quads, maxQuads);
int32_t wmoGroupId = group->m_wmoGroupId;
if (wmoGroupId == 23015 || wmoGroupId == 23016 || !group->m_portalCount || !g_minimapPortalMaxCVar || depth >= static_cast<uint32_t>(g_minimapPortalMaxCVar->m_intValue)) {
return;
}
for (int32_t i = 0; i < group->m_portalCount; i++) {
SMOPortalRef* portalRef = &this->m_portalRefList[group->m_portalStart + i];
uint32_t target = portalRef->m_groupIndex;
if (target == 0xFFFF || target == static_cast<uint32_t>(fromGroup) || (this->GetGroupFlags(target) & 0x80)) {
continue;
}
SMOPortal* portal = &this->m_portalList[portalRef->m_portalIndex];
if (!portal->m_count) {
continue;
}
uint32_t outcode = 0xFFFFFFFF;
C3Vector* vertex = &this->m_portalVertexList[portal->m_startVertex];
for (uint32_t j = 0; j < portal->m_count; j++) {
outcode &= ComputeAaBoxOutcodeExact(vertex, box);
vertex++;
}
if (outcode) {
continue;
}
CMapObjGroup* targetGroup;
if (!this->m_isGroupLoaded || !((targetGroup = this->m_mapObjGroupArray[target])->m_unkLoadedFlag & 1) || (targetGroup->m_wmoGroupId != 23015 && targetGroup->m_wmoGroupId != 23016)) {
this->QueryMapObjMinimapGroup(target, groupNum, box, quads, maxQuads, inside, flagsMask, ++depth);
}
}
}
// VERIFY: ddad8ead auto
// OFFSET: 0x007B00A0
bool CMapObj::QueryMapObjMinimap(int32_t groupNum, CAaBox* box, TSStackArray<MINIMAPQUADINFO>* quads, uint32_t maxQuads, int32_t inside, uint8_t indoorArea) {
CMapObj::sMinimapTag++;
if (!this->m_isGroupLoaded) {
return false;
}
CAaBox query = *box;
CMapObjGroup* group = this->m_mapObjGroupArray[groupNum];
if (!(group->m_unkLoadedFlag & 1)) {
return false;
}
query.t.z = group->m_bbox.t.z;
if (indoorArea) {
this->GetMinimapQuads(&query, quads, maxQuads);
return true;
}
uint32_t flagsMask = inside ? (this->m_groupInfo[groupNum].m_flags & 0x40) : 8;
this->QueryMapObjMinimapGroup(groupNum, groupNum, &query, quads, maxQuads, inside, flagsMask, 0);
return true;
}