EVEngine/Procgen_8h_source.html

#pragma once

#include "common/Export.h"


#include "common/Module.h"

#include "common/SquirrelOwnership.h"

#include "procgen/Biome.h"

#include "procgen/Grid2D.h"

#include "procgen/GridGraph.h"

#include "procgen/MeshBuild.h"

#include "procgen/MeshGraph.h"

#include "procgen/OutputSpec.h"

#include "procgen/Palette.h"

#include "procgen/ParamSchema.h"

#include "procgen/Params.h"

#include "procgen/PointGraph.h"

#include "procgen/PointSet.h"

#include "procgen/ProcgenSystem.h"

#include "procgen/RuntimeGeneration.h"

#include "procgen/ShapeGrammar.h"

#include "procgen/SpatialData.h"

#include "procgen/algorithms/LSystem.h"

#include "procgen/core/ProcgenCore.h"

#include "procgen/heightmap/Heightmap.h"

#include "procgen/heightmap/TerrainMesh.h"

#include "procgen/mesh/MeshModifierGraph.h"

#include "procgen/mesh/MeshDeformationSession.h"

#include "procgen/mesh/DynamicMeshUvPaintSession.h"

#include "procgen/spline/SplinePath.h"

#include "procgen/heightmap/TerrainPipeline.h"

#include "procgen/heightmap/TerrainSampler.h"

#include "procgen/texture/CloudField.h"

#include "procgen/texture/CloudShadow.h"


#include <memory>

#include <span>

#include <string>

#include <unordered_map>

#include <vector>


namespace eve::graphics {

class Graphics;

class Texture;

class Mesh;

class Shader;

class Renderable3D;

}  // namespace eve::graphics


namespace eve::image {

class ImageData;

}  // namespace eve::image


namespace eve::data {

class ByteData;

}  // namespace eve::data


namespace eve::procgen {

struct PbrTextureSet;

class GtsTerrainLodSet;

class PcgMeshLodSet;


struct ProcgenParamsHandleTag {};

struct ProcgenGridHandleTag {};

struct ProcgenContextHandleTag {};

struct ProcgenOutputHandleTag {};

struct ProcgenPointSetHandleTag {};

struct ProcgenTerrainSamplerHandleTag {};

struct ProcgenHeightmapHandleTag {};

struct ProcgenCloudFieldHandleTag {};

struct ProcgenCloudShadowHandleTag {};

struct ProcgenPbrMaterialHandleTag {};

struct ProcgenMeshBuildHandleTag {};

struct ProcgenImageHandleTag {};

struct ProcgenNormalImageHandleTag {};

struct ProcgenSpatialDataHandleTag {};

struct ProcgenRuntimeGenerationHandleTag {};

struct ProcgenPointGraphHandleTag {};

struct ProcgenMeshModifierGraphHandleTag {};

struct ProcgenMeshDeformationSessionHandleTag {};

struct ProcgenDynamicMeshUvPaintSessionHandleTag {};

struct ProcgenSplinePathHandleTag {};

struct ProcgenGridGraphHandleTag {};

struct ProcgenMeshGraphHandleTag {};

struct ProcgenBiomeRulesHandleTag {};

struct ProcgenShapeGrammarHandleTag {};

struct ProcgenLSystemHandleTag {};

using ProcgenParamsHandleRef            = eve::script::RuntimeHandleRef<ProcgenParamsHandleTag>;

using ProcgenGridHandleRef              = eve::script::RuntimeHandleRef<ProcgenGridHandleTag>;

using ProcgenContextHandleRef           = eve::script::RuntimeHandleRef<ProcgenContextHandleTag>;

using ProcgenOutputHandleRef            = eve::script::RuntimeHandleRef<ProcgenOutputHandleTag>;

using ProcgenPointSetHandleRef          = eve::script::RuntimeHandleRef<ProcgenPointSetHandleTag>;

using ProcgenTerrainSamplerHandleRef    = eve::script::RuntimeHandleRef<ProcgenTerrainSamplerHandleTag>;

using ProcgenHeightmapHandleRef         = eve::script::RuntimeHandleRef<ProcgenHeightmapHandleTag>;

using ProcgenCloudFieldHandleRef        = eve::script::RuntimeHandleRef<ProcgenCloudFieldHandleTag>;

using ProcgenCloudShadowHandleRef       = eve::script::RuntimeHandleRef<ProcgenCloudShadowHandleTag>;

using ProcgenPbrMaterialHandleRef       = eve::script::RuntimeHandleRef<ProcgenPbrMaterialHandleTag>;

using ProcgenMeshBuildHandleRef         = eve::script::RuntimeHandleRef<ProcgenMeshBuildHandleTag>;

using ProcgenImageHandleRef             = eve::script::RuntimeHandleRef<ProcgenImageHandleTag>;

using ProcgenNormalImageHandleRef       = eve::script::RuntimeHandleRef<ProcgenNormalImageHandleTag>;

using ProcgenSpatialDataHandleRef       = eve::script::RuntimeHandleRef<ProcgenSpatialDataHandleTag>;

using ProcgenRuntimeGenerationHandleRef = eve::script::RuntimeHandleRef<ProcgenRuntimeGenerationHandleTag>;

using ProcgenPointGraphHandleRef        = eve::script::RuntimeHandleRef<ProcgenPointGraphHandleTag>;

using ProcgenMeshModifierGraphHandleRef = eve::script::RuntimeHandleRef<ProcgenMeshModifierGraphHandleTag>;

using ProcgenMeshDeformationSessionHandleRef = eve::script::RuntimeHandleRef<ProcgenMeshDeformationSessionHandleTag>;

using ProcgenDynamicMeshUvPaintSessionHandleRef =

    eve::script::RuntimeHandleRef<ProcgenDynamicMeshUvPaintSessionHandleTag>;

using ProcgenSplinePathHandleRef = eve::script::RuntimeHandleRef<ProcgenSplinePathHandleTag>;

using ProcgenGridGraphHandleRef         = eve::script::RuntimeHandleRef<ProcgenGridGraphHandleTag>;

using ProcgenMeshGraphHandleRef         = eve::script::RuntimeHandleRef<ProcgenMeshGraphHandleTag>;

using ProcgenBiomeRulesHandleRef        = eve::script::RuntimeHandleRef<ProcgenBiomeRulesHandleTag>;

using ProcgenShapeGrammarHandleRef      = eve::script::RuntimeHandleRef<ProcgenShapeGrammarHandleTag>;

using ProcgenLSystemHandleRef           = eve::script::RuntimeHandleRef<ProcgenLSystemHandleTag>;


class EVENGINE_API_DOMAINS Procgen : public Module {

public:

    Module_REG(Procgen);

    Procgen();

    ~Procgen() override;


    [[nodiscard]] static eve::Result<ProcgenParamsHandleRef> newParamsHandle();

    [[nodiscard]] static eve::script::Borrowed<Params> resolve(ProcgenParamsHandleRef reference) noexcept;

    [[nodiscard]] static eve::Result<void> release(ProcgenParamsHandleRef reference);

    [[nodiscard]] static bool isStale(ProcgenParamsHandleRef reference) noexcept;

    [[nodiscard]] eve::Result<ProcgenOutputHandleRef> newOutputHandle();

    [[nodiscard]] eve::script::Borrowed<OutputSpec> resolveOutput(ProcgenOutputHandleRef reference) noexcept;

