MapConfig.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ecs/AssetCatalog.hpp"
#include "ecs/components/PowerupState.hpp"
#include "ecs/physics/MapLoader.hpp"
 
#include <SDL3/SDL_filesystem.h>
#include <SDL3/SDL_log.h>
 
#include <assimp/Importer.hpp>
#include <assimp/postprocess.h>
#include <assimp/scene.h>
#include <fstream>
#include <functional>
#include <iostream>
#include <string>
 
namespace gamemap
{

inline constexpr bool k_separatedCollisionMap = false;

inline constexpr const char* k_collisionPattern = "COL_";

inline constexpr bool k_useVhacd = false;

[[nodiscard]] inline physics::MapLoadOptions makeLoadOptions()
{
    physics::MapLoadOptions opts;
    opts.scale = kMapAsset.loadScale;
    opts.allMeshesAreCollision = !k_separatedCollisionMap;
    if (k_separatedCollisionMap)
        opts.collisionCollection = k_collisionPattern;
    opts.addFloorPlane = false; // Map geometry provides its own floor.
    return opts;
}

[[nodiscard]] inline std::string mapAbsolutePath()
{
    const char* const base = SDL_GetBasePath();
    return std::string(base ? base : "") + "assets/" + kMapAsset.filename;
}

struct SpawnPoint
{
    glm::vec3 pos{0.0f};
    float yaw = 0.0f; 
};
inline std::vector<SpawnPoint> spawnPoints_;
 
struct WeaponSpawner
{
    WeaponType type;
    glm::vec3 pos;
};
inline std::vector<WeaponSpawner> weaponSpawner_;
 
struct PowerupSpawner
{
    PowerupType type;
    glm::vec3 pos;
};
inline std::vector<PowerupSpawner> powerupSpawner_;
 
struct HealthPackSpawner
{
    glm::vec3 pos;
};
inline std::vector<HealthPackSpawner> healthPackSpawner_;

struct JumpPadSpawner
{
    glm::vec3 pos{0.0f};
    glm::vec3 velocity{0.0f, 1500.0f, 0.0f};
    glm::vec3 halfExtents{48.0f, 24.0f, 48.0f};
};
inline std::vector<JumpPadSpawner> jumpPadSpawner_;

struct KillzoneSpawner
{
    glm::vec3 pos{0.0f};
    glm::vec3 halfExtents{674.0f, 184.0f, 499.0f};
};
inline std::vector<KillzoneSpawner> killzoneSpawner_;
 
void traverseNodeTree(const aiNode* node, int depth = 0)
{
    if (node == nullptr) {
        return;
    }
 
    for (int i = 0; i < depth; i++) {
        std::cout << "  ";
    }
 
    std::cout << node->mName.C_Str() << "\n";
 
    for (unsigned int i = 0; i < node->mNumChildren; i++) {
        traverseNodeTree(node->mChildren[i], depth + 1);
    }
}
 
void* getMetadataValue(const aiMetadata* metadata, const std::string& key)
{
    if (metadata == nullptr) {
        return nullptr;
    }
 
    for (unsigned int i = 0; i < metadata->mNumProperties; i++) {
        if (key == metadata->mKeys[i].C_Str()) {
            return metadata->mValues[i].mData;
        }
    }
 
    return nullptr;
}

inline float getMetadataFloat(const aiMetadata* metadata, const std::string& key, float fallback)
{
    if (metadata == nullptr)
        return fallback;
    for (unsigned int i = 0; i < metadata->mNumProperties; i++) {
        if (key != metadata->mKeys[i].C_Str())
            continue;
        const aiMetadataEntry& entry = metadata->mValues[i];
        switch (entry.mType) {
        case AI_FLOAT:
            return *static_cast<float*>(entry.mData);
        case AI_DOUBLE:
            return static_cast<float>(*static_cast<double*>(entry.mData));
        case AI_INT32:
            return static_cast<float>(*static_cast<int32_t*>(entry.mData));
        default:
            return fallback;
        }
    }
    return fallback;
}

inline bool loadConfiguredMap(physics::MapCollisionData& out, const char* tag)
{
    const std::string path = mapAbsolutePath();
    const physics::MapLoadOptions opts = makeLoadOptions();
 
    if (!physics::loadMapCollision(path, out, opts)) {
        SDL_Log("[%s] WARNING: map collision load failed (%s) — falling back to testWorld()", tag, kMapAsset.filename);
        return false;
    }
 
    SDL_Log("[%s] map collision loaded (%s): %zu planes, %zu boxes, %zu brushes, %zu cylinders, %zu spheres, "
            "%zu trimeshes",
            tag,
            kMapAsset.filename,
            out.planes.size(),
            out.boxes.size(),
            out.brushes.size(),
            out.cylinders.size(),
            out.spheres.size(),
            out.triMeshes.size());
 
    // Load gameplay entities from map
    Assimp::Importer importer;
    const aiScene* scene = importer.ReadFile(path, 0 /* no flags */);
 
    if (scene == nullptr)
        return false;
 
    std::function<void(const aiNode*, int)> traverse = [&](const aiNode* node, int depth) {
        if (node == nullptr) {
            return;
        }
 
        if (node->mMetaData) {
            void* entity_type_ptr = getMetadataValue(node->mMetaData, "entity_type");
            if (entity_type_ptr != nullptr) {
                const int32_t entity_type = *static_cast<int32_t*>(entity_type_ptr);
                const char* const nodeName = node->mName.C_Str();
                switch (entity_type) {
                case 0: // Player spawn point
                {
                    const aiMatrix4x4& t = node->mTransformation;
                    glm::vec3 pos = glm::vec3(t.a4, t.b4, t.c4) * kMapAsset.loadScale;
                    // Facing yaw from the node's local -Z axis (glTF/OpenGL
                    // forward), projected onto the XZ plane. Matches
                    // viewForward(): yaw = atan2(fwd.x, fwd.z). Falls back to 0
                    // (facing +Z) when the spawn wasn't rotated in the map.
                    const glm::vec3 fwd{-t.a3, -t.b3, -t.c3};
                    float yaw = 0.0f;
                    if (std::abs(fwd.x) > 1e-4f || std::abs(fwd.z) > 1e-4f) {
                        yaw = std::atan2(fwd.x, fwd.z);
                    }
                    spawnPoints_.push_back(SpawnPoint{.pos = pos, .yaw = yaw});
                    break;
                }
                case 1: // Weapon spawn point
                {
                    void* weapon_type_ptr = getMetadataValue(node->mMetaData, "weapon_type");
                    if (weapon_type_ptr == nullptr) {
                        SDL_Log("Weapon spawner '%s' missing 'weapon_type' metadata — skipping", nodeName);
                        break;
                    }
                    const aiMatrix4x4& t = node->mTransformation;
                    WeaponType weapon_type = static_cast<WeaponType>(*static_cast<int32_t*>(weapon_type_ptr));
                    glm::vec3 pos = glm::vec3(t.a4, t.b4, t.c4) * kMapAsset.loadScale;
                    weaponSpawner_.push_back(WeaponSpawner{.type = weapon_type, .pos = pos});
                    break;
                }
                case 2: // Power up spawn point
                {
                    void* powerup_type_ptr = getMetadataValue(node->mMetaData, "powerup_type");
                    if (powerup_type_ptr == nullptr) {
                        SDL_Log("Powerup spawner '%s' missing 'powerup_type' metadata — skipping", nodeName);
                        break;
                    }
                    const aiMatrix4x4& t = node->mTransformation;
                    PowerupType powerup_type = static_cast<PowerupType>(*static_cast<int32_t*>(powerup_type_ptr));
                    glm::vec3 pos = glm::vec3(t.a4, t.b4, t.c4) * kMapAsset.loadScale;
                    powerupSpawner_.push_back(PowerupSpawner{.type = powerup_type, .pos = pos});
                    break;
                }
                case 3: // Jump pad
                {
                    const aiMatrix4x4& t = node->mTransformation;
                    glm::vec3 pos = glm::vec3(t.a4, t.b4, t.c4) * kMapAsset.loadScale;
                    JumpPadSpawner pad;
                    pad.pos = pos;
                    pad.velocity.x = getMetadataFloat(node->mMetaData, "jump_velocity_x", pad.velocity.x);
                    pad.velocity.y = getMetadataFloat(node->mMetaData, "jump_velocity_y", pad.velocity.y);
                    pad.velocity.z = getMetadataFloat(node->mMetaData, "jump_velocity_z", pad.velocity.z);
                    pad.halfExtents.x = getMetadataFloat(node->mMetaData, "half_extent_x", pad.halfExtents.x);
                    pad.halfExtents.y = getMetadataFloat(node->mMetaData, "half_extent_y", pad.halfExtents.y);
                    pad.halfExtents.z = getMetadataFloat(node->mMetaData, "half_extent_z", pad.halfExtents.z);
                    jumpPadSpawner_.push_back(pad);
                    break;
                }
                case 4: // Killzone (lava pit, void, etc.)
                {
                    const aiMatrix4x4& t = node->mTransformation;
                    glm::vec3 pos = glm::vec3(t.a4, t.b4, t.c4) * kMapAsset.loadScale;
                    KillzoneSpawner kz;
                    kz.pos = pos;
                    kz.halfExtents.x = getMetadataFloat(node->mMetaData, "half_extent_x", kz.halfExtents.x);
                    kz.halfExtents.y = getMetadataFloat(node->mMetaData, "half_extent_y", kz.halfExtents.y);
                    kz.halfExtents.z = getMetadataFloat(node->mMetaData, "half_extent_z", kz.halfExtents.z);
                    killzoneSpawner_.push_back(kz);
                    break;
                }
                case 5: // Health pack spawn point
                {
                    const aiMatrix4x4& t = node->mTransformation;
                    glm::vec3 pos = glm::vec3(t.a4, t.b4, t.c4) * kMapAsset.loadScale;
                    healthPackSpawner_.push_back(HealthPackSpawner{.pos = pos});
                    break;
                }
                default:
                    SDL_Log("Unknown entity_type %d on node '%s' — skipping", entity_type, nodeName);
                    break;
                }
            }
        }
 
        for (unsigned int i = 0; i < node->mNumChildren; i++) {
            traverse(node->mChildren[i], depth + 1);
        }
    };
 
    traverse(scene->mRootNode, 0);
 
    std::ofstream out_file("spawn_points.txt");
 
    if (out_file.is_open()) {
        out_file << "Spawn Points (" << spawnPoints_.size() << ")\n";
 
        for (size_t i = 0; i < spawnPoints_.size(); i++) {
            const glm::vec3& p = spawnPoints_[i].pos;
 
            out_file << i << ": (" << p.x << ", " << p.y << ", " << p.z << ") yaw=" << spawnPoints_[i].yaw << "\n";
        }
    }
 
    return true;
}
 
} // namespace gamemap