ModernEnvironment.cpp

Go to the documentation of this file.

#include "ModernEnvironment.hpp"
 
#include "Display.hpp"
#include "SequenceTransforms.hpp"
 
#include <cstdlib>
#include <atomic>
#include <charconv>
#include <thread>
#include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <new>
#include <string>
#include <utility>
 
namespace monopoly::engine
{
    namespace
    {
        constexpr std::array<ModernEnvironmentDefinition, ModernEnvironmentCount> Definitions{{
            {"fountain", "environment/paris_fountain.glb",
                data::packDataId(ModernEnvironmentLogicalGroup, 0), ModernEnvironmentNodeBase | 1U,
                {0.0F, 0.12F, -2.0F}, -90.0F},
            {"station", "environment/paris_station.glb",
                data::packDataId(ModernEnvironmentLogicalGroup, 1), ModernEnvironmentNodeBase | 2U,
                {-5.5F, 0.12F, -5.9F}, -90.0F},
            {"morris", "environment/paris_morris_column.glb",
                data::packDataId(ModernEnvironmentLogicalGroup, 2), ModernEnvironmentNodeBase | 3U,
                {3.9F, 0.0F, -4.1F}, -90.0F}
        }};
        constexpr std::array<ModernEnvironmentDefinition, 2> PresentationDefinitions{{
            {"table", "presentation/table.glb", data::packDataId(ModernEnvironmentLogicalGroup, 3),
                ModernEnvironmentNodeBase | 4U, {0,0,0}, 0.0F},
            {"plinth", "presentation/plinth.glb", data::packDataId(ModernEnvironmentLogicalGroup, 4),
                ModernEnvironmentNodeBase | 5U, {0,0,0}, 0.0F}
        }};
        // Global centred runtime coordinates, exported in independent groups
        // from the recovered authoring scene. No retail root or rule owns them.
        constexpr std::array<ModernEnvironmentDefinition, ModernCityCount> CityDefinitions{{
            {"city front a", "environment/procedural_city_buildings_front_a.glb", data::packDataId(ModernEnvironmentLogicalGroup,5), ModernEnvironmentNodeBase|6U, {0,0,0},0},
            {"city front b", "environment/procedural_city_buildings_front_b.glb", data::packDataId(ModernEnvironmentLogicalGroup,6), ModernEnvironmentNodeBase|7U, {0,0,0},0},
            {"city back", "environment/procedural_city_buildings_back.glb", data::packDataId(ModernEnvironmentLogicalGroup,7), ModernEnvironmentNodeBase|8U, {0,0,0},0},
            {"city east", "environment/procedural_city_buildings_east.glb", data::packDataId(ModernEnvironmentLogicalGroup,8), ModernEnvironmentNodeBase|9U, {0,0,0},0},
            {"city west a", "environment/procedural_city_buildings_west_a.glb", data::packDataId(ModernEnvironmentLogicalGroup,9), ModernEnvironmentNodeBase|10U, {0,0,0},0},
            {"city west b", "environment/procedural_city_buildings_west_b.glb", data::packDataId(ModernEnvironmentLogicalGroup,10), ModernEnvironmentNodeBase|11U, {0,0,0},0},
            {"city skyline", "environment/procedural_city_skyline.glb", data::packDataId(ModernEnvironmentLogicalGroup,11), ModernEnvironmentNodeBase|12U, {0,0,0},0},
            {"city street furniture", "environment/procedural_city_street_furniture.glb", data::packDataId(ModernEnvironmentLogicalGroup,12), ModernEnvironmentNodeBase|13U, {0,0,0},0},
            {"city trees a", "environment/procedural_city_trees_a.glb", data::packDataId(ModernEnvironmentLogicalGroup,13), ModernEnvironmentNodeBase|14U, {0,0,0},0},
            {"city trees b", "environment/procedural_city_trees_b.glb", data::packDataId(ModernEnvironmentLogicalGroup,14), ModernEnvironmentNodeBase|15U, {0,0,0},0},
            {"city trees c", "environment/procedural_city_trees_c.glb", data::packDataId(ModernEnvironmentLogicalGroup,15), ModernEnvironmentNodeBase|16U, {0,0,0},0},
            {"city trees d", "environment/procedural_city_trees_d.glb", data::packDataId(ModernEnvironmentLogicalGroup,16), ModernEnvironmentNodeBase|17U, {0,0,0},0},
            {"city people and vehicles", "environment/procedural_city_people_vehicles.glb", data::packDataId(ModernEnvironmentLogicalGroup,17), ModernEnvironmentNodeBase|18U, {0,0,0},0},
            {"city prison", "environment/procedural_city_prison.glb", data::packDataId(ModernEnvironmentLogicalGroup,18), ModernEnvironmentNodeBase|19U, {0,0,0},0},
            {"city grand hotel", "environment/procedural_city_grand_hotel.glb", data::packDataId(ModernEnvironmentLogicalGroup,19), ModernEnvironmentNodeBase|20U, {0,0,0},0},
            {"city landmarks", "environment/procedural_city_landmarks.glb", data::packDataId(ModernEnvironmentLogicalGroup,20), ModernEnvironmentNodeBase|21U, {0,0,0},0},
            {"city red hotel", "environment/procedural_city_red_hotel.glb", data::packDataId(ModernEnvironmentLogicalGroup,21), ModernEnvironmentNodeBase|22U, {0,0,0},0}
        }};
        const ModernEnvironmentDefinition& definitionAt(std::size_t index)
        {
            if(index < Definitions.size()) return Definitions[index];
            index -= Definitions.size();
            return index < PresentationDefinitions.size() ? PresentationDefinitions[index] :
                CityDefinitions[index-PresentationDefinitions.size()];
        }
        constexpr float SourceUnitsPerMetre = 200.0F;
        constexpr float BoardOrigin = 2430.0F;
 