    [[nodiscard]] eve::Result<void> releaseOutput(ProcgenOutputHandleRef reference);

    [[nodiscard]] bool isOutputStale(ProcgenOutputHandleRef reference) const noexcept;

    [[nodiscard]] static eve::Result<ProcgenGridHandleRef> newGridHandle(int width, int height);

    [[nodiscard]] static eve::script::Borrowed<Grid2D> resolve(ProcgenGridHandleRef reference) noexcept;

    [[nodiscard]] static eve::Result<void> release(ProcgenGridHandleRef reference);

    [[nodiscard]] static bool isStale(ProcgenGridHandleRef reference) noexcept;


    // --- Script-first point pipelines ---

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> newPointSetHandle();

    [[nodiscard]] eve::script::Borrowed<PointSet> resolvePointSet(ProcgenPointSetHandleRef reference) noexcept;

    [[nodiscard]] eve::Result<void> releasePointSet(ProcgenPointSetHandleRef reference);

    [[nodiscard]] bool isPointSetStale(ProcgenPointSetHandleRef reference) const noexcept;

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> sampleGridHandle(int width, int depth, float spacing,

                                                                         uint32_t seed, float jitter);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> filterHeightHandle(ProcgenPointSetHandleRef input,

                                                                           float minHeight, float maxHeight);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> filterDensityHandle(ProcgenPointSetHandleRef input,

                                                                            float minDensity, float maxDensity);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> filterBoxHandle(ProcgenPointSetHandleRef input, float minX,

                                                                        float minY, float minZ, float maxX, float maxY,

                                                                        float maxZ, bool invert = false);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> filterSlopeHandle(ProcgenPointSetHandleRef input,

                                                                          float minDegrees, float maxDegrees);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> filterPolygonHandle(ProcgenPointSetHandleRef input,

                                                                            ProcgenPointSetHandleRef polygon,

                                                                            bool                     invert = false);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> filterSplineDistanceHandle(

        ProcgenPointSetHandleRef input, ProcgenPointSetHandleRef controlPoints, float minDistance, float maxDistance);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> excludeRadiusHandle(ProcgenPointSetHandleRef input, float x,

                                                                            float z, float radius);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> jitterPointsHandle(ProcgenPointSetHandleRef input,

                                                                           uint32_t seed, float amountX, float amountZ);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> selfPruneHandle(ProcgenPointSetHandleRef input, float radius);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> projectToHeightmapHandle(ProcgenPointSetHandleRef  input,

                                                                                 ProcgenHeightmapHandleRef heightmap,

                                                                                 float originX, float originZ,

                                                                                 float cellSize, float heightScale);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> sampleSplineHandle(ProcgenPointSetHandleRef controlPoints,

                                                                           float spacing, uint32_t seed,

                                                                           float lateralJitter);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> poissonDiskHandle(int width, int depth, float radius,

                                                                          uint32_t seed, int maxPoints);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> mergePointsHandle(ProcgenPointSetHandleRef first,

                                                                          ProcgenPointSetHandleRef second);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> unionPointsHandle(ProcgenPointSetHandleRef first,

                                                                          ProcgenPointSetHandleRef second);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> intersectPointsHandle(ProcgenPointSetHandleRef first,

                                                                              ProcgenPointSetHandleRef second);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> differencePointsHandle(ProcgenPointSetHandleRef first,

                                                                               ProcgenPointSetHandleRef second);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> transformPointsHandle(ProcgenPointSetHandleRef input,

                                                                              float translateX, float translateY,

                                                                              float translateZ, float yawDegrees,

                                                                              float scaleX, float scaleY, float scaleZ);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> transformPoints3DHandle(

        ProcgenPointSetHandleRef input, float translateX, float translateY, float translateZ, float pitchDegrees,

        float yawDegrees, float rollDegrees, float scaleX, float scaleY, float scaleZ);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> copyPointsHandle(ProcgenPointSetHandleRef source,

                                                                         ProcgenPointSetHandleRef targets,

                                                                         bool inheritTargetAttributes);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> remapDensityHandle(ProcgenPointSetHandleRef input,

                                                                           float inputMin, float inputMax,

                                                                           float outputMin, float outputMax,

                                                                           bool clampOutput);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> mathFloatAttributeHandle(ProcgenPointSetHandleRef input,

                                                                                 const std::string&       attribute,

                                                                                 const std::string& outputAttribute,

                                                                                 const std::string& operation,

                                                                                 float operand, float defaultValue);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> filterFloatAttributeHandle(ProcgenPointSetHandleRef input,

                                                                                   const std::string&       name,

                                                                                   float minValue, float maxValue,

                                                                                   bool invert);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> filterStringAttributeHandle(ProcgenPointSetHandleRef input,

                                                                                    const std::string&       name,

                                                                                    const std::string&       value,

                                                                                    bool                     invert);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> excludeGridMaskHandle(

        ProcgenPointSetHandleRef input, ProcgenGridHandleRef mask, float originX, float originZ, float cellSize,

        int semantic, float clearance, int maximumChecks);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> densityCullHandle(ProcgenPointSetHandleRef input, uint32_t seed,

                                                                          float multiplier);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> projectToWorldHandle(ProcgenPointSetHandleRef input, float maxY,

                                                                             float minY, std::uint64_t maskBits,

                                                                             bool keepUnmatched);


    // --- Spatial data and composable PCG domains ---

    [[nodiscard]] eve::Result<ProcgenSpatialDataHandleRef> pointDataHandle(ProcgenPointSetHandleRef points);

    [[nodiscard]] eve::Result<ProcgenSpatialDataHandleRef> boxVolumeHandle(float minX, float minY, float minZ,

                                                                           float maxX, float maxY, float maxZ);

    [[nodiscard]] eve::Result<ProcgenSpatialDataHandleRef> sphereVolumeHandle(float x, float y, float z, float radius);

    [[nodiscard]] eve::Result<ProcgenSpatialDataHandleRef> polygonVolumeHandle(ProcgenPointSetHandleRef controlPoints,

                                                                               float minY, float maxY);

    [[nodiscard]] eve::Result<ProcgenSpatialDataHandleRef> splineDataHandle(ProcgenPointSetHandleRef controlPoints,

                                                                            float                    radius);

    [[nodiscard]] eve::Result<ProcgenSpatialDataHandleRef> heightfieldDataHandle(ProcgenHeightmapHandleRef heightmap,

                                                                                 float originX, float originZ,

                                                                                 float cellSize, float heightScale);

    [[nodiscard]] eve::Result<ProcgenSpatialDataHandleRef> textureMaskDataHandle(ProcgenHeightmapHandleRef values,

                                                                                 float originX, float originZ,

                                                                                 float cellSize, float minValue,

                                                                                 float maxValue, float minY,

                                                                                 float maxY);

    [[nodiscard]] eve::Result<ProcgenSpatialDataHandleRef> meshSurfaceDataHandle(ProcgenMeshBuildHandleRef mesh,

                                                                                 float                     tolerance);

    [[nodiscard]] eve::Result<ProcgenSpatialDataHandleRef> unionSpatialHandle(ProcgenSpatialDataHandleRef left,

                                                                              ProcgenSpatialDataHandleRef right);

