Volumetric.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "graphics/AtmosphereVolume.h"
 
#include <string>
#include <memory>
#include <vector>
#include <glm/mat4x4.hpp>
#include <glm/vec3.hpp>
 
namespace eve::graphics {
 
class Canvas;
class FogVolume;
class Drawable;
class Graphics;
class Light2D;
class Light3D;
class Mesh;
class Shader;
class Texture;
 
class EVENGINE_API_BACKENDS Volumetric {
public:
    explicit Volumetric(Graphics *gfx);
    ~Volumetric();
 
    Volumetric(const Volumetric &) = delete;
    Volumetric &operator=(const Volumetric &) = 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 setLightScreenUV(float u, float v);
    float getLightScreenU() const;
    float getLightScreenV() const;
 
    void setLightScreenPos(float x, float y, float width, float height);
 
    void setLightDirection(float dx, float dy, float dz);
 
    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 setShaftColor(float r, float g, float b);
    void setFogColor(float r, float g, float b);
    void setIntensity(float intensity);
    void setTime(float seconds);
    void setDensity(float density);
 
    void setAnisotropy(float g);
    float getAnisotropy() const;
 
    void setFogHeight(float worldY);
    void setFogHeightFalloff(float falloff);
    void setFogStart(float startDistance);
    void setFogEnd(float endDistance);
    void setFogNoise(float amount);
 
    void setCloudLayer(float bottom, float top);
    void setCloudCoverage(float coverage);
    void setCloudDensity(float density);
    void setCloudScale(float worldScale);
    void setCloudWind(float x, float z);
    void setCloudLightColor(float r, float g, float b);
 
    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_; }
 
    void beginOcclusionMap(Graphics *gfx, float lightPixelX, float lightPixelY,
                           float lightRadiusPixels = 24.f);
 
    void drawOccluder(Graphics *gfx, Drawable *drawable, const glm::mat4 &matrix);
 
    void drawOccluderSolid(Graphics *gfx, float x, float y, float w, float h);
    void drawOccluderTexture(Graphics *gfx, Texture *texture, float x, float y, float w, float h);
 
    void scatter(Graphics *gfx, Texture *occlusion);
 
    void scatterTo(Graphics *gfx, Texture *occlusion, Canvas *dest);
 
    void applyFromScene(Graphics *gfx, Texture *scene);
    void applyFromSceneTo(Graphics *gfx, Texture *scene, Canvas *dest);
 
    void rayMarch(Graphics *gfx, Texture *linearDepth);
    void rayMarchTo(Graphics *gfx, Texture *linearDepth, Canvas *dest);
 
    void applyFog(Graphics *gfx, Texture *linearDepth);
    void applyFogTo(Graphics *gfx, Texture *linearDepth, Canvas *dest);
 
    [[nodiscard]] Result<void> projectDirectionalCookie(Graphics *gfx, Texture *depth,
                                                         Texture *cookie, float worldSize,
                                                         float intensity = 1.f);
 
    void renderClouds(Graphics *gfx, Texture *linearDepth);
    void renderCloudsTo(Graphics *gfx, Texture *linearDepth, Canvas *dest);
 
    void configureFroxelGrid(int width, int height, int depth, float nearDistance,
                             float farDistance);
    AtmosphereVolume *getAtmosphereVolume() const { return atmosphereVolume_.get(); }
    const glm::mat4 &getInvViewProj() const { return invViewProj_; }
    void clearFroxelGrid();
    void injectFroxelHeightFog(float extinction, float albedoR, float albedoG, float albedoB,
                               float baseHeight, float heightFalloff, float minWorldY,
                               float maxWorldY);
    void injectFroxelLocalVolume(FogVolume *volume);
    void integrateFroxel(float lightR, float lightG, float lightB, float phaseScale = 1.f);
 
    [[nodiscard]] Result<int> collectSceneLights3D(std::vector<VolumetricLight> &out,
                                                   int maxCount = 32);
 
    [[nodiscard]] Result<void> driveFromLight3D(Light3D *light, float viewportW, float viewportH);
 
