Grass.h

浏览该文件的文档.

#pragma once
 
#include "graphics/Shader.h"
 
#include <cstdint>
#include <string>
#include <vector>
 
#include <glm/glm.hpp>
 
namespace eve::graphics {
 
class Graphics;
class Mesh;
class Texture;
 
namespace grass {
 
struct Point {
    glm::vec3 position{0.f};
    glm::vec3 normal{0.f, 1.f, 0.f};
    uint32_t id = 0;
    float scale = 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;
};
 
std::vector<Point> samplePoisson(const float *posXYZ, const float *nrmXYZ, int vertexCount,
                                 const uint32_t *indices, int indexCount,
                                 const SampleParams &params = {});
 
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);
 
BillboardMesh buildBillboards(const std::vector<Point> &points, float width = 0.62f,
                              float height = 0.95f, bool alwaysDark = false);
 
int swayFrame(float time, float frameDuration, uint32_t instanceId, int frameCount = 4);
 
void makeSwayAtlasRGBA(int frameW, int frameH, int frames, std::vector<uint8_t> &rgbaOut);
int swayAtlasWidth(int frameW, int frames);
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;
};
 
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);
void bindDefaults(Shader *shader);
void bindLayer(Shader *shader, bool alwaysDark);
void bindAtlasLayout(Shader *shader, const PackedAtlasInfo &info);
void setTime(Shader *shader, float seconds);
void setFrameDuration(Shader *shader, float seconds);
 
int paramCount();
std::string paramName(int index);
 
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 GrassField {
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() = default;
 
    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);
 
    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();
 
    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:
    Graphics *gfx_ = nullptr;
    Shader *shader_ = nullptr;
    Texture *atlas_ = nullptr;
    Mesh *denseMesh_ = nullptr;
    Mesh *sparseMesh_ = nullptr;
    int denseCount_ = 0;
    int sparseCount_ = 0;
    float time_ = 0.f;
    float frameDuration_ = 0.12f;
};
 
}  // namespace eve::graphics