EVEngine/RuntimeGeneration_8h_source.html

#pragma once


#include "procgen/PointDelta.h"


#include <cstdint>

#include <deque>

#include <functional>

#include <optional>

#include <string>

#include <thread>

#include <unordered_map>

#include <vector>


namespace eve::procgen {


class EVENGINE_API_DOMAINS ProcgenCellRequest {

public:

    int      getLevel() const;

    int      getX() const;

    int      getZ() const;

    uint32_t getSeed() const;

    uint64_t getTicket() const;

    float    getMinX() const;

    float    getMinZ() const;

    float    getMaxX() const;

    float    getMaxZ() const;


private:

    friend class RuntimeGeneration;

    int      level_    = 0;

    int      x_        = 0;

    int      z_        = 0;

    uint32_t seed_     = 1;

    uint64_t ticket_   = 0;

    uint64_t schedulerId_ = 0;

    float    cellSize_ = 1.f;

};


class EVENGINE_API_DOMAINS ProcgenGenerationJob {

public:

    int getLevel() const;

    int getX() const;

    int getZ() const;

    uint32_t getSeed() const;

    uint64_t getTicket() const;

    float getMinX() const;

    float getMinZ() const;

    float getMaxX() const;

    float getMaxZ() const;


private:

    friend class RuntimeGeneration;

    int      level_       = 0;

    int      x_           = 0;

    int      z_           = 0;

    uint32_t seed_        = 1;

    uint64_t ticket_      = 0;

    uint64_t schedulerId_ = 0;

    float    cellSize_    = 1.f;

};


class EVENGINE_API_DOMAINS ProcgenGenerationCompletion {

public:

    ProcgenGenerationCompletion(ProcgenGenerationJob job, PointSet output);


private:

    friend class RuntimeGeneration;

    ProcgenGenerationJob job_;

    PointSet             output_;

};


class EVENGINE_API_DOMAINS RuntimeGeneration {

public:

    explicit RuntimeGeneration(uint32_t worldSeed = 1);

    RuntimeGeneration(const RuntimeGeneration&)            = delete;

    RuntimeGeneration& operator=(const RuntimeGeneration&) = delete;

    RuntimeGeneration(RuntimeGeneration&&)                 = delete;

    RuntimeGeneration& operator=(RuntimeGeneration&&)      = delete;


    void clear();

    int addLevel(float cellSize, float generationRadius, float cleanupMultiplier);

    int getLevelCount() const;

    float getLevelCellSize(int level) const;

    float getLevelGenerationRadius(int level) const;

    float getLevelCleanupRadius(int level) const;


    void  setDirectionWeight(float weight);

    float getDirectionWeight() const;

    void setMaxGenerating(int count);

    int  getMaxGenerating() const;

    void setMaxActiveCells(int count);

    int getMaxActiveCells() const;

    void setMaxPointsPerCell(int count);

    int getMaxPointsPerCell() const;

    void setMaxResidentPoints(int count);

    int getMaxResidentPoints() const;

    int getResidentPointCount() const;

    int getRejectedOutputCount() const;

    int trimToResidentPoints(int target);

    void setMaxGenerationRetries(int count);

    int getMaxGenerationRetries() const;

    void  setFrameTimeBudget(float milliseconds);

    float getFrameTimeBudget() const;

    void beginFrame();

    void setRefreshWorkBudget(int candidateCells);

    int getRefreshWorkBudget() const;

    bool isRefreshPending() const;

    uint64_t getCommittedRefreshRevision() const;

    [[nodiscard]] Result<uint64_t> continueGenerationRefresh();


    void updateSource(float x, float z, float directionX, float directionZ);

    bool setGenerationSource(const std::string& id, float x, float z, float directionX,

                             float directionZ, float radiusScale = 1.f);

    bool removeGenerationSource(const std::string& id);

    void clearGenerationSources();

    int  getGenerationSourceCount() const;

    std::string getGenerationSourceId(int index) const;

    void refreshGenerationSources();


    void setFrustumCulling(bool enabled, float halfAngleDegrees, float behindRadius);

    bool  isFrustumCullingEnabled() const;

    float getFrustumHalfAngle() const;

    float getFrustumBehindRadius() const;


    int                 getPendingGenerateCount() const;

    int                 getGeneratingCount() const;

    int                 getActiveCellCount() const;

    int                 getPendingCleanupCount() const;

    int                 getCancelledGenerationCount() const;

    int                 getFailedCellCount() const;

    int                 retryFailedCells();

    [[nodiscard]] Result<std::optional<ProcgenGenerationJob>> nextGenerationJob();

