Light.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/ECS.h"
#include "zeroerr/assert.h"
 
#include <algorithm>
#include <array>
#include <cmath>
#include <cstdint>
#include <string>
#include <string_view>
#include <glm/glm.hpp>
 
namespace eve::graphics {
 
class Canvas;
 
inline void lightSpotCosines(float angleDeg, float softness, float &cosOuter, float &cosInner) {
    constexpr float kPi = 3.14159265358979323846f;
    const float outerDeg = std::clamp(angleDeg, 0.1f, 89.f);
    const float soft = std::clamp(softness, 0.f, 1.f);
    const float outerRad = outerDeg * (kPi / 180.f);
    const float innerRad = outerRad * (1.f - soft);
    cosOuter = std::cos(outerRad);
    cosInner = std::cos(innerRad);
    if (cosInner < cosOuter + 1e-4f) cosInner = cosOuter + 1e-4f;
}
 
inline void light2dSpotCosines(float angleDeg, float softness, float &cosOuter, float &cosInner) {
    lightSpotCosines(angleDeg, softness, cosOuter, cosInner);
}
 
struct Light2DGpu {
    glm::vec4 posRadius{0.f};  // xy = point/spot pos or dir; w = radius (0 => directional)
    glm::vec4 color{0.f};      // rgb * intensity
    glm::vec4 spot{0.f, 0.f, -2.f, -2.f};
};
 
struct Lighting2DUBO {
    static constexpr int kMaxLights = 8;
    glm::vec4 ambient{0.15f, 0.15f, 0.18f, 0.f};
    glm::vec4 meta{0.f};  // x = count, y = viewW, z = viewH
    Light2DGpu lights[kMaxLights]{};
};
 
class EVENGINE_API_BACKENDS Light2D : public ecs::Entity {
public:
    ENTITY(Light2D, ecs::Entity)
 
    
    void release() override {}
 
    struct Data {
        std::string type = "point";
        float x = 0.f;
        float y = 0.f;
        float dx = 0.f;
        float dy = -1.f;
        float r = 1.f, g = 1.f, b = 1.f;
        float intensity = 1.f;
        float radius = 200.f;
        float spotAngleDeg = 30.f;
        float spotSoftness = 0.35f;
        bool enabled = true;
        bool volumetric = false;
        float volumetricIntensity = 1.f;
        bool volumetricOnly = false;
        Canvas *canvas = nullptr;
        Light2D *entity = nullptr;
    };
 
    COMPONENT(Data, data)
 
    static Light2D *createLight(const std::string &type = "point");
 
    static Light2D *createEmissiveProxy(float x, float y, float r, float g, float b,
                                        float intensity = 1.f, float radius = 200.f);
 
    void setType(const std::string &type);
    std::string getType();
 
    void setPosition(float x, float y);
    float getX();
    float getY();
 
    void setDirection(float dx, float dy);
    float getDirX();
    float getDirY();
 
    void setColor(float r, float g, float b, float intensity = 1.f);
    void setRadius(float radius);
    float getRadius();
 
    void setSpotAngle(float degrees);
    float getSpotAngle();
    void setSpotSoftness(float softness);
    float getSpotSoftness();
 
    void setEnabled(bool enabled);
    bool isEnabled();
 
    void setVolumetric(bool enabled);
    bool getVolumetric();
    void setVolumetricIntensity(float intensity);
    float getVolumetricIntensity();
    void setVolumetricOnly(bool enabled);
    bool getVolumetricOnly();
 
    void setCanvas(Canvas *canvas);
};
 
struct Light3DGpu {
    glm::vec4 posRadius{0.f};  // xyz = point/spot pos or dir; w = radius (0 => directional)
    glm::vec4 color{0.f};      // rgb * intensity; a = spotBias when spot else 1
    glm::vec4 spot{0.f, 0.f, 0.f, -1.f};
};
 
struct Lighting3DPack {
    static constexpr int kMaxLights = 8;
    glm::vec4 ambient{0.12f, 0.12f, 0.14f, 0.f};
    Light3DGpu lights[kMaxLights]{};
    int count = 0;
    std::array<glm::vec4, 9> diffuseProbeSh{};  // xyz = RGB coefficient
    bool diffuseProbeShEnabled = false;
    static constexpr int kMaxDiffuseVolumeProbes = 8;
    std::array<glm::vec4, kMaxDiffuseVolumeProbes> diffuseVolumePosition{};
    std::array<glm::vec4, kMaxDiffuseVolumeProbes> diffuseVolumeExtent{};
    std::array<glm::vec4, kMaxDiffuseVolumeProbes * 9> diffuseVolumeSh{};
    int diffuseVolumeProbeCount = 0;
    bool diffuseVolumeTrilinearCell = false;
};
 
class EVENGINE_API_BACKENDS Light3D : public ecs::Entity {
public:
    ENTITY(Light3D, ecs::Entity)
 
    
    void release() override {}
 
    struct Data {
        std::string type = "point";
        float x = 0.f, y = 0.f, z = 0.f;
        float dx = 0.4f, dy = 1.f, dz = 0.3f;
        float r = 1.f, g = 1.f, b = 1.f;
        float intensity = 1.f;
        float radius = 8.f;
        float spotAngleDeg = 30.f;
        float spotSoftness = 0.35f;
        bool enabled = true;
        bool castShadow = false;
        std::uint8_t shadowMethod = 0;
        int shadowLocalSlot = -1;
        float shadowBias = 0.f;  // 0 = auto NDC from cascade texel / Z range
        float shadowStrength = 1.f;
        bool volumetric = false;
        float volumetricIntensity = 1.f;
        bool volumetricOnly = false;
        Light3D *entity = nullptr;
    };
 
    COMPONENT(Data, data)
 
    static Light3D *createLight(const std::string &type = "point");
 
    static Light3D *createEmissiveProxy(float x, float y, float z, float r, float g, float b,
                                        float intensity = 1.f, float radius = 8.f);
 
    void setType(const std::string &type);
    std::string getType();
 
    void setPosition(float x, float y, float z);
    float getX();
    float getY();
    float getZ();
 
    void setDirection(float dx, float dy, float dz);
    float getDirX();
    float getDirY();
    float getDirZ();
 
    void setColor(float r, float g, float b, float intensity = 1.f);
    void setRadius(float radius);
    float getRadius();
 
    void setSpotAngle(float degrees);
    float getSpotAngle();
    void setSpotSoftness(float softness);
    float getSpotSoftness();
 
    void setEnabled(bool enabled);
    bool isEnabled();
 
    void setCastShadow(bool cast);
    bool getCastShadow();
    void setShadowMethod(const std::string &method);
    std::string getShadowMethod();
    void setShadowBias(float bias);
    float getShadowBias();
    void setShadowStrength(float strength);
    float getShadowStrength();
 
    void setVolumetric(bool enabled);
    bool getVolumetric();
    void setVolumetricIntensity(float intensity);
    float getVolumetricIntensity();
    void setVolumetricOnly(bool enabled);
    bool getVolumetricOnly();
};
 
}  // namespace eve::graphics