    [[nodiscard]] eve::Result<ProcgenSpatialDataHandleRef> intersectSpatialHandle(ProcgenSpatialDataHandleRef left,

                                                                                  ProcgenSpatialDataHandleRef right);

    [[nodiscard]] eve::Result<ProcgenSpatialDataHandleRef> differenceSpatialHandle(ProcgenSpatialDataHandleRef left,

                                                                                   ProcgenSpatialDataHandleRef right);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> sampleSpatialHandle(ProcgenSpatialDataHandleRef spatial,

                                                                            float spacing, uint32_t seed, float jitter);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> filterSpatialHandle(ProcgenPointSetHandleRef    input,

                                                                            ProcgenSpatialDataHandleRef spatial,

                                                                            bool                        invert);

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> projectToSpatialHandle(ProcgenPointSetHandleRef    input,

                                                                               ProcgenSpatialDataHandleRef spatial);


    [[nodiscard]] eve::Result<ProcgenRuntimeGenerationHandleRef> newRuntimeGenerationHandle(uint32_t worldSeed);

    [[nodiscard]] eve::Result<ProcgenPointGraphHandleRef>        newPointGraphHandle();

    [[nodiscard]] eve::Result<ProcgenMeshModifierGraphHandleRef> newMeshModifierGraphHandle();

    [[nodiscard]] eve::Result<ProcgenMeshDeformationSessionHandleRef> newMeshDeformationSessionHandle();

    [[nodiscard]] eve::Result<ProcgenDynamicMeshUvPaintSessionHandleRef> newDynamicMeshUvPaintSessionHandle();

    [[nodiscard]] eve::Result<ProcgenSplinePathHandleRef> newSplinePathHandle();

    [[nodiscard]] eve::Result<ProcgenGridGraphHandleRef>         newGridGraphHandle();

    [[nodiscard]] eve::Result<ProcgenMeshGraphHandleRef>         newMeshGraphHandle();

    [[nodiscard]] eve::Result<ProcgenBiomeRulesHandleRef>        newBiomeRulesHandle();

    [[nodiscard]] eve::Result<ProcgenShapeGrammarHandleRef>      newShapeGrammarHandle();

    [[nodiscard]] eve::Result<ProcgenLSystemHandleRef>           newLSystemHandle();

    [[nodiscard]] eve::script::Borrowed<SpatialData> resolveSpatialData(ProcgenSpatialDataHandleRef reference) noexcept;

    [[nodiscard]] eve::script::Borrowed<RuntimeGeneration> resolveRuntimeGeneration(

        ProcgenRuntimeGenerationHandleRef reference) noexcept;

    [[nodiscard]] eve::script::Borrowed<PointGraph>   resolvePointGraph(ProcgenPointGraphHandleRef reference) noexcept;

    [[nodiscard]] eve::script::Borrowed<MeshModifierGraph> resolveMeshModifierGraph(

        ProcgenMeshModifierGraphHandleRef reference) noexcept;

    [[nodiscard]] eve::script::Borrowed<MeshDeformationSession> resolveMeshDeformationSession(

        ProcgenMeshDeformationSessionHandleRef reference) noexcept;

    [[nodiscard]] eve::script::Borrowed<DynamicMeshUvPaintSession> resolveDynamicMeshUvPaintSession(

        ProcgenDynamicMeshUvPaintSessionHandleRef reference) noexcept;

    [[nodiscard]] eve::script::Borrowed<SplinePath> resolveSplinePath(ProcgenSplinePathHandleRef reference) noexcept;

    [[nodiscard]] eve::script::Borrowed<GridGraph>    resolveGridGraph(ProcgenGridGraphHandleRef reference) noexcept;

    [[nodiscard]] eve::script::Borrowed<MeshGraph>    resolveMeshGraph(ProcgenMeshGraphHandleRef reference) noexcept;

    [[nodiscard]] eve::script::Borrowed<BiomeRules>   resolveBiomeRules(ProcgenBiomeRulesHandleRef reference) noexcept;

    [[nodiscard]] eve::script::Borrowed<ShapeGrammar> resolveShapeGrammar(

        ProcgenShapeGrammarHandleRef reference) noexcept;

    [[nodiscard]] eve::script::Borrowed<LSystem> resolveLSystem(ProcgenLSystemHandleRef reference) noexcept;

    [[nodiscard]] eve::Result<void>              release(ProcgenSpatialDataHandleRef reference);

    [[nodiscard]] eve::Result<void>              release(ProcgenRuntimeGenerationHandleRef reference);

    [[nodiscard]] eve::Result<void>              release(ProcgenPointGraphHandleRef reference);

    [[nodiscard]] eve::Result<void> release(ProcgenMeshModifierGraphHandleRef reference);

    [[nodiscard]] eve::Result<void> release(ProcgenMeshDeformationSessionHandleRef reference);

    [[nodiscard]] eve::Result<void> release(ProcgenDynamicMeshUvPaintSessionHandleRef reference);

    [[nodiscard]] eve::Result<void> release(ProcgenSplinePathHandleRef reference);

    [[nodiscard]] eve::Result<void>              release(ProcgenGridGraphHandleRef reference);

    [[nodiscard]] eve::Result<void>              release(ProcgenMeshGraphHandleRef reference);

    [[nodiscard]] eve::Result<void>              release(ProcgenBiomeRulesHandleRef reference);

    [[nodiscard]] eve::Result<void>              release(ProcgenShapeGrammarHandleRef reference);

    [[nodiscard]] eve::Result<void>              release(ProcgenLSystemHandleRef reference);

    [[nodiscard]] bool                           isStale(ProcgenSpatialDataHandleRef reference) const noexcept;

    [[nodiscard]] bool                           isStale(ProcgenRuntimeGenerationHandleRef reference) const noexcept;

    [[nodiscard]] bool                           isStale(ProcgenPointGraphHandleRef reference) const noexcept;

    [[nodiscard]] bool isStale(ProcgenMeshModifierGraphHandleRef reference) const noexcept;

    [[nodiscard]] bool isStale(ProcgenMeshDeformationSessionHandleRef reference) const noexcept;

    [[nodiscard]] bool isStale(ProcgenDynamicMeshUvPaintSessionHandleRef reference) const noexcept;

    [[nodiscard]] bool isStale(ProcgenSplinePathHandleRef reference) const noexcept;

    [[nodiscard]] bool                           isStale(ProcgenGridGraphHandleRef reference) const noexcept;

    [[nodiscard]] bool                           isStale(ProcgenMeshGraphHandleRef reference) const noexcept;

    [[nodiscard]] bool                           isStale(ProcgenBiomeRulesHandleRef reference) const noexcept;

    [[nodiscard]] bool                           isStale(ProcgenShapeGrammarHandleRef reference) const noexcept;

    [[nodiscard]] bool                           isStale(ProcgenLSystemHandleRef reference) const noexcept;


    [[nodiscard]] eve::Result<void> publishInstances(const std::string& batchId, ProcgenPointSetHandleRef points,

                                                     const std::string& assetAttribute,

                                                     const std::string& defaultAsset);

    [[nodiscard]] eve::Result<void> removeInstances(const std::string& batchId);

    [[nodiscard]] eve::Result<void> publishCellInstances(const std::string& prefix, const ProcgenCellRequest& request,

                                                         ProcgenPointSetHandleRef points,

                                                         const std::string&       assetAttribute,

                                                         const std::string&       defaultAsset);

