#include "MapObjRead.h" #include "Engine/Source/Tempest/NTempest.h" #include "Engine/Source/Tempest/C3Ray.h" #include "WoW/Common/AaBsp.h" #include "Engine/Source/Storm/H/storm.h" #include "Engine/Source/ShaderEffect/ShaderEffect.h" #include #include "WoW/Source/WorldClient/Types.h" #include "WoW/Source/WorldClient/DayNight.h" #include "Engine/Source/Services/AsyncFile.h" #include "Engine/Source/BlizzardCore/SFile2-Core.h" #include "WoW/Source/WorldClient/Map.h" #include "WoW/Source/WorldClient/MapObj.h" #include "WoW/Source/WorldClient/MapObjGroup.h" // STATIC: 0x00ADFC4C TSList > CMapObj::s_asyncLoadQueue = TSExplicitList(); // STATIC: 0x00ADFC58 TSList > CMapObj::s_loadedGroups = TSExplicitList(); // VERIFY: 477d94a9 manual // OFFSET: 0x007D72D0 void CMapObj::CreateMaterials() { for (uint32_t i = 0; i < static_cast(this->m_materialsCount); i++) { this->m_materialList[i].Textures()[0] = nullptr; this->m_materialList[i].Textures()[1] = nullptr; } } // VERIFY: 12bdf795 manual // OFFSET: 0x007D7380 void CMapObjGroup::FixColorVertexAlpha() { uint32_t firstExterior = this->m_transparencyBatchesCount ? this->m_batchList[this->m_transparencyBatchesCount - 1].m_vertexEnd + 1 : 0; for (uint32_t i = 0; i < static_cast(this->m_colorVertexListSize); i++) { CImVector& color = this->m_colorVertexList[i]; if (i >= firstExterior) { uint32_t alpha = color.a; uint32_t r = (color.r + ((alpha * color.r) >> 6)) >> 1; uint32_t g = (color.g + ((alpha * color.g) >> 6)) >> 1; uint32_t b = (color.b + ((alpha * color.b) >> 6)) >> 1; color.r = r > 0xFF ? 0xFF : r; color.g = g > 0xFF ? 0xFF : g; color.b = b > 0xFF ? 0xFF : b; color.a = 0xFF; } else { color.r >>= 1; color.g >>= 1; color.b >>= 1; } } } // VERIFY: cd3ffadf manual // OFFSET: 0x007D7470 void CMapObj::Load() { SIffChunk* chunk = reinterpret_cast(static_cast(this->m_pWmoData) + 12); this->m_header = reinterpret_cast(&chunk->m_data); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_textureNameList = reinterpret_cast(&chunk->m_data); this->m_texturesSize = chunk->m_size; chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_materialList = reinterpret_cast(&chunk->m_data); this->m_materialsCount = chunk->m_size / sizeof(SMOMaterial); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_groupNameList = reinterpret_cast(&chunk->m_data); this->m_groupNameSize = chunk->m_size; chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_groupInfo = reinterpret_cast(&chunk->m_data); this->m_groupInfoCount = chunk->m_size / sizeof(SMOGroupInfo); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_skybox = reinterpret_cast(&chunk->m_data); if (!this->m_skybox[0]) { this->m_skybox = nullptr; } chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); if (!this->m_skybox) { for (uint32_t i = 0; i < static_cast(this->m_groupInfoCount); i++) { this->m_groupInfo[i].m_flags &= ~0x40000; } } this->m_portalVertexList = reinterpret_cast(&chunk->m_data); this->m_planeVertCount = chunk->m_size / sizeof(C3Vector); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_portalList = reinterpret_cast(&chunk->m_data); this->m_portalsCount = chunk->m_size / sizeof(SMOPortal); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); for (int32_t i = 0; i < this->m_portalsCount; i++) { if (std::isnan(static_cast(this->m_portalList[i].m_plane.d))) { this->m_portalList[i].m_plane.n.x = 0.0f; this->m_portalList[i].m_plane.n.y = 0.0f; this->m_portalList[i].m_plane.n.z = 1.0f; this->m_portalList[i].m_plane.d = 800000.0f; } } this->m_portalRefList = reinterpret_cast(&chunk->m_data); this->m_portalRefCount = chunk->m_size / sizeof(SMOPortalRef); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_visBlockVertList = reinterpret_cast(&chunk->m_data); this->m_visBlockVertCount = chunk->m_size / sizeof(C3Vector); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_visBlockList = reinterpret_cast(&chunk->m_data); this->m_visBlockCount = chunk->m_size / sizeof(SMOVisibleBlock); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_lightList = reinterpret_cast(&chunk->m_data); this->m_ligtsCount = chunk->m_size / sizeof(SMOLight); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_doodadSetList = reinterpret_cast(&chunk->m_data); this->m_doodadSetCount = chunk->m_size / sizeof(SMODoodadSet); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_doodadNameList = reinterpret_cast(&chunk->m_data); this->m_doodadNameSize = chunk->m_size; chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_doodadDefList = reinterpret_cast(&chunk->m_data); this->m_doodadDefCount = chunk->m_size / sizeof(SMODoodadDef); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_fogList = reinterpret_cast(&chunk->m_data); this->m_fogsCount = chunk->m_size / sizeof(SMOFog); uint8_t* end = static_cast(this->m_pWmoData) + this->m_wmoFileSize; chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); if (reinterpret_cast(chunk) < end && chunk->m_token == 0x4D435650) { this->m_convexVolumePlanes = reinterpret_cast(&chunk->m_data); this->m_convexVolumePlaneCount = chunk->m_size / sizeof(C4Plane); } } // VERIFY: 4e3ee2fd auto // OFFSET: 0x007D7710 void CMapObj::CreateMaterial(uint8_t texture) { SMOMaterial& material = this->m_materialList[texture]; if (material.Textures()[0]) { return; } const char* texture1 = &this->m_textureNameList[material.m_texture1]; const char* texture2 = &this->m_textureNameList[material.m_texture2]; if (!*texture1) { texture1 = "createcrappygreentexture.blp"; } if (!CShaderEffect::s_enableShaders) { texture2 = ""; } switch (material.m_shader) { case 3: case 5: case 6: if (*texture2) { break; } material.m_shader = 4; texture2 = nullptr; break; case 0: case 1: case 2: case 4: texture2 = nullptr; break; default: break; } material.Textures()[0] = CMap::LoadTexture(texture1); if (texture2) { material.Textures()[1] = CMap::LoadTexture(texture2); } else { material.Textures()[1] = nullptr; } } // VERIFY: 03cc8920 manual // OFFSET: 0x007D78C0 CMapObjGroup* CMapObj::AttenTransVerts(CMapObjGroup* group) { group->m_unkLoadedFlag |= 0x2; if (!group->m_transparencyBatchesCount) { return group; } uint32_t vertexEnd = group->m_batchList[group->m_transparencyBatchesCount - 1].m_vertexEnd; for (uint32_t i = 0; i <= vertexEnd; i++) { C3Vector& vert = group->m_vertexList[i]; CImVector& color = group->m_colorVertexList[i]; float atten = 0.0f; if (group->m_portalCount) { uint32_t p; for (p = 0; p < static_cast(group->m_portalCount); p++) { SMOPortalRef& ref = this->m_portalRefList[p + group->m_portalStart]; SMOPortal& portal = this->m_portalList[ref.m_portalIndex]; C3Vector onPlane = vert; float side = portal.m_plane.n.z * vert.z + portal.m_plane.n.y * vert.y + portal.m_plane.n.x * vert.x + portal.m_plane.d; if (side > 0.001f) { C3Vector end(vert.x - portal.m_plane.n.x, vert.y - portal.m_plane.n.y, vert.z - portal.m_plane.n.z); NTempest::Intersect(C3Ray::FromStartEnd(vert, end, false), portal.m_plane, nullptr, &onPlane, 0.01f); } else if (side < -0.001f) { C3Vector end(portal.m_plane.n.x + vert.x, portal.m_plane.n.y + vert.y, portal.m_plane.n.z + vert.z); NTempest::Intersect(C3Ray::FromStartEnd(vert, end, false), portal.m_plane, nullptr, &onPlane, 0.01f); } C3Vector* portalVerts = &this->m_portalVertexList[portal.m_startVertex]; float dist; if (NTempest::Intersect(onPlane, portalVerts, portal.m_count, portal.m_plane.n.MajorAxis())) { dist = portal.m_plane.n.z * vert.z + portal.m_plane.n.y * vert.y + portal.m_plane.n.x * vert.x + portal.m_plane.d; if (ref.m_side != 1) { dist = dist * -1.0f; } } else { dist = NTempest::DistanceFromPolygonEdge(vert, portalVerts, portal.m_count); } if (this->m_groupInfo[ref.m_groupIndex].m_flags & 0x48) { if (dist < 0.0f) { dist = 0.0f; } float weight = 1.0f - dist * 0.15f; if (weight > 0.001f) { atten = weight + atten; } } else if (dist > -1.0f && dist < 1.0f) { atten = 0.0f; break; } } if (p == static_cast(group->m_portalCount)) { if (atten <= 0.001f) { atten = 0.0f; } else if (atten > 1.0f) { atten = 1.0f; } } } color.r = static_cast(atten * (127.0f - color.r) + color.r); color.g = static_cast(color.g + (127.0f - color.g) * atten); color.b = static_cast(color.b + (127.0f - color.b) * atten); color.a = static_cast(atten * 255.0f); } return group; } // VERIFY: 5789fe57 manual // OFFSET: 0x007D7C30 void CMapObjGroup::CreateOptionalDataPointers(SIffChunk* dataChunk) { SIffChunk* chunk = dataChunk; uint32_t flags = this->m_flags; if (flags & 0x200) { this->m_lightRefList = reinterpret_cast(&chunk->m_data); this->m_lightRefListCount = chunk->m_size >> 1; chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); } if (flags & 0x800) { this->m_doodadRefList = reinterpret_cast(&chunk->m_data); this->m_doodadRefListCount = chunk->m_size >> 1; chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); } if (flags & 0x1) { uint32_t nodeSize = chunk->m_size; CAaBspNode* nodes = reinterpret_cast(&chunk->m_data); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + nodeSize); uint32_t faceSize = chunk->m_size; uint16_t* faces = reinterpret_cast(&chunk->m_data); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + faceSize); this->m_cAaBspNodePtr1.Set(nodes, nodeSize >> 4, faces, faceSize >> 1, this->m_bbox); } if (this->m_flags & 0x400) { for (uint32_t i = 0; i < 4; i++) { chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); } } if (this->m_flags & 0x4) { CMapObj* parent = this->m_parent; this->m_colorVertexList = reinterpret_cast(&chunk->m_data); this->m_colorVertexListSize = chunk->m_size >> 2; chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); if (!(parent->m_header->m_flags & 0x8)) { this->FixColorVertexAlpha(); } } if (this->m_flags & 0x1000) { uint32_t* header = reinterpret_cast(&chunk->m_data); this->m_liquidVerts.x = header[0]; this->m_liquidVerts.y = header[1]; this->m_liquidTiles.x = header[2]; this->m_liquidTiles.y = header[3]; this->m_liquidCorner = *reinterpret_cast(&header[4]); uint16_t materialId = *reinterpret_cast(&header[7]); uint8_t* data = reinterpret_cast(&header[7]) + 2; this->m_liquidVertexList = reinterpret_cast(data); data += 8 * this->m_liquidVerts.x * this->m_liquidVerts.y; this->m_liquidTileList = reinterpret_cast(data); data += this->m_liquidTiles.x * this->m_liquidTiles.y; chunk = reinterpret_cast(data); this->m_liquidMaterialId = materialId; if (!this->m_liquidType) { this->m_liquidType = this->GetLiquidType(this->FindLiquidType()); } CMapObjGroup::AllocVertArray(&this->m_liquidVertArray, this->m_liquidVerts.x * this->m_liquidVerts.y); this->GenLiquidVerts(); } if (this->m_flags & 0x20000) { this->m_stripIndices = reinterpret_cast(&chunk->m_data); this->m_stripIndexCount = chunk->m_size >> 1; chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size + 8); this->m_stripBatches = reinterpret_cast(chunk); if (CMap::s_enableTriangleStrips) { for (uint32_t i = 0; i < static_cast(this->m_batchListCount); i++) { this->m_batchList[i].m_indexStart = *reinterpret_cast(&this->m_stripBatches[8 * i]); this->m_batchList[i].m_indexCount = *reinterpret_cast(&this->m_stripBatches[8 * i + 4]); } } } flags = this->m_flags; if (flags & 0x2000000) { this->m_textureVertexList2 = reinterpret_cast(&chunk->m_data); this->m_textureVertexList2Count = chunk->m_size >> 3; chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); } if (flags & 0x1000000) { this->m_colorVertexListExtra = reinterpret_cast(&chunk->m_data); this->m_colorVertexListExtraSize = chunk->m_size >> 2; } } // VERIFY: 182a9a50 manual // OFFSET: 0x007D7F50 void CMapObjGroup::CreateDataPointers(SIffChunk* dataChunk) { SIffChunk* chunk = dataChunk; this->m_polyList = reinterpret_cast(&chunk->m_data); this->m_polyListSize = chunk->m_size >> 1; chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_indices = reinterpret_cast(&chunk->m_data); this->m_indicesCount = chunk->m_size >> 1; chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_vertexList = reinterpret_cast(&chunk->m_data); this->m_vertexListCount = chunk->m_size / sizeof(C3Vector); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_normalList = reinterpret_cast(&chunk->m_data); this->m_normalListCount = chunk->m_size / sizeof(C3Vector); chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_textureVertexList = reinterpret_cast(&chunk->m_data); this->m_textureVertexListCount = chunk->m_size >> 3; chunk = reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size); this->m_batchList = reinterpret_cast(&chunk->m_data); this->m_batchListCount = chunk->m_size / sizeof(SMOBatch); this->CreateOptionalDataPointers(reinterpret_cast(reinterpret_cast(&chunk->m_data) + chunk->m_size)); } // VERIFY: aea1ef5e manual // OFFSET: 0x007D8050 void CMapObj::PostloadCallback(void* arg) { CMapObj* mapObj = static_cast(arg); AsyncFileReadDestroyObject(mapObj->m_asyncObject); mapObj->m_asyncObject = nullptr; mapObj->m_asyncLoadLink.Unlink(); mapObj->Load(); mapObj->CreateMaterials(); mapObj->m_argbColor = *reinterpret_cast(&mapObj->m_header->m_ambColor); mapObj->m_bbox = mapObj->m_header->m_boundingBox; mapObj->m_mapObjGroupCount = mapObj->m_groupInfoCount; for (uint32_t i = 0; i < static_cast(mapObj->m_groupInfoCount); i++) { mapObj->m_mapObjGroupArray[i] = CMap::AllocMapObjGroup(); } mapObj->m_isGroupLoaded = 1; } // VERIFY: 737e6a62 manual // OFFSET: 0x007D80C0 bool CMapObj::Read(char* fileName) { SStrCopy(this->m_wmoName, fileName, STORM_MAX_STR); SFileImpl* file = nullptr; if (CMap::SafeOpen(fileName, &file)) { SStrCopy(this->m_wmoName, fileName, STORM_MAX_STR); } else { CMap::SafeOpen("world\\wmo\\Dungeon\\test\\missingwmo.wmo", &file); SStrCopy(this->m_wmoName, "world\\wmo\\Dungeon\\test\\missingwmo.wmo", STORM_MAX_STR); } this->m_wmoFileSize = SFileGetFileSize(file, nullptr); this->m_pWmoData = SMemAlloc(this->m_wmoFileSize, __FILE__, __LINE__, 0); this->m_asyncObject = AsyncFileReadAllocObject(); this->m_asyncObject->m_file = file; this->m_asyncObject->m_userArg = this; this->m_asyncObject->m_buffer = this->m_pWmoData; this->m_asyncObject->m_size = this->m_wmoFileSize; this->m_asyncObject->m_userPostloadCallback = reinterpret_cast(CMapObj::PostloadCallback); this->m_asyncObject->m_priority = 124; AsyncFileReadObject(this->m_asyncObject, 0); CMapObj::s_asyncLoadQueue.LinkToTail(this); return true; } // VERIFY: a3a005c2 manual // OFFSET: 0x007D81C0 void CMapObjGroup::HandleAntiportal() { for (uint32_t i = 0; i < static_cast(this->m_polyListSize); i++) { C3Vector* verts[3]; verts[0] = &this->m_vertexList[this->m_indices[3 * i]]; verts[1] = &this->m_vertexList[this->m_indices[3 * i + 1]]; verts[2] = &this->m_vertexList[this->m_indices[3 * i + 2]]; float height = (verts[1]->z + verts[2]->z + verts[0]->z) * 0.33333334f; uint32_t above[3]; uint32_t count = 0; if (height < verts[0]->z) { above[count++] = 0; } if (height < verts[1]->z) { above[count++] = 1; } if (height < verts[2]->z) { above[count++] = 2; } if (count >= 2) { CMapObjOccluder* occluder = CMapObj::AllocOccluder(); occluder->m_start = *verts[above[0]]; occluder->m_end = *verts[above[1]]; this->m_occluderList.LinkToTail(occluder); } } this->m_extBatchCount = 0; this->m_intBatchCount = 0; } // VERIFY: 579978be manual // OFFSET: 0x007D82E0 void CMapObjGroup::Create() { SMOGroupHeader* header = reinterpret_cast(static_cast(this->m_filePtr) + 20); this->m_parent->m_mapObjGroupList.LinkToTail(this); CMapObj* parent = this->m_parent; this->m_groupName = &parent->m_groupNameList[header->m_groupName]; this->m_flags = header->m_flags; if (!parent->m_skybox) { this->m_flags &= ~0x40000; } this->m_bbox = header->m_boundingBox; this->m_portalStart = header->m_portalStart; this->m_portalCount = header->m_portalCount; this->m_transparencyBatchesCount = header->m_transBatchCount; this->m_intBatchCount = header->m_intBatchCount; this->m_extBatchCount = header->m_extBatchCount; memcpy(this->m_fogs, header->m_fogIds, sizeof(this->m_fogs)); this->m_wmoGroupId = header->m_uniqueID; if (parent->m_header->m_flags & 0x4) { this->m_liquidType = this->GetLiquidType(header->m_groupLiquid); } else { this->m_liquidType = this->GetLiquidType(header->m_groupLiquid == 15 ? 0 : header->m_groupLiquid + 1); } this->CreateDataPointers(reinterpret_cast(header + 1)); CMapObj* mapObj = this->m_parent; for (uint32_t i = 0; i < static_cast(this->m_batchListCount); i++) { mapObj->CreateMaterial(this->m_batchList[i].m_texture); } this->m_unkLoadedFlag = (this->m_unkLoadedFlag & ~0x2) | 0x1; if (mapObj->m_header->m_flags & 0x1) { this->m_unkLoadedFlag |= 0x2; } if (!SStrCmp(this->m_groupName, "antiportal", STORM_MAX_STR)) { this->HandleAntiportal(); } this->m_unkLoadedFlag |= 0x4; uint32_t batchCount = this->m_batchListCount; if (!batchCount) { return; } this->m_indexMin = 0xFFFFFFFF; this->m_indexMax = 0; this->m_vertexMin = 0xFFFF; this->m_vertexMax = 0; for (uint32_t i = 0; i < batchCount; i++) { SMOBatch& batch = this->m_batchList[i]; if (mapObj->m_materialList[batch.m_texture].m_blendMode) { this->m_unkLoadedFlag &= ~0x4; break; } uint32_t indexEnd = batch.m_indexCount + batch.m_indexStart - 1; if (this->m_vertexMax < batch.m_vertexEnd) { this->m_vertexMax = batch.m_vertexEnd; } if (this->m_vertexMin > batch.m_vertexStart) { this->m_vertexMin = batch.m_vertexStart; } if (this->m_indexMin > batch.m_indexStart) { this->m_indexMin = batch.m_indexStart; } if (this->m_indexMax < indexEnd) { this->m_indexMax = indexEnd; } } for (uint32_t i = 0; i < batchCount; i++) { if (mapObj->m_materialList[this->m_batchList[i].m_texture].m_shader == 6) { this->m_unkLoadedFlag |= 0x8; return; } } } // VERIFY: 2026a068 auto // OFFSET: 0x007D8570 void CMapObjGroup::AsyncPostloadCallback(void* arg) { CMapObjGroup* group = static_cast(arg); AsyncFileReadDestroyObject(group->m_asyncObjPtr); group->m_asyncObjPtr = nullptr; group->m_asyncLoadLink.Unlink(); group->Create(); } // VERIFY: 1fdd96d9 manual // OFFSET: 0x007D85E0 void CMapObj::ReadGroup(uint32_t index, bool preLoad) { CMapObjGroup* group = this->m_mapObjGroupArray[index]; char fileName[256]; strcpy(fileName, this->m_wmoName); SStrPrintf(strrchr(fileName, '.'), sizeof(fileName), "_%03d", index); strcat(fileName, ".wmo"); SFileImpl* file = nullptr; CMap::SafeOpen(fileName, &file); group->m_fileSize = SFileGetFileSize(file, nullptr); group->m_filePtr = SMemAlloc(group->m_fileSize, __FILE__, __LINE__, 0); group->m_parent = this; if (preLoad) { CMap::SafeRead(fileName, file, group->m_filePtr, group->m_fileSize); group->Create(); SFileCloseFile(file); return; } CAsyncObject* object = AsyncFileReadAllocObject(); object->m_file = file; object->m_buffer = group->m_filePtr; object->m_size = group->m_fileSize; object->m_userArg = group; object->m_userPostloadCallback = reinterpret_cast(CMapObjGroup::AsyncPostloadCallback); group->m_asyncObjPtr = object; AsyncFileReadObject(object, 0); CMapObj::s_loadedGroups.LinkToTail(group); }