Water.h

浏览该文件的文档.

#pragma once
 
#include "graphics/Shader.h"
#include "graphics/WaterStyleConfig.h"
 
#include <cstdint>
#include <string>
#include <vector>
 
#include <glm/glm.hpp>
 
namespace eve::graphics {
 
enum class WaterMeshType : std::uint8_t { Plane = 0, Circle = 1 };
 
struct WaterMeshSettings {
    float sizeX = 200.0F;
    float sizeY = 30.0F;
    float sizeZ = 200.0F;
    float densityX = 50.0F;
    float densityY = 50.0F;
    float height = 0.0F;
    WaterMeshType type = WaterMeshType::Plane;
};
 
[[nodiscard]] EVENGINE_API_BACKENDS Result<int> calculateWaterMeshTriangles(const WaterMeshSettings &settings);
 
class Graphics;
class Mesh;
class Texture;
 
struct WaterGradientColorStop { float time = 0.0F; glm::vec3 color{0.0F}; };
struct WaterGradientAlphaStop { float time = 0.0F; float alpha = 1.0F; };
 
struct EVENGINE_API_BACKENDS WaterDepthGradient {
    std::vector<WaterGradientColorStop> colorStops;
    std::vector<WaterGradientAlphaStop> alphaStops;
    [[nodiscard]] Result<void> addColorStop(float time, float red, float green, float blue);
    [[nodiscard]] Result<void> addAlphaStop(float time, float alpha);
    void clear();
};
 
class EVENGINE_API_BACKENDS Water {
public:
    explicit Water(Graphics *gfx);
    ~Water();
 
    Water(const Water &) = delete;
    Water &operator=(const Water &) = delete;
 
    void createPlane(float sizeX, float sizeZ, int segX, int segZ);
 
    [[nodiscard]] Result<int> createProceduralMesh(const WaterMeshSettings& settings);
 
    void update(float dt);
    void setTime(float seconds);
    float getTime() const { return time_; }
 
    // --- Animation / material knobs ---
    void setWaveSpeed(float speed);
    float getWaveSpeed() const { return config_.waveSpeed; }
 
    void setWaveAmplitude(float amp);
    float getWaveAmplitude() const { return config_.waveAmplitude; }
 
    void setRippleAmplitude(float amp);
    float getRippleAmplitude() const { return config_.rippleAmplitude; }
 
    void setEdgeFalloff(float edge);
    float getEdgeFalloff() const { return config_.foamWidth; }
 
    void setRippleCount(int count);
    int getRippleCount() const { return config_.rippleCount; }
 
    void setRippleInterval(float seconds);
    float getRippleInterval() const { return config_.rippleInterval; }
 
    void setWaveScale(float scale);
    float getWaveScale() const { return config_.waveScale; }
 
    [[nodiscard]] Result<void> setWaveDirectionAngle(float degrees);
    float getWaveDirectionAngle() const { return waveDirectionAngle_; }
 
    [[nodiscard]] Result<int> setDepthGradient(const WaterDepthGradient& gradient, int resolution);
    Texture* getDepthGradientTexture() const { return depthGradientTexture_; }
    void clearDepthGradient() { depthGradientTexture_ = nullptr; }
 
    void setWaterColor(float r, float g, float b);
    void setReflectionTint(float r, float g, float b);
    void setReflectionIntensity(float intensity);
    float getReflectionIntensity() const { return config_.reflectionIntensity; }
 
    void setSunIntensity(float intensity);
    float getSunIntensity() const { return config_.sunIntensity; }
 
    void setScreenSpaceReflection(bool enabled, float strength = 0.85f);
    bool getScreenSpaceReflection() const { return config_.screenSpaceReflection; }
    float getScreenSpaceReflectionStrength() const { return config_.screenSpaceReflectionStrength; }
 
    [[nodiscard]] Result<void> applyConfigJson(const std::string& json);
    [[nodiscard]] Result<std::string> configJson() const;
    WaterStyleConfig config() const { return config_; }
 
    void setViewport(float width, float height);
    float getViewportWidth() const { return viewportW_; }
    float getViewportHeight() const { return viewportH_; }
 
    void bindParams();
 
    void draw();
 
    void drawWithPlanarReflection(Texture* planarReflection, float strength = 1.0F);
 
    void setReflectionCaptureEnabled(bool enabled) { reflectionCaptureEnabled_ = enabled; }
    bool getReflectionCaptureEnabled() const { return reflectionCaptureEnabled_; }
    void setReflectionCaptureMask(uint32_t mask) { reflectionCaptureMask_ = mask; }
    uint32_t getReflectionCaptureMask() const { return reflectionCaptureMask_; }
 
    Shader *getShader() const { return shader_; }
    Mesh *getMesh() const { return mesh_; }
 
    static int paramCount();
    static std::string paramName(int index);
 
private:
    void drawWithReflection(Texture* reflection, float strength);
    void drawReflectionCapture();
 
    Graphics *gfx_ = nullptr;
    Shader *shader_ = nullptr;
    Mesh *mesh_ = nullptr;
 
    float time_ = 0.f;
    float waveDirectionAngle_ = 0.0F;
    Texture* depthGradientTexture_ = nullptr;
    WaterStyleConfig config_;
    float viewportW_ = 0.f;
    float viewportH_ = 0.f;
    uint64_t captureDrawerToken_ = 0;
    uint32_t reflectionCaptureMask_ = 0xffffffffu;
    bool reflectionCaptureEnabled_ = true;
};
 
Shader *newWaterShader(Graphics *gfx);
 
}  // namespace eve::graphics