sub_5F36D0 —— MPP 缓存装配与通行格栅化

void __thiscall sub_5F36D0(
    DWORD* this,
    int a2,
    float* a3,
    float* a4,
    float* a5,
    char a6,
    char a7);

void __thiscall CLevel::loadOrBuildPassabilityRegion(
    const std::wstring& layout_path,
    const Ogre::Vector3& bounds_min,
    const Ogre::Vector3& bounds_max,
    const Ogre::Vector3& world_ext,
    bool clear_region,
    bool claim_work_mask);

header.world_ext_x = world_ext.x - bounds_min.x;
header.world_ext_z = world_ext.z - bounds_min.z;
header.bounds_x     = bounds_max.x - bounds_min.x;
header.bounds_z     = bounds_max.z - bounds_min.z;

std::wstring mpp_path = layout_path;
mpp_path = mpp_path.substr(0, mpp_path.length() - 6);
mpp_path += L"mpp";

bool CLevel::mpp_cache_io_enabled; // +0x36D，默认 true

if (!level->mpp_output_override.empty())
    mpp_path = level->mpp_output_override;

bool cache_valid = false;
bool layout_exists = false;
bool path_is_empty = layout_path.empty();

if (mpp_cache_io_enabled && !path_is_empty) {
    mpp_path = replaceLayoutSuffix(layout_path, L"mpp");
    PackageEntry* entry = PackageMgr::findFile(mpp_path);
    cache_valid = entry != nullptr;

    layout_exists = fileExists(layout_path);
    if (!layout_exists && !mpp_output_override.empty()) {
        auto override_layout = replaceMppSuffix(mpp_output_override, L"layout");
        layout_exists = fileExists(override_layout);
    }

    bool loose_mpp_exists = fileExists(mpp_path);

    if (cache_valid && loose_mpp_exists && layout_exists) {
        if (!mpp_output_override.empty()) {
            cache_valid = false;
        } else if (isOlderOrMissing(mpp_path, layout_path)) {
            cache_valid = false;
        } else if (!sameFileTimeAsPackageEntry(entry, mpp_path)) {
            cache_valid = false;
            if (entry->crc32 != 0xFFFFFFFF)
                cache_valid = crc32File(mpp_path) == entry->crc32;
        }
    } else if (layout_exists && !loose_mpp_exists) {
        cache_valid = false;
    }

    if (developer_force_cache_flag)
        cache_valid = true;
}

#pragma pack(push, 1)
struct MppHeader {
    int32_t grid_width;
    int32_t grid_height;
    float   world_ext_x;
    float   world_ext_z;
    float   bounds_x;
    float   bounds_z;
};
#pragma pack(pop)

static_assert(sizeof(MppHeader) == 24);

constexpr float CELLS_PER_UNIT = 2.5f;
constexpr float CELL_SIZE      = 0.4f;

int start_x = floor((bounds_min.x - grid_origin_x) * 2.5f);
int start_z = floor((bounds_min.z - grid_origin_z) * 2.5f);
int end_x   = ceil ((bounds_max.x - grid_origin_x) * 2.5f);
int end_z   = ceil ((bounds_max.z - grid_origin_z) * 2.5f);

int width  = end_x - start_x;
int height = end_z - start_z;

float cached_min_x = world_ext.x - header.world_ext_x;
float cached_min_z = world_ext.z - header.world_ext_z;

start_x = floor((cached_min_x - grid_origin_x) * 2.5f);
start_z = floor((cached_min_z - grid_origin_z) * 2.5f);
end_x   = start_x + header.grid_width;
end_z   = start_z + header.grid_height;

float world_x = grid_origin_x + grid_x * 0.4f + 0.2f;
float world_z = grid_origin_z + grid_z * 0.4f + 0.2f;

uint8_t* cached_cells = new uint8_t[header.grid_width * header.grid_height];
read(cached_cells, header.grid_width * header.grid_height);

++g_rooms_path_cached;                       // 0x3352734
g_pathnodes_loaded += width * height;        // 0x3352738

local_index = (global_z - start_z) * cached_width
            + (global_x - start_x);

uint8_t value = cached_cells[local_index];
if (inside_level_grid && value != 0xFF) {
    level->primary[global_x][global_z] = value;
    if (value == 0)
        ++level->zero_grid_cell_count;
}