    [[nodiscard]] eve::Result<uint64_t> publishCellSnapshot(const std::string&        prefix,

                                                            const ProcgenCellRequest& request,

                                                            ProcgenPointSetHandleRef points, uint64_t targetRevision,

                                                            const std::string& assetAttribute,

                                                            const std::string& defaultAsset);

    [[nodiscard]] eve::Result<uint64_t> publishCellInstanceDelta(const std::string&        prefix,

                                                                 const ProcgenCellRequest& request,

                                                                 const PointDelta& delta, uint64_t targetRevision,

                                                                 const std::string& assetAttribute,

                                                                 const std::string& defaultAsset);

    [[nodiscard]] eve::Result<uint64_t> synchronizeCellInstances(const std::string&        prefix,

                                                                 const RuntimeGeneration&  runtime,

                                                                 const ProcgenCellRequest& request,

                                                                 const std::string&        assetAttribute,

                                                                 const std::string&        defaultAsset);

    [[nodiscard]] eve::Result<uint64_t> synchronizeCellInstancesAtomic(

        const std::string& prefix, const std::vector<const RuntimeGeneration*>& runtimes,

        const std::vector<const ProcgenCellRequest*>& requests, const std::string& assetAttribute,

        const std::string& defaultAsset);

    [[nodiscard]] eve::Result<void> removeCellInstances(const std::string& prefix, const ProcgenCellRequest& request);

    [[nodiscard]] eve::Result<uint64_t> removeCellInstancesAtomic(

        const std::string& prefix, const std::vector<const ProcgenCellRequest*>& requests);

