ShadowScheme.h

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
#include "common/Result.h"
#include "graphics/Light.h"
#include "graphics/Shadow.h"
 
#include <cstdint>
#include <string>
#include <string_view>
#include <vector>
#include <glm/glm.hpp>
 
namespace eve::graphics {
 
[[nodiscard]] EVENGINE_API_BACKENDS Result<ShadowMethod> parseShadowMethod(std::string_view name);
 
[[nodiscard]] EVENGINE_API_BACKENDS const char* shadowMethodName(ShadowMethod method);
 
[[nodiscard]] EVENGINE_API_BACKENDS Result<ShadowMethod> resolveShadowMethod(std::string_view lightType,
                                                                             ShadowMethod requested);
 
struct ShadowPagingView {
    glm::vec3 eye{0.f};
    glm::mat4 viewProj{1.f};
    bool      valid = false;
};
 
struct EVENGINE_API_BACKENDS ShadowSchemeSettings {
    bool enableDirectionalCsm = true;
    bool enableSpotPerspective = true;
    bool enablePointCube = false;  // GPU atlas path lands later; keep off by default
    int  directionalMapSize = ShadowConfig::kMapSize;
    int  localMapSize = 1024;
    int  maxSpotShadowCasters = ShadowConfig::kLocalSlots;
    int  maxPointShadowCasters = 0;
    float defaultSpotBias = 0.002f;
    float defaultPointBias = 0.003f;
 
    bool enableLocalPaging = true;
    int maxLocalUpdatesPerFrame = ShadowConfig::kLocalSlots;
    float hysteresisBonus = 0.35f;
    float minPageScore = 1e-4f;
 
    [[nodiscard]] static ShadowSchemeSettings& current();
};
 
struct LocalShadowSlot {
    Light3D::Data* light = nullptr;
    ShadowMethod   method = ShadowMethod::None;
    int            layer = -1;       // index into the shadow depth array
    int            lightIndex = -1;  // index in the packed Light3D list (0..7)
    glm::mat4      lightVP{1.f};
    float          bias = 0.002f;
    float          strength = 1.f;
    float          score = 0.f;
    bool           needsUpdate = true;
};
 
[[nodiscard]] EVENGINE_API_BACKENDS glm::mat4 buildSpotShadowVP(const glm::vec3& position,
                                                                const glm::vec3& direction, float range,
                                                                float outerAngleDeg);
 
[[nodiscard]] EVENGINE_API_BACKENDS Result<glm::mat4> buildPointShadowFaceVP(const glm::vec3& position,
                                                                             int faceIndex, float range);
 
[[nodiscard]] EVENGINE_API_BACKENDS float scoreSpotShadowCandidate(const Light3D::Data& light,
                                                                   const ShadowPagingView& view,
                                                                   const ShadowSchemeSettings& settings,
                                                                   bool hadSlot);
 
EVENGINE_API_BACKENDS void selectShadowCasters(const std::vector<Light3D::Data*>& lights,
                                               const std::vector<bool>& isPointFlags,
                                               const ShadowSchemeSettings& settings,
                                               const ShadowPagingView& view,
                                               Light3D::Data*& directionalCaster,
                                               std::vector<LocalShadowSlot>& localSlots);
 
EVENGINE_API_BACKENDS void resetShadowLocalPageCache();
 
}  // namespace eve::graphics