for each cell in region:
    if (inside_level_grid &&
        (!claim_work_mask || work_mask[x][z] < 0))
        primary[x][z] = 0;

if (work_mask[x][z] > 0)
    skip;

++g_pathnodes_calculated;  // 0x3352730
work_mask[x][z] = 1;

temp[cell] = primary[x][z];
if (temp[cell] == 0xFF)
    temp[cell] = 0;

CLevel::prepareCollisionCandidates(query_min, query_max); // sub_5F2C70

Vector3 ray_from(world_x, -200.0f, world_z);
Vector3 ray_to  (world_x,  200.0f, world_z);

if (!raycastVertical(ray_from, ray_to, 0.1f, ...)) {
    temp[cell] = 0xFF;               // 没有地面/无几何
} else if (hit.y > 80.0f ||
           hit.y < -80.0f ||
           hit.kind == 100) {
    temp[cell] = 1;                  // 超出有效层高或特殊阻挡类
} else {
    temp[cell] = 0;                  // 暂定可走，继续净空检查
}

Vector3 origin(hit.x, hit.y + 1.5f, hit.z);

origin → origin + Vector3(+0.3, 0, 0)
origin → origin + Vector3(-0.3, 0, 0)
origin → origin + Vector3(0, 0, +0.3)
origin → origin + Vector3(0, 0, -0.3)

primary[x][z] = temp[cell];
if (temp[cell] == 0)
    ++level->zero_grid_cell_count;

bool blocked(int x, int z) {
    if (x < 0 || z < 0 || x >= grid_width || z >= grid_height)
        return true;
    return primary[x][z] == 1;
}

if ((blocked(x - 1, z)     && blocked(x + 1, z))     ||
    (blocked(x, z - 1)     && blocked(x, z + 1))     ||
    (blocked(x - 1, z - 1) && blocked(x + 1, z + 1)) ||
    (blocked(x + 1, z - 1) && blocked(x - 1, z + 1))) {
    primary[x][z] = 1;
}

--level->zero_grid_cell_count;

if (level->mpp_cache_io_enabled &&
    !cache_valid &&
    !layout_path.empty() &&
    layout_exists) {
    writeMpp(...);
}

fwrite(&width,                   4, 1, fp);
fwrite(&height,                  4, 1, fp);
fwrite(&world_ext_minus_min_x,   4, 1, fp);
fwrite(&world_ext_minus_min_z,   4, 1, fp);
fwrite(&bounds_width_x,          4, 1, fp);
fwrite(&bounds_depth_z,          4, 1, fp);
fwrite(cells, width * height,    1, fp);

if (file_size < 24) reject;
if (width <= 0 || height <= 0) reject;
if (uint64_t(width) * uint64_t(height) > MAX_GRID_CELLS) reject;
if (file_size != 24 + uint64_t(width) * uint64_t(height)) reject;
if (any cell not in {0, 1, 0xFF}) warn_or_reject;

Vector3 size = box.getMaximum() - box.getMinimum();
float_area += size.z * size.x;       // Y 不参与

loadOrBuildPassabilityRegion(
    L"", box.getMinimum(), box.getMaximum(), box.getMinimum(), true, true);

if (cell == 0)
    ++level->zero_grid_cell_count; // CLevel+0x54

