Grass.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "common/PcgPhotoModeApply.h"
#include "graphics/Shader.h"
 
#include <cstdint>
#include <string>
#include <vector>
 
#include <glm/glm.hpp>
 
namespace eve::image {
class ImageData;
}
 
namespace eve::graphics {
 
class Graphics;
class Mesh;
class Texture;
 
namespace grass {
 
struct GrassFoliageSettings {
    float baseR = 1.f, baseG = 1.f, baseB = 1.f;
    float alphaCutoff = 0.05f;
    float normalStrength = 1.f;
    float renderDistance = 75.f;
    float fadeRange = 20.f;
    float hardRenderDistance = 105.f;
    float density = 1.f;
    float snowMinimumHeight = 100.f;
    float snowFadeDistance = 20.f;
    float snowProgress = 0.f;
    float snowR = 1.f, snowG = 1.f, snowB = 1.f;
};
 
struct TerrainDetailOverwriteSettings {
    float pcgDetailDistance = 75.f;
    float pcgFadeoutDistance = 20.f;
    int unityDetailDistance = 105;
    float unityDetailDensity = 1.f;
    int detailResolutionPerPatch = 16;
};
 
enum class TerrainDetailQuality { VeryLow64, Low32, Medium16, High8, VeryHigh4, Ultra2 };
 
EVENGINE_API_BACKENDS TerrainDetailQuality terrainDetailQuality(int resolutionPerPatch) noexcept;
 
[[nodiscard]] EVENGINE_API_BACKENDS Result<int> applyTerrainDetailOverwrite(
    GrassFoliageSettings &foliage, const TerrainDetailOverwriteSettings &settings);
 
struct Point {
    glm::vec3 position{0.f};
    glm::vec3 normal{0.f, 1.f, 0.f};
    uint32_t  id    = 0;
    float     scale = 1.f;
    float widthScale = 0.f;
    glm::vec3 tint{-1.f};
};
 
struct SampleParams {
    float    radius    = 0.14f;
    int      maxPoints = 8192;
    uint32_t seed      = 1;
    float minSlopeDot = 0.25f;
};
 
struct BillboardMesh {
    std::vector<float>    posXYZ;
    std::vector<float>    nrmXYZ;
    std::vector<float>    uvST;
    std::vector<uint32_t> indices;
};
 
EVENGINE_API_BACKENDS std::vector<Point> samplePoisson(const float *posXYZ, const float *nrmXYZ, int vertexCount,
                                                       const uint32_t *indices, int indexCount,
                                                       const SampleParams &params = {});
 
EVENGINE_API_BACKENDS std::vector<Point> sampleHalton(const float *posXYZ, const float *nrmXYZ, int vertexCount,
                                                      const uint32_t *indices, int indexCount, int count,
                                                      uint32_t seed = 1, float minSlopeDot = 0.25f);
 
EVENGINE_API_BACKENDS BillboardMesh buildBillboards(const std::vector<Point> &points, float width = 0.62f,
                                                    float height = 0.95f, bool alwaysDark = false);
 
EVENGINE_API_BACKENDS int swayFrame(float time, float frameDuration, uint32_t instanceId, int frameCount = 4);
 
EVENGINE_API_BACKENDS void makeSwayAtlasRGBA(int frameW, int frameH, int frames, std::vector<uint8_t> &rgbaOut);
EVENGINE_API_BACKENDS int  swayAtlasWidth(int frameW, int frames);
EVENGINE_API_BACKENDS int  swayAtlasHeight(int frameH);
 
Texture *createSwayAtlas(Graphics *gfx, int frameW = 64, int frameH = 64, int frames = 4);
 
struct PackedAtlasInfo {
    int width         = 0;
    int height        = 0;
    int atlasCols     = 2;
    int atlasRows     = 2;
    int grassVariants = 1;
    int leafVariants  = 1;
    int leafRowOffset = 0;
    int frames        = 4;
};
 
EVENGINE_API_BACKENDS void packSwayAtlasRGBA(const std::vector<std::string> &grassFiles,
                                             const std::vector<std::string> &leafFiles, std::vector<uint8_t> &rgbaOut,
                                             PackedAtlasInfo &info);
Texture *createSwayAtlasFromFiles(Graphics *gfx, const std::vector<std::string> &grassFiles,
                                  const std::vector<std::string> &leafFiles, PackedAtlasInfo *infoOut = nullptr);
 
Shader *createShader(Graphics *gfx);
EVENGINE_API_BACKENDS void bindDefaults(Shader *shader);
EVENGINE_API_BACKENDS void bindLayer(Shader *shader, bool alwaysDark);
void    bindAtlasLayout(Shader *shader, const PackedAtlasInfo &info);
EVENGINE_API_BACKENDS void bindFoliage(Shader *shader, const GrassFoliageSettings &settings);
void    setTime(Shader *shader, float seconds);
void    setFrameDuration(Shader *shader, float seconds);
 
EVENGINE_API_BACKENDS int paramCount();
EVENGINE_API_BACKENDS std::string paramName(int index);
 
EVENGINE_API_BACKENDS void makePlane(float sizeX, float sizeZ, int segX, int segZ, std::vector<float> &posXYZ,
                                     std::vector<float> &nrmXYZ, std::vector<uint32_t> &indices);
 
}  // namespace grass
 
class EVENGINE_API_BACKENDS GrassField : public IPhotoModeFieldSink {
public:
    struct BakeParams {
        float    denseRadius  = 0.14f;
        float    sparseRadius = 0.62f;
        int      maxDense     = 8192;
        int      maxSparse    = 384;
        uint32_t seed         = 1;
        float    width        = 0.62f;
        float    height       = 0.95f;
        float    minSlopeDot  = 0.25f;
        int      atlasFrameW  = 64;
        int      atlasFrameH  = 64;
        int      atlasFrames  = 4;
        std::vector<std::string> grassAtlasFiles;
        std::vector<std::string> leafAtlasFiles;
    };
 