    [[nodiscard]] Result<uint64_t> completeGenerationJob(ProcgenGenerationCompletion completion);

    [[nodiscard]] Result<void> failGenerationJob(const ProcgenGenerationJob& job);

    [[nodiscard]] Result<std::optional<ProcgenCellRequest>> nextCleanupRequest();

    [[nodiscard]] Result<uint64_t> completeCleanupRequest(const ProcgenCellRequest& request);

    bool isOwnerThread() const noexcept;


    ProcgenCellRequest* nextGenerate();

    ProcgenCellRequest* nextCleanup();

    bool isRequestCurrent(const ProcgenCellRequest* request) const;

    bool completeGeneration(ProcgenCellRequest* request, PointSet* output);

    bool failGeneration(ProcgenCellRequest* request);

    bool completeCleanup(ProcgenCellRequest* request);

    [[nodiscard]] Result<uint64_t> completeCleanupsAtomic(const std::vector<const ProcgenCellRequest*>& requests);


    bool      hasCell(int level, int x, int z) const;

    PointSet* getCellOutput(int level, int x, int z) const;

    uint64_t  getCellRevision(int level, int x, int z) const;

    [[nodiscard]] Result<uint64_t> applyCellUpdate(int level, int x, int z, uint64_t expectedRevision,

                                                   const PointSet& output);

    [[nodiscard]] Result<uint64_t> migrateCellPointIds(int level, int x, int z, uint64_t expectedRevision);

    PointDelta* getCellDelta(int level, int x, int z) const;

    std::string serializeCell(int level, int x, int z) const;

    bool deserializeCell(const std::string& definition);

    std::string debugReport() const;


private:

    friend class Procgen;


    struct Level {

        float cellSize        = 1.f;

        float generationRadius = 1.f;

        float cleanupRadius    = 1.f;

    };

    enum class State { Pending, Generating, Active, Cleanup, Failed };

    struct CellKey {

        int level = 0;

        int x     = 0;

        int z     = 0;

        bool operator==(const CellKey& other) const {

            return level == other.level && x == other.x && z == other.z;

        }

    };

    struct CellKeyHash {

        size_t operator()(const CellKey& key) const;

    };

    struct Cell {

        State    state    = State::Pending;

        float    priority = 0.f;

        uint64_t revision = 0;

        uint64_t ticket   = 0;

        int      failures = 0;

        bool     trimmed  = false;

        PointSet output;

        PointDelta delta;

        bool       hasDelta = false;

    };

    struct Source {

        float x           = 0.f;

        float z           = 0.f;

        float directionX  = 0.f;

        float directionZ  = 0.f;

        float radiusScale = 1.f;

    };

    struct RefreshPlan {

        uint64_t                                        revision = 0;

        std::vector<Level>                              levels;

        std::vector<Source>                             sources;

        std::unordered_map<CellKey, float, CellKeyHash> desiredPriorities;

        float                                           directionWeight     = 0.f;

        float                                           frustumHalfAngle    = 180.f;

        float                                           coneCosine          = -1.f;

        float                                           frustumBehindRadius = 0.f;

        bool                                            frustumCulling      = false;

        size_t                                          sourceIndex         = 0;

        size_t                                          levelIndex          = 0;

        int                                             minX                = 0;

        int                                             maxX                = -1;

        int                                             minZ                = 0;

        int                                             maxZ                = -1;

        int                                             cellX               = 0;

        int                                             cellZ               = 0;

        bool                                            rangeReady          = false;

    };


    ProcgenCellRequest                                 makeRequest(const CellKey& key) const;

    ProcgenGenerationJob                               makeGenerationJob(const CellKey& key) const;

    std::optional<ProcgenGenerationJob>                issueGenerationJob();

    [[nodiscard]] Result<std::reference_wrapper<Cell>> validateGenerationJob(const ProcgenGenerationJob& job);

    void                       transitionCellState(Cell& cell, State nextState);

    void                       requestGenerationRefresh();

    void                       startRefreshPlan();

    uint64_t                   advanceRefreshPlan(uint64_t candidateBudget);

    void                       commitRefreshPlan(const RefreshPlan& plan);

    [[nodiscard]] Result<void> validateCleanups(const std::vector<const ProcgenCellRequest*>& requests) const;

    void                       eraseValidatedCleanups(const std::vector<const ProcgenCellRequest*>& requests);

    uint32_t            cellSeed(const CellKey& key) const;

    void                sortQueues();


    uint32_t worldSeed_       = 1;

    std::thread::id                                ownerThread_;

    const uint64_t                                 schedulerId_;

    float    directionWeight_ = 0.25f;

    int      maxGenerating_   = 4;