void CLevel::loadOrBuildPassabilityRegion(
    const std::wstring& layoutPath,
    const Vector3& boundsMin,
    const Vector3& boundsMax,
    const Vector3& worldExt,
    bool clearRegion,
    bool claimWorkMask)
{
    std::wstring mppPath = layoutPath;
    bool cacheValid = false;
    bool pathEmpty = false;
    bool layoutExists = false;
    PackageEntry* packageEntry = nullptr;

    if (!mpp_cache_io_enabled || layoutPath.empty()) {
        pathEmpty = true;
    } else {
        mppPath = replaceSuffix(layoutPath, 6, L"mpp");
        packageEntry = PackageMgr::findFile(mppPath);
        cacheValid = packageEntry != nullptr;
        layoutExists = fileExists(layoutPath);

        if (!layoutExists && !mpp_output_override.empty()) {
            auto altLayout = replaceSuffix(mpp_output_override, 3, L"layout");
            layoutExists = fileExists(altLayout);
        }

        bool looseMppExists = fileExists(mppPath);
        cacheValid = validateMppCache(
            cacheValid,
            packageEntry,
            looseMppExists,
            layoutExists,
            layoutPath,
            mppPath,
            mpp_output_override);
    }

    int startX = floor((boundsMin.x - grid_origin_x) * 2.5f);
    int startZ = floor((boundsMin.z - grid_origin_z) * 2.5f);
    int endX   = ceil ((boundsMax.x - grid_origin_x) * 2.5f);
    int endZ   = ceil ((boundsMax.z - grid_origin_z) * 2.5f);
    int width  = endX - startX;
    int height = endZ - startZ;

    uint8_t* local = nullptr;
    MppHeader header{};

    if (cacheValid) {
        readMpp(mppPath, &header, &local);
        startX = floor((worldExt.x - header.world_ext_x - grid_origin_x) * 2.5f);
        startZ = floor((worldExt.z - header.world_ext_z - grid_origin_z) * 2.5f);
        width  = header.grid_width;
        height = header.grid_height;
        endX   = startX + width;
        endZ   = startZ + height;

        ++g_rooms_path_cached;
        g_pathnodes_loaded += width * height;
    } else {
        if (!layoutPath.empty())
            ++g_rooms_repathed;
        local = new uint8_t[width * height];
    }

    if (collision_list) {
        if (clearRegion)
            clearPrimaryRegion(startX, startZ, endX, endZ, claimWorkMask);

        for (int x = startX; x < endX; ++x) {
            for (int z = startZ; z < endZ; ++z) {
                int li = (z - startZ) * width + (x - startX);

                if (cacheValid) {
                    uint8_t value = local[li];
                    if (insideGlobalGrid(x, z) && value != 0xFF) {
                        primary[x][z] = value;
                        if (value == 0)
                            ++zero_grid_cell_count;
                    }
                    continue;
                }

                if (!insideGlobalGrid(x, z)) {
                    local[li] = 0xFF;
                    continue;
                }

                if (claimWorkMask && work_mask[x][z] > 0)
                    continue;

                ++g_pathnodes_calculated;
                if (claimWorkMask)
                    work_mask[x][z] = 1;

                local[li] = primary[x][z];
                if (local[li] == 0xFF)
                    local[li] = 0;

                if (local[li] == 0) {
                    float wx = grid_origin_x + x * 0.4f + 0.2f;
                    float wz = grid_origin_z + z * 0.4f + 0.2f;
                    local[li] = classifyCell(wx, wz); // 0, 1, or 0xFF
                }

                primary[x][z] = local[li];
                if (local[li] == 0)
                    ++zero_grid_cell_count;
            }
        }
    }

    if (!cacheValid)
        enclosurePass(primary, startX, startZ, endX, endZ, local);

    if (mpp_cache_io_enabled && !cacheValid &&
        !pathEmpty && layoutExists) {
        writeMpp(mpp_output_override.empty() ? mppPath
                                             : mpp_output_override,
                 width, height,
                 worldExt.x - boundsMin.x,
                 worldExt.z - boundsMin.z,
                 boundsMax.x - boundsMin.x,
                 boundsMax.z - boundsMin.z,
                 local);
        refreshPackageRecord(mppPath);
    }

    delete[] local;
}

uint8_t CLevel::classifyCell(float x, float z)
{
    Vector3 down(x, -200.0f, z);
    Vector3 up  (x,  200.0f, z);

    prepareCollisionCandidates(cellQueryMin(x, z), cellQueryMax(x, z));

    Hit hit;
    if (!raycastWide(down, up, 0.1f, 0.1f, &hit))
        return 0xFF;

    if (hit.position.y > 80.0f ||
        hit.position.y < -80.0f ||
        hit.kind == 100)
        return 1;

    Vector3 body = hit.position + Vector3(0, 1.5f, 0);
    for (Vector3 d : {
        Vector3(+0.3f, 0, 0),
        Vector3(-0.3f, 0, 0),
        Vector3(0, 0, +0.3f),
        Vector3(0, 0, -0.3f) }) {
        Hit side;
        if (raycast(body, body + d, &side) && side.kind == 100)
            return 1;
    }

    return 0;
}

floor((x - origin) * 2.5f)       // 原版顺序
floor(double(x - origin) / 0.4)  // 不保证一致