WaterUnderwaterEffects.h

浏览该文件的文档.

#pragma once
 
#include "common/Result.h"
 
#include <cstdint>
#include <vector>
 
#include <glm/glm.hpp>
 
namespace ssq { class Table; }
 
namespace eve::graphics {
class Volumetric;
class Camera3D;
class Graphics;
class Renderable3D;
 
struct UnderwaterColorStop { float time = 0.0F; glm::vec3 color{1.0F}; };
 
class EVENGINE_API_BACKENDS UnderwaterColorGradient {
public:
    [[nodiscard]] Result<void> addStop(float time, float r, float g, float b);
    void clear() { stops_.clear(); }
    [[nodiscard]] Result<glm::vec3> evaluate(float time) const;
  private:
    std::vector<UnderwaterColorStop> stops_;
};
 
class EVENGINE_API_BACKENDS UnderwaterScalarCurve {
public:
    [[nodiscard]] Result<void> addKey(float time, float value);
    void clear() { keys_.clear(); }
    [[nodiscard]] Result<float> evaluate(float time) const;
  private:
    std::vector<glm::vec2> keys_;
};
 
struct WaterUnderwaterSettings {
    bool enabled = true;
    bool supportFog = true;
    bool supportPostFx = true;
    bool enableTransitionFx = true;
    bool useCaustics = true;
    bool hdrp = false;
    bool overrideFogColor = false;
    float fogDepth = 100.0F;
    float fogDistance = 45.0F;
    float hdrpFogDistance = 30.0F;
    float nearFogDistance = -4.0F;
    float fogDensity = 0.045F;
    float playbackVolume = 0.5F;
    float causticSize = 15.0F;
    int framesPerSecond = 24;
    int causticTextureCount = 0;
    glm::vec3 fogColorMultiplier{0.0F};
    bool photoModeFogColorEnabled = false;
    glm::vec3 photoModeFogColor{0.0F};
    glm::vec3 overrideFogMultiplier{1.0F};
    float overrideFogCurve = 1.0F;
    float anisotropyShallow = 0.225F;
    float anisotropyDeep = 0.0F;
    bool timeDrivenPostFx = false;
    float constantPostExposure = 0.0F;
    glm::vec3 constantPostColor{1.0F};
    float transitionHalfHeight = 0.025F;
    float transitionBlendDistance = 0.025F;
    float transitionVignette = 0.25F;
    float transitionVignetteSmoothness = 0.8F;
    float transitionLensDistortion = 0.252F;
    float transitionLensScale = 1.02F;
    glm::vec3 transitionLift{-0.020152892F, -0.009343888F, 0.005069838F};
    glm::vec3 transitionInverseGamma{1.35160142F, 1.35531419F, 1.26800077F};
    glm::vec3 transitionGain{0.67146943F, 0.68969287F, 0.72298255F};
    glm::vec3 transitionColorFilter{0.0F};
};
 
struct WaterUnderwaterInput {
    float cameraY = 0.0F;
    float seaLevel = 50.0F;
    float timeOfDay = 0.5F;
    glm::vec3 mainLightColor{1.0F};
    bool hasMainLight = true;
    int causticTicks = 0;
};
 
struct WaterUnderwaterState { bool initialized = false; bool isUnderwater = false; int causticFrame = 0; };
 
struct WaterUnderwaterDisableTriggerState { bool effectsEnabled = true; };
 
struct WaterUnderwaterTriggerEvent {
    int sensorTag = 0;
    int visitorTag = 0;
    bool entered = false;
    bool exited = false;
};
 
struct WaterUnderwaterOutput {
    bool isUnderwater = false;
    bool entered = false;
    bool exited = false;
    bool playSubmergeDown = false;
    bool playSubmergeUp = false;
    bool loopAudio = false;
    bool particles = false;
    bool horizon = false;
    bool surfaceVfx = true;
    bool postFx = false;
    bool transitionFx = false;
    bool caustics = false;
    int causticFrame = 0;
    float causticSize = 0.0F;
    glm::vec3 fogColor{0.533F, 0.764F, 1.0F};
    float fogDensity = 0.0F;
    float fogStart = 0.0F;
    float fogEnd = 0.0F;
    float fogHeight = 0.0F;
    float depth01 = 0.0F;
    float hdrpBaseHeight = -150.0F;
    float hdrpMeanFreePath = 3000.0F;
    float hdrpProbeDimmer = 1.0F;
    float hdrpAnisotropy = 0.225F;
    float hdrpDepthExtent = 150.0F;
    float postExposure = 0.0F;
    glm::vec3 postColor{1.0F};
    glm::vec3 underwaterMaterialColor{0.8117647F};
    float transitionWeight = 0.0F;
    float transitionVignette = 0.0F;
    float transitionVignetteSmoothness = 0.2F;
    float transitionLensDistortion = 0.0F;
    float transitionLensScale = 1.0F;
    glm::vec3 transitionLift{0.0F};
    glm::vec3 transitionInverseGamma{1.0F};
    glm::vec3 transitionGain{1.0F};
    glm::vec3 transitionColorFilter{1.0F};
};
 
struct WaterSurfaceFogSnapshot {
    glm::vec3 color{0.55F, 0.58F, 0.62F};
    float density = 0.004F;
    float start = 2.0F;
    float end = 90.0F;
    float height = 0.0F;
    float heightFalloff = 0.04F;
};
 
struct WaterSurfacePostFxSnapshot {
    float exposureEv = 0.0F;
    glm::vec3 color{1.0F};
    float vignette = 0.0F;
    float vignetteSmoothness = 0.2F;
    float lensDistortion = 0.0F;
    float lensScale = 1.0F;
    glm::vec3 lift{0.0F};
    glm::vec3 inverseGamma{1.0F};
    glm::vec3 gain{1.0F};
};
 
struct WaterSurfaceMaterialSnapshot {
    glm::vec3 color{1.0F};
    float alpha = 1.0F;
};
 
[[nodiscard]] EVENGINE_API_BACKENDS Result<void> advanceWaterUnderwaterEffects(
    WaterUnderwaterState& state, WaterUnderwaterOutput& output, const WaterUnderwaterSettings& settings,
    const WaterUnderwaterInput& input, const UnderwaterColorGradient& depthGradient,
    const UnderwaterColorGradient& timeGradient, const UnderwaterScalarCurve& postExposureCurve,
    const UnderwaterColorGradient& postColorGradient);
 
[[nodiscard]] EVENGINE_API_BACKENDS Result<void> advanceWaterUnderwaterDisableTrigger(
    WaterUnderwaterDisableTriggerState& state, const WaterUnderwaterTriggerEvent& event, int expectedSensorTag,
    int expectedVisitorTag);
 
[[nodiscard]] EVENGINE_API_BACKENDS Result<void> applyWaterUnderwaterFog(Volumetric*                    volumetric,
                                                                         const WaterUnderwaterOutput&   output,
                                                                         const WaterSurfaceFogSnapshot& surface);
 
[[nodiscard]] EVENGINE_API_BACKENDS Result<void> applyWaterUnderwaterPostFx(Graphics* graphics, Camera3D* camera,
                                                                            const WaterUnderwaterOutput&      output,
                                                                            const WaterSurfacePostFxSnapshot& surface);
 
[[nodiscard]] EVENGINE_API_BACKENDS Result<void> applyWaterUnderwaterHorizon(Renderable3D*                horizon,
                                                                             const WaterUnderwaterOutput& output);
 
[[nodiscard]] EVENGINE_API_BACKENDS Result<void> applyWaterUnderwaterMaterial(
    Renderable3D* renderable, const WaterUnderwaterOutput& output, const WaterSurfaceMaterialSnapshot& surface);
 
void exposeWaterUnderwaterEffectsBindings(ssq::Table& table);
 
}  // namespace eve::graphics