        bool validGeometry(const data::MeshRenderData& mesh) noexcept
        {
            if (mesh.vertices.empty() || mesh.indices.empty() || mesh.batches.empty() ||
                mesh.indices.size() % 3U != 0U) return false;
            for (std::size_t axis = 0; axis < 3; ++axis)
                if (!std::isfinite(mesh.bounds.minimum[axis]) ||
                    !std::isfinite(mesh.bounds.maximum[axis]) ||
                    mesh.bounds.minimum[axis] > mesh.bounds.maximum[axis]) return false;
            for (const auto& vertex : mesh.vertices)
                for (std::size_t axis = 0; axis < 3; ++axis)
                    if (!std::isfinite(vertex.position[axis]) ||
                        !std::isfinite(vertex.normal[axis])) return false;
            for (const auto index : mesh.indices)
                if (index >= mesh.vertices.size()) return false;
            for (const auto& batch : mesh.batches)
                if (batch.material.model != data::MeshMaterialModel::MetallicRoughness ||
                    !batch.indexCount || batch.indexCount % 3U != 0U ||
                    batch.firstIndex > mesh.indices.size() ||
                    batch.indexCount > mesh.indices.size() - batch.firstIndex) return false;
            return true;
        }
    }
 
    const std::array<ModernEnvironmentDefinition, ModernEnvironmentCount>&
        modernEnvironmentDefinitions() noexcept
    { return Definitions; }
 
    ModernEnvironment::ModernEnvironment(std::filesystem::path modernAssetsRoot,
        bool enabled, Diagnostic diagnostic, Loader loader)
        : root_(std::move(modernAssetsRoot)), enabled_(enabled),
          diagnostic_(std::move(diagnostic)), loader_(std::move(loader))
    {
        const auto hardware=std::thread::hardware_concurrency();
        decodeWorkers_=hardware ? std::clamp(hardware/2,1U,8U) : 4U;
        if (loader_) decodeWorkers_ = 1;
        else if (const auto* value = std::getenv("MONOPOLY_ENVIRONMENT_WORKERS"))
        {
            unsigned workers{};
            const std::string_view text{value};
            const auto parsed = std::from_chars(text.data(),text.data()+text.size(),workers);
            if (parsed.ec==std::errc{} && parsed.ptr==text.data()+text.size() &&
                (workers==1 || workers==4 || workers==8)) decodeWorkers_=workers;
        }
    }
 
    void ModernEnvironment::report(std::string_view message) const
    {
        if (diagnostic_) diagnostic_(message);
        else std::cerr << "Modern environment: " << message << '\n';
    }
 
