Procgen.h

浏览该文件的文档.

#pragma once
 
#include "common/Module.h"
#include "procgen/Grid2D.h"
#include "procgen/MeshBuild.h"
#include "procgen/OutputSpec.h"
#include "procgen/Palette.h"
#include "procgen/Params.h"
#include "procgen/heightmap/Heightmap.h"
#include "procgen/heightmap/TerrainSampler.h"
#include "procgen/texture/CloudField.h"
#include "procgen/texture/CloudShadow.h"
 
#include <string>
#include <vector>
 
namespace eve::graphics {
class Graphics;
class Texture;
class Mesh;
}  // namespace eve::graphics
 
namespace eve::image {
class ImageData;
}  // namespace eve::image
 
namespace eve::procgen {
class PbrTextureSet;
 
class Procgen : public Module {
public:
    Module_REG(Procgen);
    Procgen();
    ~Procgen() override = default;
 
    Params     *newParams();
    OutputSpec *newOutput();
    Grid2D     *newGrid(int width, int height);
 
    // --- Phase A: maps ---
    Grid2D *generate(const std::string &algorithmId, Params *params);
    bool    generateTo(const std::string &algorithmId, Params *params, OutputSpec *output);
    bool    applyToLayer(Grid2D *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;
 
    bool autotileGrid(Grid2D *grid);
 
    uint32_t randomSeed();
 
    std::string lastError() const;
    std::string gridToJson(Grid2D *grid) const;
 
    // --- Phase B: textures ---
    image::ImageData *generateImage(const std::string &recipeId, Params *params);
    image::ImageData *generateNormalImage(const std::string &recipeId, Params *params);
    graphics::Texture *generateTexture(const std::string &recipeId, Params *params,
                                       graphics::Graphics *gfx);
 
    int         getTextureRecipeCount() const;
    std::string getTextureRecipeId(int index) const;
    bool        hasTextureRecipe(const std::string &recipeId) const;
 
    // --- Phase E: dynamic clouds + cloud shadows ---
    CloudField *newCloudField();
    CloudShadow *newCloudShadow();
    float cloudCoverageAt(CloudField *field, float x, float z, float time);
    float cloudShadowFactor(CloudShadow *shadow, float x, float z, float time);
    void sampleCloud(CloudField *field, float *out, int w, int h, float time, float x0, float z0,
                     float extent);
    void sampleCloudShadow(CloudShadow *shadow, float *out, int w, int h, float time, float x0,
                           float z0, float extent);
    PbrTextureSet *generatePbrMaterial(const std::string &recipeId, Params *params);
 
    int         getPbrRecipeCount() const;
    std::string getPbrRecipeId(int index) const;
    bool        hasPbrRecipe(const std::string &recipeId) const;
 
    // --- Mesh recipes (Marching Cubes, …) ---
    MeshBuild *buildMesh(const std::string &recipeId, Params *params);
    graphics::Mesh *generateMesh(const std::string &recipeId, Params *params,
                                 graphics::Graphics *gfx);
 
    int         getMeshRecipeCount() const;
    std::string getMeshRecipeId(int index) const;
    bool        hasMeshRecipe(const std::string &recipeId) const;
 
    // --- Phase D: terrain height sampling ---
    TerrainSampler *newTerrainSampler();
    Heightmap *newHeightmap(int width, int height);
    Heightmap *generateHeightmap(Params *params);
    bool heightmapToGrid(Heightmap *heightmap, Params *params, Grid2D *out);
 
    PaletteTable &palettes() { return palettes_; }
 
private:
    bool runGenerate(const std::string &algorithmId, const Params &params, Grid2D &out);
 
    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_;
};
 
}  // namespace eve::procgen