    [[nodiscard]] Result<void> driveFromPrimarySceneLight3D(float viewportW, float viewportH);
 
    [[nodiscard]] Result<void> integrateFroxelFromSceneLights(float ambientR, float ambientG,
                                                              float ambientB,
                                                              const glm::vec3 &worldMin,
                                                              const glm::vec3 &worldMax,
                                                              int maxLights = 16);
 
    [[nodiscard]] Result<int> beginOcclusionMapFromSceneLights2D(Graphics *gfx,
                                                                Canvas *canvasFilter = nullptr,
                                                                float defaultRadiusPixels = 24.f);
 
    [[nodiscard]] Result<int> scatterFromSceneLights2D(Graphics *gfx, Texture *occlusion,
                                                      Canvas *canvasFilter = nullptr);
 
    [[nodiscard]] Result<void> injectEmissiveLightProxy(float x, float y, float z, float r, float g,
                                                        float b, float radius, float intensity);
 
    void uploadFroxel(Graphics *gfx);
    void applyFroxel(Graphics *gfx, Texture *linearDepth);
    void applyFroxelTo(Graphics *gfx, Texture *linearDepth, Canvas *dest);
 
    Texture *newLinearDepthTexture(Graphics *gfx, int width, int height,
                                   float (*depth01)(int x, int y, void *userdata), void *userdata);
 
    int resolutionFor(int fullSize) const;
 
    void drawOccluders2D(Graphics *gfx);
 
    Shader *getShader() const { return shader_; }
    Shader *getRayMarchShader() const { return rayShader_; }
    Shader *getFogShader() const { return fogShader_; }
    Shader *getCloudShader() const { return cloudShader_; }
    Shader *getFroxelShader() const { return froxelShader_; }
    Texture *getFroxelAtlas() const { return froxelAtlas_; }
 
private:
    void applyQualityDefaults();
    void uploadCommon(bool compositeFromScene);
    void uploadRayMarchCommon();
    void uploadFogCommon();
    void uploadCloudCommon();
    void drawFullscreen(Graphics *gfx, Texture *source, Shader *shader);
    void uploadRayMarchShadowAnisotropy();
    void clearPendingEmissiveProxies();
 
    Graphics *gfx_ = nullptr;     // not owned
    Shader *shader_ = nullptr;    // owned by Graphics (screenspace)
    Shader *rayShader_ = nullptr; // owned by Graphics (ray march)
    Shader *fogShader_ = nullptr; // owned by Graphics (volumetric fog)
    Shader *directionalCookieShader_ = nullptr; // owned by Graphics
    Shader *cloudShader_ = nullptr; // owned by Graphics (volumetric clouds)
    Shader *froxelShader_ = nullptr; // owned by Graphics (froxel atlas composite)
    std::unique_ptr<AtmosphereVolume> atmosphereVolume_;
    Texture *froxelAtlas_ = nullptr; // owned by Graphics
    int froxelAtlasCols_ = 1;
    int froxelAtlasRows_ = 1;
    std::string quality_ = "medium";
    std::string mode_ = "screenspace";
    float downscale_ = 2.f;
    glm::mat4 invViewProj_{1.f};
    float nearZ_ = 0.1f;
    float farZ_ = 100.f;
    glm::vec3 lightDir_{0.4f, 1.f, 0.3f};
    float anisotropy_ = 0.6f;
    float fogHeight_ = 0.f;
    float fogHeightFalloff_ = 0.15f;
    float fogStart_ = 2.f;
    float fogEnd_ = 40.f;
    float fogNoise_ = 0.35f;
    float cloudBottom_ = 8.f;
    float cloudTop_ = 16.f;
    float cloudCoverage_ = 0.55f;
    float cloudDensity_ = 1.f;
    float cloudScale_ = 18.f;
    glm::vec3 cloudWind_{1.5f, 0.f, 0.4f};
    glm::vec3 cloudLightColor_{1.f, 0.92f, 0.78f};
    std::vector<VolumetricLight> pendingEmissiveProxies_;
};
 
}  // namespace eve::graphics