    int      maxActiveCells_  = 0;

    int      maxPointsPerCell_      = 0;

    int      maxResidentPoints_     = 0;

    int      rejectedOutputCount_   = 0;

    int      cancelledGenerationCount_ = 0;

    int      maxGenerationRetries_ = 3;

    float    frameTimeBudgetMs_ = 0.f;

    uint64_t frameStartedNs_    = 0;

    int                                            refreshWorkBudget_        = 0;

    uint64_t                                       sourceRevision_           = 0;

    uint64_t                                       committedRefreshRevision_ = 0;

    std::optional<RefreshPlan>                     refreshPlan_;

    bool     frustumCulling_    = false;

    float    frustumHalfAngle_  = 60.f;

    float    frustumBehindRadius_ = 0.f;

    std::vector<Level> levels_;

    std::unordered_map<std::string, Source> sources_;

    std::vector<std::string> sourceOrder_;

    std::unordered_map<CellKey, Cell, CellKeyHash> cells_;

    std::deque<CellKey>                            generateQueue_;

    std::deque<CellKey>                            cleanupQueue_;

    int                                            generatingCount_ = 0;

    int                                            activeCellCount_ = 0;

    uint64_t             nextTicket_ = 0;

};


}  // namespace eve::procgen

target
LogicalId target
Definition ActionNotifyRegistry.cpp:151

state
bool state
Definition ActionTimelineWidget.cpp:33

x
float x
Definition AnimClip.cpp:738

z
float z
Definition AnimClip.cpp:738

output
std::string output
Definition AssetCommand.cpp:161

priority
int priority
Definition Capability.cpp:15

EVENGINE_API_DOMAINS
#define EVENGINE_API_DOMAINS
Definition Export.h:110

request
const GltfImportRequest & request
Definition GltfMaterials.cpp:31

key
std::uint32_t key
Definition GraphicsParticles.cpp:68

level
int level
Definition ModuleAssembly.cpp:22

milliseconds
double & milliseconds
Definition OnnxGpgpu.cpp:19

revision
std::uint64_t revision
Definition PixelWorld.cpp:62

PointDelta.h

count
std::uint32_t count
Definition SourceTiff.cpp:24

cell
Cell cell
Definition TacticsPath.cpp:15

definition
LogicalId definition
Definition TacticsPersistence.cpp:145

weight
double weight
Definition UnityVegetationMaterial.cpp:164

index
uint32_t index
Definition UnityVegetationMaterial.cpp:163

eve::Result
Move-only operation result carrying either a value or Status.
Definition Result.h:155

eve::procgen::PointSet
Script-friendly collection of attributed 3D samples.
Definition PointSet.h:59

eve::procgen::ProcgenCellRequest
One immutable runtime-generation cell request returned to script.
Definition RuntimeGeneration.h:17

eve::procgen::ProcgenGenerationCompletion
Owning worker result returned to a RuntimeGeneration scheduler.
Definition RuntimeGeneration.h:88

eve::procgen::ProcgenGenerationJob
Copyable generation input issued by one RuntimeGeneration scheduler.
Definition RuntimeGeneration.h:55

eve::procgen::Procgen
Procedural generation module. Phase A: runtime maps (semantic Grid2D → TileLayer)....
Definition Procgen.h:146

eve::procgen::RuntimeGeneration
View-driven partition and hierarchical procedural generation scheduler.
Definition RuntimeGeneration.h:115

eve::procgen::RuntimeGeneration::operator=
RuntimeGeneration & operator=(RuntimeGeneration &&)=delete

eve::procgen::RuntimeGeneration::operator=
RuntimeGeneration & operator=(const RuntimeGeneration &)=delete

eve::procgen::RuntimeGeneration::RuntimeGeneration
RuntimeGeneration(RuntimeGeneration &&)=delete

eve::procgen::RuntimeGeneration::RuntimeGeneration
RuntimeGeneration(const RuntimeGeneration &)=delete

eve::action::ActionSpatialTarget::Source
@ Source

eve::artifact::PartKind::PointSet
@ PointSet

eve::hexmap::HexSearchPop::Cell
@ Cell
A cell was removed; the out-parameter holds it.

eve::procgen
Definition EvpackPointGraphLoader.h:12

eve::transaction::State
State
Lifecycle state of a generic transaction plan.
Definition Transaction.h:207

eve::DiagnosticCode::Failed
@ Failed

eve::StatusCode::Pending
@ Pending

std
Definition Container.h:602

enabled
bool enabled
Definition Settlement.cpp:31

eve::procgen::PointDelta
Transactional identity-based change set between two point snapshots.
Definition PointDelta.h:16