AmbientOcclusion.h

浏览该文件的文档.

#pragma once
 
#include <string>
#include <glm/mat4x4.hpp>
 
namespace eve::graphics {
 
class Canvas;
class Graphics;
class Shader;
class Texture;
 
class AmbientOcclusion {
public:
    explicit AmbientOcclusion(Graphics *gfx);
    ~AmbientOcclusion();
 
    AmbientOcclusion(const AmbientOcclusion &) = delete;
    AmbientOcclusion &operator=(const AmbientOcclusion &) = delete;
 
    void setQuality(const std::string &quality);
    std::string getQuality() const { return quality_; }
 
    void setMode(const std::string &mode);
    std::string getMode() const { return mode_; }
 
    void setCamera(float eyeX, float eyeY, float eyeZ, float targetX, float targetY, float targetZ,
                   float upX, float upY, float upZ, float fovYDeg, float aspect, float nearZ,
                   float farZ);
 
    void setInvViewProj(const glm::mat4 &invViewProj);
 
    void setRadius(float radius);
    void setBias(float bias);
    void setIntensity(float intensity);
    void setPower(float power);
    void setThickness(float thickness);
 
    float getRadius() const;
    float getBias() const;
    float getIntensity() const;
    float getPower() const;
 
    bool hasParam(const std::string &name) const;
    void setFloat(const std::string &name, float value);
    float getFloat(const std::string &name) const;
 
    int getSampleCount() const;
    float getDownscale() const { return downscale_; }
 
    int resolutionFor(int fullSize) const;
 
    void compute(Graphics *gfx, Texture *linearDepth);
    void computeTo(Graphics *gfx, Texture *linearDepth, Canvas *dest);
 
    void blur(Graphics *gfx, Texture *aoMap);
    void blurTo(Graphics *gfx, Texture *aoMap, Canvas *dest);
 
    void applyOverlay(Graphics *gfx, Texture *aoMap);
    void applyOverlayTo(Graphics *gfx, Texture *aoMap, Canvas *dest);
 
    void applyFromDepth(Graphics *gfx, Texture *hwDepth);
    void applyFromDepthTo(Graphics *gfx, Texture *linearDepth, Canvas *dest);
    void applyFromGBuffer(Graphics *gfx, Texture *hwDepth, Texture *worldNormal);
 
    Texture *newLinearDepthTexture(Graphics *gfx, int width, int height,
                                   float (*depth01)(int x, int y, void *userdata), void *userdata);
 
    Shader *getShader() const;
    Shader *getSsaoShader() const { return ssaoShader_; }
    Shader *getHbaoShader() const { return hbaoShader_; }
    Shader *getGtaoShader() const { return gtaoShader_; }
    Shader *getBlurShader() const { return blurShader_; }
    Shader *getOverlayShader() const { return overlayShader_; }
    Shader *getFromDepthShader() const { return fromDepthShader_; }
 
private:
    void applyQualityDefaults();
    void uploadComputeCommon(Shader *shader, int width, int height);
    void drawFullscreen(Graphics *gfx, Texture *source, Shader *shader);
    Shader *activeComputeShader() const;
 
    Graphics *gfx_ = nullptr;
    Shader *ssaoShader_ = nullptr;
    Shader *hbaoShader_ = nullptr;
    Shader *gtaoShader_ = nullptr;
    Shader *blurShader_ = nullptr;
    Shader *overlayShader_ = nullptr;
    Shader *fromDepthShader_ = nullptr;
    std::string quality_ = "medium";
    std::string mode_ = "ssao";
    float downscale_ = 2.f;
    glm::mat4 invViewProj_{1.f};
    float nearZ_ = 0.1f;
    float farZ_ = 100.f;
    float radius_ = 0.75f;
    float bias_ = 0.025f;
    float intensity_ = 1.f;
    float power_ = 1.5f;
    float thickness_ = 0.5f;
};
 
}  // namespace eve::graphics