    explicit GrassField(Graphics *gfx);
    ~GrassField();
 
    GrassField(const GrassField &)            = delete;
    GrassField &operator=(const GrassField &) = delete;
 
    void bake(const float *posXYZ, const float *nrmXYZ, int vertexCount, const uint32_t *indices, int indexCount,
              const BakeParams &params);
    void bakePlane(float sizeX, float sizeZ, int segX, int segZ);
    void bakePlane(float sizeX, float sizeZ, int segX, int segZ, const BakeParams &params);
 
    [[nodiscard]] Result<int> bakePoints(const std::vector<grass::Point> &points, float width, float height);
    [[nodiscard]] Result<int> bakeTexturedPoints(const std::vector<grass::Point> &points, float width, float height,
                                                 const image::ImageData &image);
 
    [[nodiscard]] Result<int> bakeFoliagePoints(const std::vector<grass::Point> &points, float width, float height,
                                                const image::ImageData &albedo, const image::ImageData &normal,
                                                const image::ImageData &mask,
                                                const grass::GrassFoliageSettings &settings);
 
    [[nodiscard]] Result<int> setTerrainDetailOverwrite(const grass::TerrainDetailOverwriteSettings &settings);
    float getTerrainDetailHardDistance() const noexcept { return detailHardDistance_; }
    float getTerrainDetailDensity() const noexcept { return detailDensity_; }
    void setPhotoModeAuthority(bool enabled);
    PhotoModeFieldAcceptance acceptsPhotoModeField(const PhotoModeAssignment& assignment) const noexcept override;
    [[nodiscard]] Result<void> applyPhotoModeField(const PhotoModeAssignment& assignment) override;
 
 
    void  update(float dt);
    void  setTime(float seconds);
    float getTime() const { return time_; }
    void  setFrameDuration(float seconds);
    float getFrameDuration() const { return frameDuration_; }
 
    void draw(const glm::mat4 &model);
    void draw();
 
    void setReflectionCaptureEnabled(bool enabled) { reflectionCaptureEnabled_ = enabled; }
    bool getReflectionCaptureEnabled() const { return reflectionCaptureEnabled_; }
    void setReflectionCaptureMask(uint32_t mask) { reflectionCaptureMask_ = mask; }
    uint32_t getReflectionCaptureMask() const { return reflectionCaptureMask_; }
 
    Mesh *getDenseMesh() const { return denseMesh_; }
    Mesh *getSparseMesh() const { return sparseMesh_; }
    Shader *getShader() const { return shader_; }
    Texture *getAtlas() const { return atlas_; }
 
    int getDenseCount() const { return denseCount_; }
    int getSparseCount() const { return sparseCount_; }
 
private:
    void applyPhotoModeShaderState();
    [[nodiscard]] Result<int> bakePointData(const std::vector<grass::Point> &points, float width, float height,
                                            const image::ImageData *image, const image::ImageData *normal = nullptr,
                                            const image::ImageData *mask = nullptr,
                                            const grass::GrassFoliageSettings *foliage = nullptr);
    Graphics                 *gfx_           = nullptr;
    Shader                   *shader_        = nullptr;
    Texture                  *atlas_         = nullptr;
    Texture                  *normal_        = nullptr;
    Texture                  *mask_          = nullptr;
    Mesh                     *denseMesh_     = nullptr;
    Mesh                     *sparseMesh_    = nullptr;
    int                       denseCount_    = 0;
    int                       sparseCount_   = 0;
    float                     time_          = 0.f;
    float                     frameDuration_ = 0.12f;
    glm::mat4                 lastModel_{1.f};
    uint64_t                  captureDrawerToken_       = 0;
    uint32_t                  reflectionCaptureMask_    = 0xffffffffu;
    bool                      reflectionCaptureEnabled_ = true;
    bool                      foliageProfile_           = false;
    float                     detailHardDistance_       = 105.f;
    float                     detailDensity_            = 1.f;
    float                     baseDetailRenderDistance_ = 75.f;
    float                     baseDetailFadeRange_      = 20.f;
    float                     baseDetailHardDistance_   = 105.f;
    float                     baseDetailDensity_        = 1.f;
    bool                      photoModeAuthority_       = false;
    float                     photoModeDensity_         = 1.f;
    float                     photoModeDistance_        = 1.f;
    float                     photoModeCellDistance_    = 1.f;
    int                       photoModeCellSubdivision_ = 0;
};
 
}  // namespace eve::graphics