DynamicMMapTileBuilder.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "DynamicMMapTileBuilder.h"
#include "Containers.h"
#include "DB2Stores.h"
#include "DeadlineTimer.h"
#include "GameObjectModel.h"
#include "GameTime.h"
#include "Hash.h"
#include "IoContext.h"
#include "Log.h"
#include "MMapDefines.h"
#include "MMapManager.h"
#include "Map.h"
#include "VMapFactory.h"
#include "VMapManager.h"
#include "World.h"
#include "advstd.h"
#include <thread>
 
namespace
{
struct TileCacheKeyObject
{
    uint32 DisplayId;
    int16 Scale;
    std::array<int16, 3> Position;
    int64 Rotation;
 
    friend std::strong_ordering operator<=>(TileCacheKeyObject const&, TileCacheKeyObject const&) = default;
    friend bool operator==(TileCacheKeyObject const&, TileCacheKeyObject const&) = default;
};
 
struct TileCacheKey
{
    uint32 TerrainMapId;
    uint32 X;
    uint32 Y;
    std::size_t CachedHash; // computing the hash is expensive - store it
    std::vector<TileCacheKeyObject> Objects;
 
    friend bool operator==(TileCacheKey const&, TileCacheKey const&) = default;
};
}
 
template <>
struct std::hash<TileCacheKey>
{
    static std::size_t Compute(TileCacheKey const& key) noexcept
    {
        Trinity::HashFnv1a<> hash;
        hash.UpdateData(key.TerrainMapId);
        hash.UpdateData(key.X);
        hash.UpdateData(key.Y);
        for (TileCacheKeyObject const& object : key.Objects)
        {
            hash.UpdateData(object.DisplayId);
            hash.UpdateData(object.Scale);
            hash.UpdateData(object.Position);
            hash.UpdateData(object.Rotation);
        }
        return hash.Value;
    }
 
    std::size_t operator()(TileCacheKey const& key) const noexcept
    {
        return key.CachedHash;
    }
};
 
namespace
{
std::unique_ptr<VMAP::VMapManager> CreateVMapManager(uint32 mapId)
{
    std::unique_ptr<VMAP::VMapManager> vmgr = std::make_unique<VMAP::VMapManager>();
 
    do
    {
        MapEntry const* mapEntry = sMapStore.AssertEntry(mapId);
        if (!mapEntry)
            break;
 
        vmgr->InitializeThreadUnsafe(mapId, mapEntry->ParentMapID);
        if (mapEntry->ParentMapID < 0)
            break;
 
        mapId = mapEntry->ParentMapID;
    } while (true);
 
    VMAP::VMapManager* globalManager = VMAP::VMapFactory::createOrGetVMapManager();
    vmgr->GetLiquidFlagsPtr = globalManager->GetLiquidFlagsPtr;
    vmgr->IsVMAPDisabledForPtr = globalManager->IsVMAPDisabledForPtr;
    vmgr->LoadPathOnlyModels = globalManager->LoadPathOnlyModels;
    return vmgr;
}
 
struct TileCache
{
    static TileCache* Instance()
    {
        static TileCache tc;
        return &tc;
    }
 
    struct Tile
    {
        std::shared_ptr<MMAP::DynamicTileBuilder::AsyncTileResult> Data;
        TimePoint LastAccessed;
    };
 
    static constexpr TimePoint::duration CACHE_CLEANUP_INTERVAL = 5min;
    static constexpr TimePoint::duration CACHE_MAX_AGE = 30min;
 
    std::mutex TilesMutex;
    std::unordered_map<TileCacheKey, Tile> Tiles;
 
    TileCache() :
        _taskContext(1),
        _cacheCleanupTimer(_taskContext, CACHE_CLEANUP_INTERVAL)
    {
        MMAP::CreateVMapManager = &CreateVMapManager;
 
        // init timer
        OnCacheCleanupTimerTick();
 
        // start the worker
        _builderThread = std::thread([this] { _taskContext.run(); });
    }
 
    TileCache(TileCache const&) = delete;
    TileCache(TileCache&&) = delete;
 
    TileCache& operator=(TileCache const&) = delete;
    TileCache& operator=(TileCache&&) = delete;
 
    ~TileCache()
    {
        _cacheCleanupTimer.cancel();
        _builderThread.join();
    }
 
    template <typename Task>
    auto StartTask(Task&& task)
    {
        return Trinity::Asio::post(_taskContext, std::forward<Task>(task));
    }
 
private:
    void OnCacheCleanupTimerTick()
    {
        TimePoint now = GameTime::Now();
        RemoveOldCacheEntries(now - CACHE_MAX_AGE);
        _cacheCleanupTimer.expires_at(now + CACHE_CLEANUP_INTERVAL);
        _cacheCleanupTimer.async_wait([this](boost::system::error_code const& error)
        {
            if (error || !_builderThread.joinable() /*shutting down*/)
                return;
 
            OnCacheCleanupTimerTick();
        });
    }
 
