TextureRecipe.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "procgen/Params.h"
#include "procgen/ParamSchema.h"
#include "procgen/texture/ColorRamp.h"
#include "procgen/texture/NoiseField.h"
 
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::image {
class ImageData;
}
 
namespace eve::procgen {
 
using TextureRecipeFn = std::function<std::unique_ptr<image::ImageData>(const Params &params, std::string &error)>;
 
class EVENGINE_API_DOMAINS TextureRecipeRegistry {
public:
    static TextureRecipeRegistry &instance();
 
    void registerRecipe(const std::string &id, TextureRecipeFn fn);
    void registerRecipe(RecipeDescriptor descriptor, TextureRecipeFn fn);
    bool has(const std::string &id) const;
    [[nodiscard]] std::unique_ptr<image::ImageData> generate(const std::string &id, const Params &params,
                                                             std::string &error) const;
    std::vector<std::string> list() const;
    const RecipeDescriptor *descriptor(const std::string &id) const;
    bool applyDefaults(const std::string &id, Params &params) const;
 
    void registerBuiltins();
 
private:
    struct Entry {
        TextureRecipeFn fn;
        RecipeDescriptor descriptor;
    };
    TextureRecipeRegistry() = default;
    std::unordered_map<std::string, Entry> recipes_;
    bool builtinsRegistered_ = false;
};
 
struct TextureGenContext {
    int      width     = 64;
    int      height    = 64;
    uint32_t seed      = 1;
    float    scale     = 4.f;
    int      octaves   = 4;
    int      colors    = 6;
    int      pixelSize = 1;
    bool     seamless  = true;
    float    warpAmp   = 1.f;
 
    static TextureGenContext fromParams(const Params &params);
};
 
void paintHeightToImage(image::ImageData &img, const std::vector<float> &height, int w, int h,
                        const ColorRamp &ramp, int bands, int pixelSize);
 
void fillHeightField(const TextureGenContext &ctx,
                     const std::function<float(float, float, const NoiseField &)> &fn,
                     std::vector<float> &height);
 
[[nodiscard]] std::unique_ptr<image::ImageData> heightToNormalImage(const std::vector<float> &height, int w, int h,
                                                                    float strength, bool seamless);
 
struct PbrParams {
    float roughnessLow      = 0.45f;  // roughness at the low end of displacement
    float roughnessHigh     = 0.85f;  // roughness at the high end of displacement
    float metallic          = 0.f;    // uniform metalness (0..1)
    float normalStrength    = 4.f;    // normal-map height strength
    float aoStrength        = 1.f;    // cavity/ambient-occlusion strength
    float heightStrength    = 1.f;    // height-map displacement scale
 
    static PbrParams fromParams(const Params &params);
};
 
struct TextureRecipeDef {
    std::string id;  // albedo recipe id, e.g. "tex.marble"
    ColorRamp   albedo;
    std::function<float(float, float, const NoiseField &)> height;  // clamped to [0,1]
    PbrParams   pbr;
};
 
const std::vector<TextureRecipeDef> &builtinTextureDefs();
 
RecipeDescriptor makeTextureRecipeDescriptor(const TextureRecipeDef &definition);
 
}  // namespace eve::procgen