AtmosphereVolume.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include <cstddef>
#include <vector>
 
#include <glm/mat4x4.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
 
namespace eve::graphics {
 
class FogVolume;
class VolumeDensityGraph;
class SparseVolumeTexture;
 
struct FogFroxel {
    glm::vec3 scattering{0.f};
    float extinction = 0.f;
    glm::vec3 emissive{0.f};
    float anisotropy = 0.f;
    float lightVisibility = 1.f;
};
 
struct VolumetricLight {
    glm::vec3 position{0.f};
    glm::vec3 color{1.f};
    float radius = 5.f;
    float intensity = 1.f;
    bool enabled = true;
};
 
class EVENGINE_API_BACKENDS AtmosphereVolume {
public:
    void resize(int width, int height, int depth);
    void clear();
 
    int getWidth() const { return width_; }
    int getHeight() const { return height_; }
    int getDepth() const { return depth_; }
    std::size_t getFroxelCount() const { return media_.size(); }
 
    void setDepthRange(float nearDistance, float farDistance);
    float getNearDistance() const { return nearDistance_; }
    float getFarDistance() const { return farDistance_; }
    float sliceDistance(int z) const;
    int sliceForDistance(float distance) const;
 
    FogFroxel &at(int x, int y, int z);
    const FogFroxel &at(int x, int y, int z) const;
 
    void injectHeightFog(float baseExtinction, const glm::vec3 &albedo, float baseHeight,
                         float heightFalloff, float minWorldY, float maxWorldY);
 
    void injectHeightFogFrustum(float baseExtinction, const glm::vec3 &albedo,
                                float baseHeight, float heightFalloff, float minWorldY,
                                float maxWorldY,
                                const glm::mat4 &invViewProj);
 
    void injectLocalVolume(const FogVolume &volume, const glm::vec3 &worldMin,
                           const glm::vec3 &worldMax);
 
    void injectLocalVolumeFrustum(const FogVolume &volume, const glm::mat4 &invViewProj);
 
    void injectDensityGraph(const VolumeDensityGraph &graph, const glm::vec3 &worldMin,
                            const glm::vec3 &worldMax, float extinctionScale,
                            const glm::vec3 &albedo, float time = 0.f);
 
    void injectSparseVolume(const SparseVolumeTexture &texture, float extinctionScale = 1.f);
 
    void integrate(const glm::vec3 &lightColor, float phaseScale = 1.f);
 
    void integrateLocalLights(const std::vector<VolumetricLight> &lights,
                              const glm::vec3 &worldMin, const glm::vec3 &worldMax,
                              const glm::vec3 &ambientLight);
 
    void setLightVisibility(int x, int y, int z, float visibility);
 
    std::size_t blendHistory(const AtmosphereVolume &history, float historyWeight,
                             float rejectionThreshold);
 
    const glm::vec4 &integratedAt(int x, int y, int z) const;
 
    glm::vec4 sampleIntegrated(float u, float v, float distance) const;
 
    FogFroxel sampleMedia(float u, float v, float w) const;
 
private:
    std::size_t index(int x, int y, int z) const;
 
    int width_ = 0;
    int height_ = 0;
    int depth_ = 0;
    float nearDistance_ = 0.1f;
    float farDistance_ = 100.f;
    std::vector<FogFroxel> media_;
    std::vector<glm::vec4> integrated_;
};
 
}  // namespace eve::graphics