    void RemoveOldCacheEntries(TimePoint oldestPreservedEntryTimestamp)
    {
        std::scoped_lock lock(TilesMutex);
        Trinity::Containers::EraseIf(Tiles, [=](std::unordered_map<TileCacheKey, Tile>::value_type const& kv)
        {
            return kv.second.LastAccessed < oldestPreservedEntryTimestamp;
        });
    }
 
    Trinity::Asio::IoContext _taskContext;
    Trinity::Asio::DeadlineTimer _cacheCleanupTimer;
    std::thread _builderThread;
};
}
 
namespace MMAP
{
struct DynamicTileBuilder::TileId
{
    uint32 TerrainMapId;
    uint32 X;
    uint32 Y;
 
    friend bool operator==(TileId const&, TileId const&) = default;
};
 
struct TileBuildRequest
{
    DynamicTileBuilder::TileId Id;
    std::weak_ptr<DynamicTileBuilder::AsyncTileResult> Result;
    dtNavMesh* NavMesh;
};
 
bool InvokeAsyncCallbackIfReady(TileBuildRequest& request)
{
    std::shared_ptr<DynamicTileBuilder::AsyncTileResult> result = request.Result.lock();
    if (!result)
        return true;    // expired, mark as complete and do nothing
 
    if (!result->IsReady.load(std::memory_order::acquire))
        return false;
 
    TileBuilder::TileResult const& tileResult = result->Result;
    if (tileResult.data)
    {
        dtMeshHeader const* header = reinterpret_cast<dtMeshHeader const*>(tileResult.data.get());
 
        if (dtTileRef tileRef = request.NavMesh->getTileRefAt(header->x, header->y, 0))
        {
            TC_LOG_INFO("maps.mmapgen", "[Map {:04}] [{:02},{:02}]: Swapping new tile", request.Id.TerrainMapId, request.Id.Y, request.Id.X);
 
            request.NavMesh->removeTile(tileRef, nullptr, nullptr);
 
            unsigned char* data = static_cast<unsigned char*>(dtAlloc(tileResult.size, DT_ALLOC_PERM));
            std::memcpy(data, tileResult.data.get(), tileResult.size);
 
            request.NavMesh->addTile(data, tileResult.size, DT_TILE_FREE_DATA, tileRef, nullptr);
        }
    }
 
    return true;
}
 
static constexpr auto SetAsyncCallbackReady = [](DynamicTileBuilder::AsyncTileResult* result)
{
    result->IsReady.store(true, std::memory_order::release);
};
 
DynamicTileBuilder::DynamicTileBuilder(Map* map, dtNavMesh* navMesh) : TileBuilder(sWorld->GetDataPath(), sWorld->GetDataPath(), {}, {}, false, false, false, nullptr),
    m_map(map), m_navMesh(navMesh), m_rebuildCheckTimer(1s)
{
}
 
DynamicTileBuilder::~DynamicTileBuilder() = default;
 
void DynamicTileBuilder::AddTile(uint32 terrainMapId, uint32 tileX, uint32 tileY)
{
    TileId id = { .TerrainMapId = terrainMapId, .X = tileX, .Y = tileY };
    if (!advstd::ranges::contains(m_tilesToRebuild, id))
        m_tilesToRebuild.push_back(id);
}
 
void DynamicTileBuilder::Update(Milliseconds diff)
{
    m_rebuildCheckTimer.Update(diff);
    if (m_rebuildCheckTimer.Passed())
    {
        for (TileId const& tileId : m_tilesToRebuild)
            m_tiles.AddCallback({ .Id = tileId, .Result = BuildTile(tileId.TerrainMapId, tileId.X, tileId.Y), .NavMesh = m_navMesh });
 
        m_tilesToRebuild.clear();
        m_rebuildCheckTimer.Reset(1s);
    }
 
    m_tiles.ProcessReadyCallbacks();
}
 
std::weak_ptr<DynamicTileBuilder::AsyncTileResult> DynamicTileBuilder::BuildTile(uint32 terrainMapId, uint32 tileX, uint32 tileY)
{
    struct GameObjectModelWorkData
    {
        explicit GameObjectModelWorkData(std::shared_ptr<VMAP::WorldModel const> worldModel, G3D::Vector3 const& position, float scale,
            G3D::Quat const& rotation, GameObjectModel const* gameObject) : WorldModel(std::move(worldModel)), Position(position),
            Rotation(rotation), Scale(scale), GameObject(gameObject) { }
 
        std::shared_ptr<VMAP::WorldModel const> WorldModel;
        G3D::Vector3 Position;
        G3D::Quat Rotation;
        float Scale;
        GameObjectModel const* GameObject;
    };
 
    std::vector<GameObjectModelWorkData> modelSpawns;
    for (GameObjectModel const* gameObjectModel : m_map->GetGameObjectModelsInGrid(tileX, tileY))
    {
        if (!gameObjectModel->IsIncludedInNavMesh())
            continue;
 
        std::shared_ptr<VMAP::WorldModel const> worldModel = gameObjectModel->GetWorldModel();
        if (!worldModel)
            continue;
 
        modelSpawns.emplace_back(std::move(worldModel), gameObjectModel->GetPosition(),
            gameObjectModel->GetScale(), gameObjectModel->GetRotation(), gameObjectModel);
    }
 
    TileCacheKey cacheKey{ .TerrainMapId = terrainMapId, .X = tileX, .Y = tileY, .CachedHash = 0, .Objects = std::vector<TileCacheKeyObject>(modelSpawns.size()) };
    for (std::size_t i = 0; i < modelSpawns.size(); ++i)
    {
        GameObjectModel const* gameObjectModel = modelSpawns[i].GameObject;
        TileCacheKeyObject& object = cacheKey.Objects[i];
        object.DisplayId = gameObjectModel->GetDisplayId();
        object.Scale = int16(gameObjectModel->GetScale() * 1024.0f);
        object.Position = [](G3D::Vector3 const& pos) -> std::array<int16, 3>
        {
            return { int16(pos.x), int16(pos.y), int16(pos.z) };
        }(gameObjectModel->GetPosition());
        object.Rotation = gameObjectModel->GetPackedRotation();
    }
 
    // Ensure spawn order is stable after adding/removing gameobjects from the map for hash calculation
    std::ranges::sort(cacheKey.Objects);
 
    cacheKey.CachedHash = std::hash<TileCacheKey>::Compute(cacheKey);
 
    TileCache* tileCache = TileCache::Instance();
    std::scoped_lock lock(tileCache->TilesMutex);
    auto [itr, isNew] = tileCache->Tiles.try_emplace(std::move(cacheKey));
    itr->second.LastAccessed = GameTime::Now();
    if (!isNew)
        return itr->second.Data;
 
    itr->second.Data = std::make_shared<AsyncTileResult>();
    tileCache->StartTask([result = itr->second.Data, hash = cacheKey.CachedHash, selfRef = weak_from_this(), terrainMapId, tileX, tileY, modelSpawns = std::move(modelSpawns)]() mutable
    {
        auto isReadyGuard = Trinity::make_unique_ptr_with_deleter<SetAsyncCallbackReady>(result.get());
 
        std::shared_ptr<DynamicTileBuilder> self = selfRef.lock();
        if (!self)
            return;
 
        // get navmesh params
        dtNavMeshParams params;
        std::vector<OffMeshData> offMeshConnections;
        if (MMapManager::parseNavMeshParamsFile(sWorld->GetDataPath(), terrainMapId, &params, &offMeshConnections) != LoadResult::Success)
            return;
 
        std::unique_ptr<VMAP::VMapManager> vmapManager = CreateVMapManager(terrainMapId);
 
        MeshData meshData;
 
        // get heightmap data
        self->m_terrainBuilder.loadMap(terrainMapId, tileX, tileY, meshData, vmapManager.get());
 
        // get model data
        self->m_terrainBuilder.loadVMap(terrainMapId, tileX, tileY, meshData, vmapManager.get());
 
        for (GameObjectModelWorkData const& model : modelSpawns)
        {
            G3D::Vector3 position = model.Position;
            position.x = -position.x;
            position.y = -position.y;
 
            G3D::Matrix3 invRotation = (G3D::Quat(0, 0, 1, 0) * model.Rotation).toRotationMatrix().inverse();
 
            self->m_terrainBuilder.loadVMapModel(model.WorldModel.get(), position, invRotation, model.Scale,
                meshData, vmapManager.get());
        }
 
        // if there is no data, give up now
        if (meshData.solidVerts.empty() && meshData.liquidVerts.empty())
            return;
 
        // remove unused vertices
        TerrainBuilder::cleanVertices(meshData.solidVerts, meshData.solidTris);
        TerrainBuilder::cleanVertices(meshData.liquidVerts, meshData.liquidTris);
 
        // gather all mesh data for final data check, and bounds calculation
        std::vector<float> allVerts(meshData.liquidVerts.size() + meshData.solidVerts.size());
        std::ranges::copy(meshData.liquidVerts, allVerts.begin());
        std::ranges::copy(meshData.solidVerts, allVerts.begin() + std::ssize(meshData.liquidVerts));
 
        // get bounds of current tile
        float bmin[3], bmax[3];
        getTileBounds(tileX, tileY, allVerts.data(), allVerts.size() / 3, bmin, bmax);
 
        self->m_terrainBuilder.loadOffMeshConnections(terrainMapId, tileX, tileY, meshData, offMeshConnections);
 
        // build navmesh tile
        std::string debugSuffix = Trinity::StringFormat("_{:016X}", hash);
 
        result->Result = self->buildMoveMapTile(terrainMapId, tileX, tileY, meshData, bmin, bmax, &params);
        if (self->m_debugOutput && result->Result.data)
            self->saveMoveMapTileToFile(terrainMapId, tileX, tileY, nullptr, result->Result, debugSuffix);
    });
 
    return itr->second.Data;
}
}