    void ModernEnvironment::loadPending(const std::vector<std::size_t>& indices)
    {
        struct Result { std::shared_ptr<const data::MeshRuntimeAsset> asset; bool failed{}; std::string error; };
        std::vector<std::size_t> pending;
        for(const auto index:indices)
            if(!attempted_[index]) pending.push_back(index);
        if(pending.empty()) return;
        std::vector<Result> results(pending.size());
        // Complete bookkeeping allocations before recording any attempt.
        for(const auto index:pending) attempted_[index]=true;
        std::atomic<std::size_t> next{};
        const auto decode=[&]() noexcept
        {
            for(;;)
            {
                const auto slot=next.fetch_add(1,std::memory_order_relaxed);
                if(slot>=pending.size()) return;
                const auto& definition=definitionAt(pending[slot]);
                auto& result=results[slot];
                try
                {
                    data::ModernGltfLoadOptions options;
                    options.unitsPerMeter=SourceUnitsPerMetre;
                    options.yawDegrees=definition.localYawDegrees;
                    options.localOffset={};options.groundToZero=false;
                    const auto path=root_/definition.relativeGlbPath;
                    auto loaded=loader_ ? loader_(path,options) : data::loadModernGltfMesh(path,options);
                    if(!loaded || !*loaded || !validGeometry(**loaded))
                    {
                        result.failed=true;
                        result.error=std::string(definition.slug)+": skipped "+
                            (loaded ? "invalid native geometry" : loaded.error().detail);
                        continue;
                    }
                    auto asset=std::make_shared<data::MeshRuntimeAsset>();
                    asset->dataId=definition.logicalId;asset->origin=data::MeshAssetOrigin::ModernGltf;
                    asset->renderData=std::move(*loaded);result.asset=std::move(asset);
                }
                catch(const std::exception& exception)
                {
                    result.failed=true;
                    // Diagnostics are optional: even their allocation failure
                    // must never escape a worker and terminate the process.
                    try { result.error=std::string(definition.slug)+": skipped decode exception: "+exception.what(); }
                    catch(...) {}
                }
                catch(...)
                {
                    result.failed=true;
                    try { result.error=std::string(definition.slug)+": skipped unknown decode exception"; }
                    catch(...) {}
                }
            }
        };
        // Workers only write their isolated result slot. Maps, callbacks and
        // scene order publish on the calling thread after every worker joins.
        const auto workers=std::min<std::size_t>(decodeWorkers_,pending.size());
        std::vector<std::jthread> threads;
        try
        {
            threads.reserve(workers>0?workers-1:0);
            for(std::size_t worker=1;worker<workers;++worker) threads.emplace_back(decode);
        }
        catch(const std::exception&) { /* remaining work runs on caller */ }
        decode();threads.clear();
        for(std::size_t slot=0;slot<pending.size();++slot)
        {
            assets_[pending[slot]]=std::move(results[slot].asset);
            if(results[slot].failed)
                report(results[slot].error.empty() ? std::string_view{"skipped environment decode failure; diagnostic unavailable"} : std::string_view{results[slot].error});
        }
    }
 
    void ModernEnvironment::rejectGeometry(const data::MeshRenderData* geometry)
    {
        if (!geometry) return;
        bool dropped{};
        for (std::size_t index = 0; index < assets_.size(); ++index)
            if (assets_[index] && assets_[index]->renderData.get() == geometry)
            {
                assets_[index].reset();
                attempted_[index] = true;
                dropped = true;
            }
        if (dropped) report("dropped rejected native GPU geometry");
    }
 
    std::vector<sequence::SequenceMeshRenderItem> ModernEnvironment::items(
        const sequence::Matrix3D& boardMatrix, std::uint32_t tick, bool includePresentation,
        bool includeLandmarks, bool includeCity)
    {
        std::vector<sequence::SequenceMeshRenderItem> result;
        if (!enabled_) return result;
        if (!std::all_of(boardMatrix.values.begin(), boardMatrix.values.end(),
                [](float value) { return std::isfinite(value); }))
        {
            if (!invalidMatrixReported_)
            {
                invalidMatrixReported_ = true;
                report("skipped invalid board transform");
            }
            return result;
        }
        const auto count = Definitions.size() + PresentationDefinitions.size() +
            (includeCity ? CityDefinitions.size() : 0);
        result.reserve(count);
        std::vector<std::size_t> selected;
        for (std::size_t index = includeLandmarks ? 0 : Definitions.size(); index < count; ++index)
        {
            // Complete city groups include these three source landmarks in
            // their global placement, so never duplicate the local prototypes.
            if(includeCity && index < Definitions.size()) continue;
            if(index >= Definitions.size() && index < Definitions.size()+PresentationDefinitions.size() &&
                !includePresentation) continue;
            selected.push_back(index);
        }
        loadPending(selected);
        for (const auto index:selected)
        {
            if (!assets_[index]) continue;
            const auto& definition = definitionAt(index);
            const auto& position = definition.originalYup;
            const auto local = sequence::translate3D(
                BoardOrigin - position[2] * SourceUnitsPerMetre,
                position[1] * SourceUnitsPerMetre,
                BoardOrigin - position[0] * SourceUnitsPerMetre);
            sequence::SequenceMeshRenderItem item;
            item.node = definition.node;
            item.contentsDataId = definition.logicalId;
            // No retail sequence root owns these native scene items.
            item.rootSequenceDataId = data::EmptyDataId;
            item.priority = display::Board3DPriority;
            item.clock = static_cast<std::int32_t>(std::min(tick,
                static_cast<std::uint32_t>(std::numeric_limits<std::int32_t>::max())));
            // Row vectors: local placement precedes the actual board transform.
            // Reversing these operands would leave the 2430 origin unscaled.
            item.worldTransform = sequence::multiply(local, boardMatrix);
            item.asset = assets_[index];
            item.renderData = assets_[index]->renderData;
            result.push_back(std::move(item));
        }
        return result;
    }
}