    [[nodiscard]] eve::Result<uint64_t> completeCellCleanupAtomic(

        const std::string& prefix, const std::vector<RuntimeGeneration*>& runtimes,

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

    int      getPublishedInstanceCount(const std::string& batchId) const;

    int      getPublishedCreatedCount(const std::string& batchId) const;

    int      getPublishedReusedCount(const std::string& batchId) const;

    int      getPublishedRemovedCount(const std::string& batchId) const;

    uint32_t deriveSeed(uint32_t parent, const std::string& scope) const;


    // --- Atomic script rebuilds ---

    [[nodiscard]] static eve::Result<ProcgenContextHandleRef> beginSystemHandle(const std::string& name, uint32_t seed);

    [[nodiscard]] static eve::Result<ProcgenContextHandleRef> beginCachedSystemHandle(const std::string& name,

                                                                                      uint32_t           seed,

                                                                                      const std::string& buildKey);

    [[nodiscard]] static eve::script::Borrowed<ProcgenContext> resolve(ProcgenContextHandleRef reference) noexcept;

    [[nodiscard]] static eve::Result<void> release(ProcgenContextHandleRef reference);

    [[nodiscard]] static bool       isStale(ProcgenContextHandleRef reference) noexcept;

    [[nodiscard]] eve::Result<void> commitSystem(ProcgenContextHandleRef context);

    [[nodiscard]] eve::Result<void> abortSystem(ProcgenContextHandleRef context);

    [[nodiscard]] eve::Result<void> removeSystem(const std::string& name);

    bool                            hasSystem(const std::string& name) const;

    uint64_t                        getSystemRevision(const std::string& name) const;

    uint32_t                        getSystemSeed(const std::string& name) const;

    std::string                     getSystemBuildKey(const std::string& name) const;

    int                             getSystemOutputCount(const std::string& name) const;

    std::string                     getSystemOutputName(const std::string& name, int index) const;

    int                             getSystemDebugStageCount(const std::string& name) const;

    std::string                     getSystemDebugStageName(const std::string& name, int index) const;

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> getSystemOutputHandle(const std::string& name,

                                                                              const std::string& outputName) const;

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> getSystemDebugStageHandle(const std::string& name,

                                                                                  const std::string& stageName) const;

    [[nodiscard]] eve::Result<ProcgenPointSetHandleRef> getPreviousSystemDebugStageHandle(

        const std::string& name, const std::string& stageName) const;

    uint64_t    getPreviousSystemRevision(const std::string& name) const;

    std::string getSystemDebugReport(const std::string& name) const;

    std::string getSystemDebugDiffReport(const std::string& name) const;


    // --- Phase A: maps ---

    [[nodiscard]] eve::Result<ProcgenGridHandleRef> generateHandle(const std::string&     algorithmId,

                                                                   ProcgenParamsHandleRef params);

    [[nodiscard]] eve::Result<void> generateTo(const std::string& algorithmId, ProcgenParamsHandleRef params,

                                               ProcgenOutputHandleRef output);

    [[nodiscard]] eve::Result<void> applyToLayer(ProcgenGridHandleRef grid, const std::string& palette,

                                                 map::TileLayer& layer);


    void setPaletteGid(const std::string& palette, const std::string& semantic, int gid);

    int  getPaletteGid(const std::string& palette, const std::string& semantic) const;


    int         getAlgorithmCount() const;

    std::string getAlgorithmId(int index) const;

    bool        hasAlgorithm(const std::string& algorithmId) const;

    [[nodiscard]] eve::Result<RecipeDescriptor> getAlgorithmSchema(const std::string& algorithmId) const;

    std::string getAlgorithmDisplayName(const std::string& algorithmId) const;

    std::string getAlgorithmCategory(const std::string& algorithmId) const;

    int getAlgorithmParamCount(const std::string& algorithmId) const;

    std::string getAlgorithmParamKey(const std::string& algorithmId, int index) const;

    std::string getAlgorithmParamLabel(const std::string& algorithmId, int index) const;

    std::string getAlgorithmParamDescription(const std::string& algorithmId, int index) const;

    std::string getAlgorithmParamCategory(const std::string& algorithmId, int index) const;

    std::string getAlgorithmParamKind(const std::string& algorithmId, int index) const;

    std::string getAlgorithmParamDefault(const std::string& algorithmId, int index) const;

    bool algorithmParamHasMinimum(const std::string &algorithmId, int index) const;

    bool algorithmParamHasMaximum(const std::string &algorithmId, int index) const;

    float getAlgorithmParamMinimum(const std::string& algorithmId, int index) const;

    float getAlgorithmParamMaximum(const std::string& algorithmId, int index) const;

    float getAlgorithmParamStep(const std::string& algorithmId, int index) const;

    bool isAlgorithmParamAdvanced(const std::string& algorithmId, int index) const;

    int getAlgorithmParamChoiceCount(const std::string& algorithmId, int index) const;

    std::string getAlgorithmParamChoice(const std::string& algorithmId, int paramIndex, int choiceIndex) const;

    [[nodiscard]] eve::Result<void> applyAlgorithmDefaults(const std::string&     algorithmId,

                                                           ProcgenParamsHandleRef params) const;


    [[nodiscard]] eve::Result<void> autotileGrid(ProcgenGridHandleRef grid);


    uint32_t randomSeed();


    [[nodiscard]] eve::Result<std::string> gridToJson(ProcgenGridHandleRef grid) const;


    // --- Phase B: textures ---

    [[nodiscard]] eve::Result<ProcgenImageHandleRef> generateImageHandle(const std::string&     recipeId,

                                                                         ProcgenParamsHandleRef params);

    [[nodiscard]] static eve::script::Borrowed<image::ImageData> resolve(ProcgenImageHandleRef reference) noexcept;

    [[nodiscard]] static eve::Result<void> release(ProcgenImageHandleRef reference);

    [[nodiscard]] static bool isStale(ProcgenImageHandleRef reference) noexcept;


    [[nodiscard]] eve::Result<ProcgenNormalImageHandleRef> generateNormalImageHandle(const std::string&     recipeId,

                                                                                     ProcgenParamsHandleRef params);

    [[nodiscard]] static eve::script::Borrowed<image::ImageData> resolve(

        ProcgenNormalImageHandleRef reference) noexcept;

    [[nodiscard]] static eve::Result<void> release(ProcgenNormalImageHandleRef reference);

    [[nodiscard]] static bool isStale(ProcgenNormalImageHandleRef reference) noexcept;

    [[nodiscard]] eve::script::Borrowed<graphics::Texture> generateTextureBorrowed(const std::string&     recipeId,

                                                                                   ProcgenParamsHandleRef params,

                                                                                   graphics::Graphics*    gfx);


    int         getTextureRecipeCount() const;

    std::string getTextureRecipeId(int index) const;

    bool        hasTextureRecipe(const std::string& recipeId) const;

    [[nodiscard]] eve::Result<RecipeDescriptor> getTextureRecipeSchema(const std::string& recipeId) const;

    [[nodiscard]] eve::Result<void> applyTextureRecipeDefaults(const std::string&     recipeId,

                                                               ProcgenParamsHandleRef params) const;


    // --- Phase E: dynamic clouds + cloud shadows ---

    [[nodiscard]] eve::Result<ProcgenCloudFieldHandleRef> newCloudFieldHandle();

    [[nodiscard]] eve::script::Borrowed<CloudField>       resolveCloudField(ProcgenCloudFieldHandleRef) noexcept;

    [[nodiscard]] eve::Result<void>                       releaseCloudField(ProcgenCloudFieldHandleRef);

    [[nodiscard]] bool                                    isCloudFieldStale(ProcgenCloudFieldHandleRef) const noexcept;

    [[nodiscard]] eve::Result<ProcgenCloudShadowHandleRef> newCloudShadowHandle();

    [[nodiscard]] eve::script::Borrowed<CloudShadow>       resolveCloudShadow(ProcgenCloudShadowHandleRef) noexcept;

    [[nodiscard]] eve::Result<void>                        releaseCloudShadow(ProcgenCloudShadowHandleRef);

    [[nodiscard]] bool isCloudShadowStale(ProcgenCloudShadowHandleRef) const noexcept;

    [[nodiscard]] eve::Result<float> cloudCoverageAt(ProcgenCloudFieldHandleRef field, float x, float z, float time);

    [[nodiscard]] eve::Result<float> cloudShadowFactor(ProcgenCloudShadowHandleRef shadow, float x, float z,

                                                       float time);

    [[nodiscard]] eve::Result<void> sampleCloud(ProcgenCloudFieldHandleRef field, std::span<float> out, int w, int h,

                                                float time, float x0, float z0, float extent);

    [[nodiscard]] eve::Result<void> sampleCloudShadow(ProcgenCloudShadowHandleRef shadow, std::span<float> out, int w,

                                                      int h, float time, float x0, float z0, float extent);

    [[nodiscard]] eve::Result<ProcgenPbrMaterialHandleRef> generatePbrMaterialHandle(const std::string&     recipeId,

                                                                                     ProcgenParamsHandleRef params);

    [[nodiscard]] eve::script::Borrowed<PbrTextureSet>     resolvePbrMaterial(ProcgenPbrMaterialHandleRef) noexcept;

    [[nodiscard]] eve::Result<void>                        releasePbrMaterial(ProcgenPbrMaterialHandleRef);

    [[nodiscard]] bool isPbrMaterialStale(ProcgenPbrMaterialHandleRef) const noexcept;


    int         getPbrRecipeCount() const;

    std::string getPbrRecipeId(int index) const;

    bool        hasPbrRecipe(const std::string& recipeId) const;

    [[nodiscard]] eve::Result<RecipeDescriptor> getPbrRecipeSchema(const std::string& recipeId) const;

    [[nodiscard]] eve::Result<void> applyPbrRecipeDefaults(const std::string&     recipeId,

                                                           ProcgenParamsHandleRef params) const;


    // --- Mesh recipes (Marching Cubes, …) ---

    [[nodiscard]] eve::Result<ProcgenMeshBuildHandleRef> buildMeshHandle(const std::string&     recipeId,

                                                                         ProcgenParamsHandleRef params);

    [[nodiscard]] eve::script::Borrowed<MeshBuild>       resolveMeshBuild(ProcgenMeshBuildHandleRef) noexcept;

    [[nodiscard]] eve::Result<void>                      releaseMeshBuild(ProcgenMeshBuildHandleRef);

    [[nodiscard]] bool                                   isMeshBuildStale(ProcgenMeshBuildHandleRef) const noexcept;

    [[nodiscard]] eve::Result<GeneratedArtifact> buildArtifact(const std::string&     recipeId,

                                                               ProcgenParamsHandleRef params, ArtifactId id);

    [[nodiscard]] eve::Result<ArtifactPublishReceipt> publishArtifact(const std::string&     recipeId,

                                                                      ProcgenParamsHandleRef params, ArtifactId id,

                                                                      ArtifactPublishOptions options = {});

    [[nodiscard]] const ArtifactStore& artifactStore() const noexcept { return artifactStore_; }

    [[nodiscard]] eve::script::Borrowed<graphics::Mesh> uploadMeshBorrowed(const MeshBuild    &mesh,

                                                                           graphics::Graphics &gfx);

    [[nodiscard]] eve::Result<void> configureGtsTerrainTileLods(

        const GtsTerrainLodSet& lods, int tileIndex, graphics::Renderable3D& renderable,

        graphics::Graphics& gfx, float worldDiameter, float verticalFovDegrees,

        float originX = 0.f, float originY = 0.f, float originZ = 0.f);

    [[nodiscard]] eve::Result<void> configurePcgMeshLods(const PcgMeshLodSet& lods,

                                                           graphics::Renderable3D& renderable,

                                                           graphics::Graphics& gfx, float worldDiameter,

                                                           float verticalFovDegrees);

    [[nodiscard]] eve::script::Borrowed<graphics::Mesh> generateMeshBorrowed(const std::string&     recipeId,

                                                                             ProcgenParamsHandleRef params,

                                                                             graphics::Graphics*    gfx);


    int         getMeshRecipeCount() const;

    std::string getMeshRecipeId(int index) const;

    bool        hasMeshRecipe(const std::string& recipeId) const;

    [[nodiscard]] eve::Result<RecipeDescriptor> getMeshRecipeSchema(const std::string& recipeId) const;

    [[nodiscard]] eve::Result<void> applyMeshRecipeDefaults(const std::string&     recipeId,

                                                            ProcgenParamsHandleRef params) const;


    // --- Phase D: terrain height sampling ---

    [[nodiscard]] eve::Result<ProcgenTerrainSamplerHandleRef> newTerrainSamplerHandle();

    [[nodiscard]] eve::script::Borrowed<TerrainSampler> resolveTerrainSampler(ProcgenTerrainSamplerHandleRef) noexcept;

    [[nodiscard]] eve::Result<void>                     releaseTerrainSampler(ProcgenTerrainSamplerHandleRef);

    [[nodiscard]] bool isTerrainSamplerStale(ProcgenTerrainSamplerHandleRef) const noexcept;

    [[nodiscard]] eve::Result<ProcgenHeightmapHandleRef> newHeightmapHandle(int width, int height);

    [[nodiscard]] eve::Result<ProcgenHeightmapHandleRef> adoptHeightmap(Heightmap heightmap);

    [[nodiscard]] eve::script::Borrowed<Heightmap>       resolveHeightmap(ProcgenHeightmapHandleRef) noexcept;

    [[nodiscard]] eve::Result<void>                      releaseHeightmap(ProcgenHeightmapHandleRef);

    [[nodiscard]] bool                                   isHeightmapStale(ProcgenHeightmapHandleRef) const noexcept;

    bool heightmapToGrid(Heightmap* heightmap, Params* params, Grid2D* out);

    bool erodeTerrainThermal(Heightmap* heightmap, int iterations, float talus, float strength);

    bool erodeTerrainHydraulic(Heightmap* heightmap, int iterations, float rainfall, float evaporation, float capacity,

                               float erosion, float deposition);

    bool erodeTerrainFluvial(Heightmap* heightmap, int iterations, float riverThreshold, float incision, float maxDepth,

                             float bankWidth);

    bool erodeTerrainFluvialAdvanced(Heightmap* heightmap, int iterations, float riverThreshold, float incision,

                                     float maxDepth, float bankWidth, float maxBreachDepth);

    bool erodeTerrainFluvialScaled(Heightmap* heightmap, int iterations, float riverThreshold, float incision,

                                   float maxDepth, float bankWidth, float maxBreachDepth, float coordinateScale);

    TerrainErosionMap* erodeTerrainFluvialDetailed(Heightmap* heightmap, int iterations, float riverThreshold,

                                                   float incision, float maxDepth, float bankWidth,

                                                   float maxBreachDepth, float coordinateScale);

    TerrainLayers* analyzeTerrain(Heightmap* heightmap, float riverThreshold, float seaLevel, float latitude);

    TerrainLayers* analyzeTerrainScaled(Heightmap* heightmap, float riverThreshold, float seaLevel, float latitude,

                                        float coordinateScale);

    data::ByteData* bakeTerrainAsset(Heightmap* heightmap, TerrainLayers* layers, int chunkSize);

    TerrainMeshChunk* buildTerrainChunk(Heightmap* heightmap, TerrainLayers* layers, int originX, int originY,

                                        int cellsX, int cellsY, int lod, float cellSize, float heightScale,

                                        float skirtDepth);

    int selectTerrainLod(Heightmap* heightmap, int originX, int originY, int cellsX, int cellsY, int maxLod,

                         float cellSize, float heightScale, float cameraDistance, float viewportHeight,

                         float verticalFovDegrees, float targetPixelError);

    graphics::Mesh* generateTerrainChunkMesh(TerrainMeshChunk* chunk, graphics::Graphics* gfx);

    graphics::Mesh* generateTerrainRiverMesh(Heightmap* heightmap, TerrainLayers* layers, graphics::Graphics* gfx,

                                             int originX, int originY, int cellsX, int cellsY, float cellSize,

                                             float heightScale, float minWidth, float maxWidth, float heightOffset);

    graphics::Mesh* generateTerrainRiverMeshAdvanced(Heightmap* heightmap, TerrainLayers* layers,

                                                     graphics::Graphics* gfx, int originX, int originY, int cellsX,

                                                     int cellsY, float cellSize, float heightScale, float minWidth,

                                                     float maxWidth, float heightOffset, float minSurfaceSlope,

                                                     float maxSurfaceSlope);

    graphics::Mesh* generateTerrainLakeMesh(Heightmap* heightmap, TerrainLayers* layers, graphics::Graphics* gfx,

                                            int originX, int originY, int cellsX, int cellsY, float cellSize,

                                            float heightScale, float minimumDepth, float heightOffset);

    image::ImageData* generateTerrainSplatMap(TerrainMeshChunk* chunk);

    image::ImageData* generateTerrainAlbedoMap(TerrainMeshChunk* chunk);

    image::ImageData* generateTerrainErosionMap(TerrainErosionMap* erosion, float exposure);

    image::ImageData* generateTerrainWearMap(TerrainErosionMap* erosion, float exposure);

    image::ImageData* generateTerrainDepositionMap(TerrainErosionMap* erosion, float exposure);

    graphics::Shader* createTerrainMaterialShader(graphics::Graphics* gfx);

    graphics::Shader*                                    createTerrainWaterShader(graphics::Graphics* gfx);

    [[nodiscard]] eve::Result<ProcgenHeightmapHandleRef> generateHeightmapHandle(ProcgenParamsHandleRef params);

    [[nodiscard]] eve::Result<ProcgenGridHandleRef> heightmapToGrid(ProcgenHeightmapHandleRef heightmap,

                                                                    ProcgenParamsHandleRef    params);


    PaletteTable& palettes() { return palettes_; }


private:

    bool       runGenerate(const std::string& algorithmId, const Params& params, Grid2D& out);

    ArtifactId nextCompatibilityArtifactId() noexcept;


    struct OwnershipState;

    std::unique_ptr<OwnershipState> ownership_;


    PaletteTable                                                                             palettes_;

    mutable std::string              lastError_;

    mutable std::vector<std::string>                                                         algorithmIdsCache_;

    mutable std::vector<std::string>                                                         textureRecipeIdsCache_;

    mutable std::vector<std::string>                                                         pbrRecipeIdsCache_;

    mutable std::vector<std::string>                                                         meshRecipeIdsCache_;

    std::unordered_map<std::string, ProcgenSystemSnapshot>                                   systems_;

    std::unordered_map<std::string, ProcgenSystemSnapshot>                                   previousSystems_;

    ArtifactStore                                                                            artifactStore_;

    std::uint64_t                                                                            nextArtifactSequence_ = 1;

    eve::script::RuntimeObjectRegistry<Params, ProcgenParamsHandleTag>                       params_;

    eve::script::RuntimeObjectRegistry<Grid2D, ProcgenGridHandleTag>                         grids_;

    eve::script::RuntimeObjectRegistry<ProcgenContext, ProcgenContextHandleTag>              contexts_;

    eve::script::RuntimeObjectRegistry<SpatialData, ProcgenSpatialDataHandleTag>             spatialData_;

    eve::script::RuntimeObjectRegistry<RuntimeGeneration, ProcgenRuntimeGenerationHandleTag> runtimeGenerations_;

    eve::script::RuntimeObjectRegistry<PointGraph, ProcgenPointGraphHandleTag>               pointGraphs_;

    eve::script::RuntimeObjectRegistry<MeshModifierGraph, ProcgenMeshModifierGraphHandleTag> meshModifierGraphs_;

    eve::script::RuntimeObjectRegistry<MeshDeformationSession, ProcgenMeshDeformationSessionHandleTag>

        meshDeformationSessions_;

    eve::script::RuntimeObjectRegistry<DynamicMeshUvPaintSession, ProcgenDynamicMeshUvPaintSessionHandleTag>

        dynamicMeshUvPaintSessions_;

    eve::script::RuntimeObjectRegistry<SplinePath, ProcgenSplinePathHandleTag>                     splinePaths_;

    eve::script::RuntimeObjectRegistry<GridGraph, ProcgenGridGraphHandleTag>                 gridGraphs_;

    eve::script::RuntimeObjectRegistry<MeshGraph, ProcgenMeshGraphHandleTag>                 meshGraphs_;

    eve::script::RuntimeObjectRegistry<BiomeRules, ProcgenBiomeRulesHandleTag>               biomeRules_;

    eve::script::RuntimeObjectRegistry<ShapeGrammar, ProcgenShapeGrammarHandleTag>           shapeGrammars_;

    eve::script::RuntimeObjectRegistry<LSystem, ProcgenLSystemHandleTag>                     lsystems_;

};


}  // namespace eve::procgen

operation
ActionParameterOperation operation
Definition ActionNotifyRegistry.cpp:152

value
double value
Definition ActionNotifyRegistry.cpp:153

time
Duration time
Definition ActionTimelinePayloadEditor.cpp:18

w
float w
Definition AnimClip.cpp:738

y
float y
Definition AnimClip.cpp:738

x
float x
Definition AnimClip.cpp:738

z
float z
Definition AnimClip.cpp:738

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

spatial
eve::action::ActionSpatialBinding spatial
Definition AudioCapabilities.cpp:378

reference
AuthorityStoreHandleRef reference
Definition Authority.cpp:24

Biome.h

mask
int mask
Definition BuildingFx.cpp:64

CloudField.h

CloudShadow.h

DynamicMeshUvPaintSession.h

values
std::map< std::string, Var > values
Definition EditorHost.cpp:490

input
EvpackChunkInput input
Definition Evpack.cpp:170

Export.h

EVENGINE_API_DOMAINS
#define EVENGINE_API_DOMAINS
Definition Export.h:110

palette
std::string palette
Definition FloorTextures.cpp:239

request
const GltfImportRequest & request
Definition GltfMaterials.cpp:31

capacity
std::uint32_t capacity
Definition GraphicsParticles.cpp:37

Grid2D.h

GridGraph.h

Heightmap.h

left
HexVec3 left
Definition HexSphereMesh.cpp:219

right
HexVec3 right
Definition HexSphereMesh.cpp:220

second
std::int32_t second
Definition HexSphereTopology.cpp:81

first
std::int32_t first
Definition HexSphereTopology.cpp:80

h
int h
Definition ImageData.cpp:690

height
std::uint32_t height
Definition ImageImporter.cpp:14

width
std::uint32_t width
Definition ImageImporter.cpp:13

scope
JobScope scope
Definition JobSystemThreadPool.cpp:158

LSystem.h

parent
std::int32_t parent
Definition LegacyAnimationImporter.cpp:14

name
std::string name
Definition McpScriptTools.cpp:40

MeshBuild.h

MeshDeformationSession.h

MeshGraph.h

Module.h

OutputSpec.h

Palette.h

ParamSchema.h

Params.h

layer
TileLayer * layer
Definition Pathfinder.cpp:146

radius
float radius
Definition PlacementSystem.cpp:42

script
std::string script
Definition PlayHost.cpp:116

PointGraph.h

seed
std::uint32_t seed
Definition PointSet.cpp:807

PointSet.h

points
std::shared_ptr< const std::vector< glm::vec2 > > points
Definition PrimitiveDrawList.cpp:76

ProcgenCore.h

ProcgenSystem.h

release
std::function< eve::Result< void >()> release
Definition Procgen.cpp:86

mesh
Mesh * mesh
Definition RenderSystem3D.cpp:677

lod
int lod
Definition RoadArtifact.cpp:82

RuntimeGeneration.h

ShapeGrammar.h

SpatialData.h

SplinePath.h

options
const SquirrelValueOptions & options
Definition SquirrelBinding.cpp:17

SquirrelOwnership.h
Explicit Value/Owned/Borrowed semantics at the Squirrel boundary.

strength
float strength
Definition TerrainGenerationSession.cpp:121

TerrainMesh.h

TerrainPipeline.h

TerrainSampler.h

spacing
int spacing
Definition TileConfig.cpp:86

iterations
int iterations
Definition TreeMesh.cpp:311

index
uint32_t index
Definition UnityVegetationMaterial.cpp:163

source
const UnitySourceAsset & source
Definition UnityVegetationPreset.cpp:29

depth
std::uint32_t depth
Definition UnityVegetationPreset.cpp:34

context
const VegetationPresetContext & context
Definition VegetationPreset.cpp:94

semantic
uint32_t semantic
Definition WfcSimple.cpp:15

eve::Module
EVENGINE_API_FOUNDATION public API.
Definition Module.h:46

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

eve::data::ByteData
In-memory byte buffer implementing eve::Data (ref-counted).
Definition ByteData.h:13

eve::detail::Id128
Id128 public API.
Definition Identity.h:112

eve::graphics::Graphics
Definition Graphics.h:125

eve::graphics::Mesh
GPU mesh handle (+ optional CPU morph targets).
Definition Mesh.h:25

eve::graphics::Renderable3D
EVENGINE_API_BACKENDS public API.
Definition RenderSystem3D.h:204

eve::graphics::Shader
Custom GPU program.
Definition Shader.h:39

eve::image::ImageData
Represents raw pixel data.
Definition ImageData.h:38

eve::map::TileLayer
ECS tile layer entity. Script mutates tile GIDs / tileset / draw; TileRenderSystem batch-draws atlas ...
Definition TileLayer.h:32

eve::procgen::ArtifactStore
In-memory owner and publisher for generated artifacts.
Definition GeneratedArtifact.h:227

eve::procgen::BiomeRules
Data-driven biome distribution rules compatible with PointGraph and scene batches.
Definition Biome.h:40

eve::procgen::DynamicMeshUvPaintSession
Integrates dynamic-mesh hit mapping with the canonical image UV-paint session.
Definition DynamicMeshUvPaintSession.h:19

eve::procgen::Grid2D
Intermediate 2D generation result. cells store semantic ids (see Semantic.h), not tile GIDs — convert...
Definition Grid2D.h:36

eve::procgen::GridGraph
Deterministic data-flow graph for grid generation and explicit grid-to-point composition.
Definition GridGraph.h:35

eve::procgen::GtsTerrainLodSet
Owned result of the GTS split-and-sequential-simplify pipeline.
Definition GtsTerrainLod.h:112

eve::procgen::Heightmap
In-memory terrain heightmap: a dense float grid (row-major, index = y * width + x) materialized from ...
Definition Heightmap.h:21

eve::procgen::LSystem
General stochastic bracketed L-system engine.
Definition LSystem.h:55

eve::procgen::MeshBuild
CPU triangle mesh from procedural mesh recipes (e.g. marching cubes). Positions/normals are xyz-packe...
Definition MeshBuild.h:19

eve::procgen::MeshDeformationSession
Stateful CPU sculpting session with explicit bake, restore, and undo semantics.
Definition MeshDeformationSession.h:25

eve::procgen::MeshGraph
Typed procedural mesh graph composing grid, point and topology domains.
Definition MeshGraph.h:21

eve::procgen::MeshModifierGraph
Deterministic CPU data-flow graph for procedural mesh deformation and composition.
Definition MeshModifierGraph.h:47

eve::procgen::PaletteTable
Named palette: semantic name -> tile GID. Unmapped semantics become GID 0.
Definition Palette.h:16

eve::procgen::Params
Owning, typed generation parameters.
Definition Params.h:27

eve::procgen::PcgMeshLodSet
Owned generic mesh LOD output generated with Pcg's independent-per-level policy.
Definition PcgMeshLod.h:144

eve::procgen::PointGraph
EVENGINE_API_DOMAINS public API.
Definition PointGraph.h:66

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

eve::procgen::ProcgenContext
Staging area for one atomic rebuild of a named procedural system.
Definition ProcgenSystem.h:34

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

eve::procgen::Procgen::artifactStore
const ArtifactStore & artifactStore() const noexcept
Borrow the compatibility facade's published CPU artifact store.
Definition Procgen.h:848

eve::procgen::Procgen::Module_REG
Module_REG(Procgen)

eve::procgen::Procgen::heightmapToGrid
bool heightmapToGrid(Heightmap *heightmap, Params *params, Grid2D *out)
Compatibility facade that classifies a heightmap into a semantic Grid2D.

eve::procgen::Procgen::~Procgen
~Procgen() override
Procgen.

eve::procgen::Procgen::palettes
PaletteTable & palettes()
Palettes.
Definition Procgen.h:991

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

eve::procgen::ShapeGrammar
Module-based shape grammar expanded continuously along a 3D polyline.
Definition ShapeGrammar.h:27

eve::procgen::SpatialData
Queryable spatial input for procedural pipelines.
Definition SpatialData.h:35

eve::procgen::SplinePath
Owning multi-segment 3D spline with deterministic bounded sampling.
Definition SplinePath.h:91

eve::procgen::TerrainLayers
Script-friendly ownership wrapper for baked hydrology and climate layers.
Definition TerrainPipeline.h:77

eve::procgen::TerrainMeshChunk
One renderable heightfield chunk plus four ecological material weights.
Definition TerrainMesh.h:27

eve::script::Borrowed
Non-owning C++ observation with no implicit lifetime extension.
Definition RuntimeRegistry.h:42

defaultValue
const char * defaultValue
Definition MeshModifierGraph.cpp:22

params
std::vector< ParamSpec > params
Definition MeshModifierGraph.cpp:29

MeshModifierGraph.h

eve::artifact::PartKind::ImageData
@ ImageData

eve::asset::EvpackChunkKind::Shader
@ Shader

eve::data
Definition ByteData.cpp:7

eve::graphics
卡牌游戏 UI 工具模块：工厂 + 脚本绑定入口。 功能参考 ycarowr/UiCard：扇形手牌布局、抽牌/洗牌、悬浮放大、拖拽到落牌区、 敌方手牌（背面/偷看）、费用不足置灰，以及可实时调节的布局...
Definition Animation.h:25

eve::image
Definition AvatarInstance.h:25

eve::procgen
Definition EvpackPointGraphLoader.h:12

eve::procgen::gridToJson
std::string gridToJson(const Grid2D &grid)
Compact JSON for debugging / reload workflows (not full Tiled).
Definition JsonExport.cpp:29

eve::procgen::GtsTerrainColliderType::Mesh
@ Mesh

eve::procgen::TerrainOperationDomain::Texture
@ Texture

eve::procgen::deriveSeed
uint32_t deriveSeed(uint32_t parent, const std::string &scope)
Stable label-based seed derivation; independent pipeline branches do not perturb each other.
Definition PointSet.cpp:459

eve
Build metadata (engine git commit, build time, third-party version).
Definition Build.cpp:16

eve::PhotoModeDomain::Graphics
@ Graphics

std
Definition Container.h:602

eve::artifact::PublishOptions
Required provider set for one artifact publication transaction.
Definition ArtifactPublication.h:179

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

eve::procgen::ProcgenBiomeRulesHandleTag
Handle domain for module-owned biome rules.
Definition Procgen.h:107

eve::procgen::ProcgenCloudFieldHandleTag
Handle domain for module-owned cloud fields.
Definition Procgen.h:77

eve::procgen::ProcgenCloudShadowHandleTag
Handle domain for module-owned cloud shadow fields.
Definition Procgen.h:79

eve::procgen::ProcgenContextHandleTag
Handle domain for module-owned procedural rebuild contexts.
Definition Procgen.h:67

eve::procgen::ProcgenDynamicMeshUvPaintSessionHandleTag
Handle domain for module-owned dynamic-mesh UV paint sessions.
Definition Procgen.h:99

eve::procgen::ProcgenGridGraphHandleTag
Handle domain for module-owned grid graphs.
Definition Procgen.h:103

eve::procgen::ProcgenGridHandleTag
Handle domain for module-owned procedural grids.
Definition Procgen.h:65

eve::procgen::ProcgenHeightmapHandleTag
Handle domain for module-owned heightmaps.
Definition Procgen.h:75

eve::procgen::ProcgenImageHandleTag
Handle domain for module-owned generated images.
Definition Procgen.h:85

eve::procgen::ProcgenLSystemHandleTag
Handle domain for module-owned L-system engines.
Definition Procgen.h:111

eve::procgen::ProcgenMeshBuildHandleTag
Handle domain for module-owned CPU mesh builds.
Definition Procgen.h:83

eve::procgen::ProcgenMeshDeformationSessionHandleTag
Handle domain for module-owned interactive mesh deformation sessions.
Definition Procgen.h:97

eve::procgen::ProcgenMeshGraphHandleTag
Handle domain for module-owned mesh graphs.
Definition Procgen.h:105

eve::procgen::ProcgenMeshModifierGraphHandleTag
Handle domain for module-owned mesh modifier graphs.
Definition Procgen.h:95

eve::procgen::ProcgenNormalImageHandleTag
Handle domain for module-owned generated normal images.
Definition Procgen.h:87

eve::procgen::ProcgenOutputHandleTag
Handle domain for module-owned output specifications.
Definition Procgen.h:69

eve::procgen::ProcgenParamsHandleTag
Handle domain for module-owned procedural parameter objects.
Definition Procgen.h:63

eve::procgen::ProcgenPbrMaterialHandleTag
Handle domain for module-owned PBR material sets.
Definition Procgen.h:81

eve::procgen::ProcgenPointGraphHandleTag
Handle domain for module-owned point graphs.
Definition Procgen.h:93

eve::procgen::ProcgenPointSetHandleTag
Handle domain for module-owned point-set intermediates.
Definition Procgen.h:71

eve::procgen::ProcgenRuntimeGenerationHandleTag
Handle domain for module-owned runtime-generation schedulers.
Definition Procgen.h:91

eve::procgen::ProcgenShapeGrammarHandleTag
Handle domain for module-owned shape grammars.
Definition Procgen.h:109

eve::procgen::ProcgenSpatialDataHandleTag
Handle domain for module-owned spatial data.
Definition Procgen.h:89

eve::procgen::ProcgenSplinePathHandleTag
Handle domain for module-owned 3D spline paths.
Definition Procgen.h:101

eve::procgen::ProcgenSystemSnapshot
Immutable committed snapshot retained by Procgen across script reloads.
Definition ProcgenSystem.h:131

eve::procgen::ProcgenTerrainSamplerHandleTag
Handle domain for module-owned terrain samplers.
Definition Procgen.h:73

eve::procgen::TerrainErosionMap
Per-cell diagnostic outputs produced by an erosion stage.
Definition TerrainPipeline.h:59

eve::script::RuntimeHandleRef< ProcgenParamsHandleTag >