Laurens-Packages/Packages/com.unity.render-pipelines.core/Runtime/PostProcessing/Shaders/LensFlareCommon.hlsl

#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Filtering.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Random.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Sampling/Sampling.hlsl"
#include "Packages/com.unity.render-pipelines.core/Runtime/PostProcessing/LensFlareDataSRP.cs.hlsl"
#include "Packages/com.unity.render-pipelines.core/Runtime/PostProcessing/LensFlareOcclusionPermutation.cs.hlsl"

struct AttributesLensFlare
{
    uint vertexID : SV_VertexID;

#ifndef FLARE_PREVIEW
    UNITY_VERTEX_INPUT_INSTANCE_ID
#endif
};

struct VaryingsLensFlare
{
    float4 positionCS : SV_POSITION;
    float2 texcoord : TEXCOORD0;
    float2 screenPos : TEXCOORD1;
#if defined(FLARE_HAS_OCCLUSION) || defined(FLARE_COMPUTE_OCCLUSION)
    float occlusion : TEXCOORD2;
#endif

#ifndef FLARE_PREVIEW
    UNITY_VERTEX_OUTPUT_STEREO
#endif
};

TEXTURE2D(_FlareTex);
SAMPLER(sampler_FlareTex);

TEXTURE2D(_FlareOcclusionRemapTex);
SAMPLER(sampler_FlareOcclusionRemapTex);

#if defined(FLARE_HAS_OCCLUSION)
TEXTURE2D_ARRAY(_FlareOcclusionTex);
SAMPLER(sampler_FlareOcclusionTex);
#endif

#ifdef HDRP_FLARE
uint _FlareOcclusionPermutation;

TEXTURE2D_X(_FlareSunOcclusionTex);
SAMPLER(sampler_FlareSunOcclusionTex);
#endif

float4 _FlareColorValue;
float4 _FlareData0; // x: localCos0, y: localSin0, zw: PositionOffsetXY
float4 _FlareData1; // x: OcclusionRadius, y: OcclusionSampleCount, z: ScreenPosZ, w: ScreenRatio
float4 _FlareData2; // xy: ScreenPos, zw: FlareSize
float4 _FlareData3; // x: Allow Offscreen, y: Edge Offset, z: Falloff, w: invSideCount
                    // For Ring:
                    //                                                 w: RingThickness
float4 _FlareData4; // x: SDF Roundness, y: Poly Radius, z: PolyParam0, w: PolyParam1
                    // For Ring:
                    // x: noiseAmplitude, y: noiseFrequency, z: noiseSparsity, w: noiseSpeed
float4 _FlareData5; // x: ConstantColor, y: Intensity, z: shapeCutOffSpeed, w: cutoffRadius
float4 _FlareData6; // x: LensFlareType, y: ElementIndex

TEXTURE2D(_FlareRadialTint);
SAMPLER(sampler_FlareRadialTint);
int _ViewId; // Used for XR index, for SinglePass and Multipass

#ifdef FLARE_PREVIEW
float4 _FlarePreviewData;

#define _ScreenSize         _FlarePreviewData.xy;
#define _FlareScreenRatio   _FlarePreviewData.z;
#endif

float4 _FlareOcclusionIndex;

#define _LocalCos0              _FlareData0.x
#define _LocalSin0              _FlareData0.y
#define _PositionTranslate      _FlareData0.zw

// Vertex _FlareData1
#define _OcclusionRadius        _FlareData1.x
#define _OcclusionSampleCount   _FlareData1.y
#define _ScreenPosZ             _FlareData1.z
#ifndef _FlareScreenRatio
#define _FlareScreenRatio       _FlareData1.w
#endif

// Fragment _FlareData1
#define _FlareType              ((int)_FlareData6.x)
#define _FlareElementIndex      ((int)_FlareData6.y)

#define _ScreenPos              _FlareData2.xy
#define _FlareSize              _FlareData2.zw

#define _OcclusionOffscreen     _FlareData3.x
#define _FlareEdgeOffset        _FlareData3.y
#define _FlareFalloff           _FlareData3.z
#define _FlareShapeInvSide      _FlareData3.w
#define _FlareRingThickness     _FlareData3.w

#define _FlareSDFRoundness      _FlareData4.x
#define _FlareSDFPolyRadius     _FlareData4.y
#define _FlareSDFPolyParam0     _FlareData4.z
#define _FlareSDFPolyParam1     _FlareData4.w

// For Ring only
#define _FlareNoiseAmplitude    _FlareData4.x
#define _FlareNoiseFrequency    _FlareData4.y
#define _FlareNoiseSpeed        _FlareData4.z

#define _IsFlareColorRadial     (_FlareData5.x == 1.0f)
#define _IsFlareColorAngular    (_FlareData5.x == 2.0f)

#define _FlareIntensity         _FlareData5.y
#define _FlareCutoffSpeed       _FlareData5.z
#define _FlareCutoffRadius      _FlareData5.w

void Rotate(out float2 rot, float2 v, float cos0, float sin0)
{
    rot = float2(v.x * cos0 - v.y * sin0,
                 v.x * sin0 + v.y * cos0);
}

// Disables LOAD_TEXTURE2D_ARRAY_LOD-related implicit vector-truncation warnings.
#pragma warning (disable : 3206)

#if defined(FLARE_COMPUTE_OCCLUSION) || defined(FLARE_OPENGL3_OR_OPENGLCORE)
float GetLinearDepthValue(float2 uv)
{
    float depth;

#if defined(HDRP_FLARE) || defined(FLARE_PREVIEW)
    if (_ViewId >= 0)
    {
        depth = LOAD_TEXTURE2D_ARRAY_LOD(_CameraDepthTexture, uint2(uv * _ScreenSize.xy), _ViewId, 0).x;
    }
    else
    {
        depth = LOAD_TEXTURE2D_X_LOD(_CameraDepthTexture, uint2(uv * _ScreenSize.xy), 0).x;
    }

#else
    depth = LOAD_TEXTURE2D_X_LOD(_CameraDepthTexture, uint2(uv * GetScaledScreenParams().xy), 0).x;

    if (_ViewId >= 0)
    {
#if defined(DISABLE_TEXTURE2D_X_ARRAY)
        // This should never happen in theory since _ViewId can only be >= 0 IF xr is enabled and so DISABLE_TEXTURE2D_X_ARRAY is disabled.
        // We just have to manage the DISABLE_TEXTURE2D_X_ARRAY variant here for avoiding warnings.
        // HDRP does not need this because it never uses DISABLE_TEXTURE2D_X_ARRAY.
        depth = LOAD_TEXTURE2D_LOD(_CameraDepthTexture, int2(uv * GetScaledScreenParams().xy), 0).x;
#else
        depth = LOAD_TEXTURE2D_ARRAY_LOD(_CameraDepthTexture, int2(uv * GetScaledScreenParams().xy), _ViewId, 0).x;
#endif
    }
    else
        depth = LOAD_TEXTURE2D_X_LOD(_CameraDepthTexture, uint2(uv * GetScaledScreenParams().xy), 0).x;

#endif

    return LinearEyeDepth(depth, _ZBufferParams);
}

float GetOcclusion(float ratio)
{
    if (_OcclusionSampleCount == 0.0f)
        return 1.0f;

    float contrib = 0.0f;
    float sample_Contrib = 1.0f / _OcclusionSampleCount;
    float2 ratioScale = float2(1.0f / ratio, 1.0);

    for (uint i = 0; i < (uint)_OcclusionSampleCount; i++)
    {
        float2 dir = _OcclusionRadius * SampleDiskUniform(Hash(2 * i + 0), Hash(2 * i + 1));
        float2 pos0 = _ScreenPos.xy + dir;
        float2 pos = pos0 * 0.5f + 0.5f;
#ifdef UNITY_UV_STARTS_AT_TOP
        pos.y = 1.0f - pos.y;
#endif

        if (all(pos >= 0) && all(pos <= 1))
        {
            float depth0 = GetLinearDepthValue(pos);

            if (depth0 > _ScreenPosZ)
            {
                float occlusionValue = 1.0f;

#ifdef HDRP_FLARE
                if ((_FlareOcclusionPermutation & LENSFLAREOCCLUSIONPERMUTATION_FOG_OPACITY) != 0)
                {
                    float fogOcclusion;
                    if (_ViewId >= 0)
                        fogOcclusion = SAMPLE_TEXTURE2D_ARRAY_LOD(_FlareSunOcclusionTex, sampler_FlareSunOcclusionTex, pos * _RTHandleScale.xy, _ViewId, 0).x;
                    else
                        fogOcclusion = SAMPLE_TEXTURE2D_X_LOD(_FlareSunOcclusionTex, sampler_FlareSunOcclusionTex, pos * _RTHandleScale.xy, 0).x;
                    occlusionValue *= saturate(fogOcclusion);
                }
#endif

                contrib += sample_Contrib * occlusionValue;
            }
        }
        else if (_OcclusionOffscreen > 0.0f)
        {
            contrib += sample_Contrib;
        }
    }

    contrib = SAMPLE_TEXTURE2D_LOD(_FlareOcclusionRemapTex, sampler_FlareOcclusionRemapTex, float2(saturate(contrib), 0.0f), 0).x;
    contrib = saturate(contrib);

    return contrib;
}
#endif

#if defined(FLARE_COMPUTE_OCCLUSION)
VaryingsLensFlare vertOcclusion(AttributesLensFlare input, uint instanceID : SV_InstanceID)
{
    VaryingsLensFlare output;

    UNITY_SETUP_INSTANCE_ID(input);
    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);

#if defined(HDRP_FLARE) || defined(FLARE_PREVIEW)
    float screenRatio = _FlareScreenRatio;
#else
    float2 screenParam = GetScaledScreenParams().xy;
    float screenRatio = screenParam.y / screenParam.x;
#endif

    float2 quadPos = 2.0f * GetQuadVertexPosition(input.vertexID).xy - 1.0f;
    float2 uv = GetQuadTexCoord(input.vertexID);
    uv.x = 1.0f - uv.x;
    output.positionCS.xy = quadPos;

    output.texcoord.xy = uv;

    output.positionCS.z = 1.0f;
    output.positionCS.w = 1.0f;

    float occlusion = GetOcclusion(screenRatio);

    if (_OcclusionOffscreen < 0.0f && // No lens flare off screen
        (any(_ScreenPos.xy < -1) || any(_ScreenPos.xy >= 1)))
        occlusion = 0.0f;

    output.occlusion = occlusion;
    output.screenPos = output.positionCS.xy;

    return output;
}

float4 fragOcclusion(VaryingsLensFlare input) : SV_Target
{
    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);

    return float4(input.occlusion.xxx, 1.0f);
}
#else
VaryingsLensFlare vert(AttributesLensFlare input, uint instanceID : SV_InstanceID)
{
    VaryingsLensFlare output;

#ifndef FLARE_PREVIEW
    UNITY_SETUP_INSTANCE_ID(input);
    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
#endif

#if defined(HDRP_FLARE) || defined(FLARE_PREVIEW)
    float screenRatio = _FlareScreenRatio;
#else
    float2 screenParam = GetScaledScreenParams().xy;
    float screenRatio = screenParam.y / screenParam.x;
#endif

    float4 posPreScale = float4(2.0f, 2.0f, 1.0f, 1.0f) * GetQuadVertexPosition(input.vertexID) - float4(1.0f, 1.0f, 0.0f, 0.0);
    float2 uv = GetQuadTexCoord(input.vertexID);
    uv.x = 1.0f - uv.x;

    output.texcoord.xy = uv;

    posPreScale.xy *= _FlareSize;
    float2 local;
    Rotate(local, posPreScale.xy, _LocalCos0, _LocalSin0);

    local.x *= screenRatio;

    output.positionCS.xy = local + _ScreenPos + _PositionTranslate;
    output.positionCS.z = 1.0f;
    output.positionCS.w = 1.0f;

#if defined(FLARE_HAS_OCCLUSION)
    float occlusion;

    if (_OcclusionOffscreen < 0.0f && // No lens flare off screen
        (any(_ScreenPos.xy < -1.0f) || any(_ScreenPos.xy > 1.0f)))
    {
        occlusion = 0.0f;
    }
    else
    {
#if defined(FLARE_OPENGL3_OR_OPENGLCORE)

#if defined(HDRP_FLARE) || defined(FLARE_PREVIEW)
        float screenRatio = _FlareScreenRatio;
#else
        float2 screenParam = GetScaledScreenParams().xy;
        float screenRatio = screenParam.y / screenParam.x;
#endif

        occlusion = GetOcclusion(screenRatio);

#else // defined(FLARE_OPENGL3_OR_OPENGLCORE)

        if (_ViewId >= 0)
            occlusion = LOAD_TEXTURE2D_ARRAY_LOD(_FlareOcclusionTex, uint2(_FlareOcclusionIndex.x, 0), _ViewId, 0).x;
        else
            occlusion = LOAD_TEXTURE2D_ARRAY_LOD(_FlareOcclusionTex, uint2(_FlareOcclusionIndex.x, 0), 0, 0).x;

#endif // defined(FLARE_OPENGL3_OR_OPENGLCORE)
    }

    output.occlusion = occlusion;
#endif
    output.screenPos = output.positionCS.xy;

    return output;
}
#endif

// Resets LOAD_TEXTURE2D_ARRAY_LOD-related implicit vector-truncation warnings.
#pragma warning (default : 3206)

// Constrains: x in [0.0f, 1.0f]
float InverseGradient(float x)
{
    // Before:

    // Do *not* simplify as 1.0f - x
    //return x * (1.0f - x) / (x + eps);
    // Kind of equivalent of (without the edge smoothness control):
    //if (0.0f < x && x < 1.0f)
    //    return 1.0f - x;
    //else
    //    return 0.0f;

    // After:

    // Larger eps give smoother boundary-edges
    const float eps = 1e-3f;
    // cf. https://www.desmos.com/calculator/0hprry9l90
    // Rescale to always have the max at 1.0f;
    //
    // The max of 'x * (1.0f - x) / (x + eps)'
    // Is when x == sqrt(eps (1 + eps)) - eps
    // which is => 1 + 2*eps - 2*sqrt(eps*(1 + eps))
    // We can rescale by scaling with 1/maxValue
    // => x*(1 - x)/(x + eps)*(1/(1 + 2*eps - 2*sqrt(eps*(1 + eps))))
    // Simplifed as:
    // Compile-time variables:
    const float eps2 = 2.0f * eps;
    const float scale = 2.0f * sqrt(eps * (1.0f + eps));
    const float a = scale - eps2 - 1.0f;
    const float b = a * eps;

    //return x * (x - 1.0f) / (a * x + b);
    // to:
    return mad(x, x, -x) * rcp(mad(a, x, b));
}

float CircleSDF(float2 center, float2 pos, float r)
{
    return length(pos - center) - r;
}

float SDFBlocker(float2 pos, float2 screenPos, float ar, float r)
{
    float2 localPos = _ScreenPos - screenPos;
    localPos.y = -localPos.y;

    float2 offset = localPos * _FlareCutoffSpeed;

    float2 rot;
    Rotate(rot, offset, _LocalCos0, _LocalSin0);

    pos.y *= ar;

    return CircleSDF(pos, rot, _FlareCutoffRadius * r);
}

float ComputeCircle(float2 uv, float2 screenPos)
{
    float2 v = 2.0f * uv - 1.0f;

    float radius = 1.0f;
    float sdfBlocker = SDFBlocker(v, screenPos, _FlareSize.y / _FlareSize.x, radius);
    float sdfSrc = CircleSDF(v, float2(0.0f, 0.0f), radius);

    float sdf = max(sdfSrc, sdfBlocker);

    sdf = saturate(sdf / ((_FlareEdgeOffset - radius)));

#if defined(FLARE_INVERSE_SDF)
    sdf = saturate(sdf);
    sdf = InverseGradient(sdf);
#endif

    sdf = pow(saturate(sdf), _FlareFalloff);

    return sdf;
}

// Modfied from ref: https://www.shadertoy.com/view/MtKcWW
// https://www.shadertoy.com/view/3tGBDt
float ComputePolygon(float2 uv_, float2 screenPos)
{
    float2 v = 2.0f * uv_ - 1.0f;

    float r  = _FlareSDFPolyRadius;
    float an = _FlareSDFPolyParam0;
    float he = _FlareSDFPolyParam1;

    float bn = an * floor((atan2(v.y, v.x) + 0.5f * an) / an);
    float cos0 = cos(bn);
    float sin0 = sin(bn);
    float2 p = float2( cos0 * v.x + sin0 * v.y,
                      -sin0 * v.x + cos0 * v.y);

    // side of polygon
    float sdf = length(p - float2(r, clamp(p.y, -he, he))) * sign(p.x - r) - _FlareSDFRoundness;

    float sdfBlocker = SDFBlocker(v, screenPos, _FlareSize.y / _FlareSize.x, r);
    sdf = max(sdf, sdfBlocker);

    sdf *= _FlareEdgeOffset;

#if defined(FLARE_INVERSE_SDF)
    sdf = saturate(-sdf);
    sdf = InverseGradient(sdf);
#else
    sdf = saturate(-sdf);
#endif

    sdf = pow(saturate(sdf), _FlareFalloff);

    return sdf;
}

float4 Interpolation_C2_InterpAndDeriv(float2 x)
{
    return x.xyxy * x.xyxy * (x.xyxy * (x.xyxy * (x.xyxy * float2(6.0f, 0.0f).xxyy + float2(-15.0f, 30.0f).xxyy) + float2(10.0f, -60.0f).xxyy) + float2(0.0f, 30.0f).xxyy);
}

// Generates a random number for each of the 4 cell corners
float4 NoiseHash2D(float2 gridcell)
{
    float2 kOffset = float2(26.0f, 161.0f);
    float kDomain = 71.0f;
    float kLargeFloat = 1.0f / 951.135664f;

    float4 P = float4(gridcell.xy, gridcell.xy + 1.0f);
    P = P - floor(P * (1.0f / kDomain)) * kDomain;  // truncate the domain
    P += kOffset.xyxy;                              // offset to interesting part of the noise
    P *= P;                                         // calculate and return the hash
    return frac(P.xzxz * P.yyww * kLargeFloat);
}

float GenerateValueNoise2D(float2 coordinate)
{
    float2 i = floor(coordinate);
    float2 f = coordinate - i;

    float4 hash = NoiseHash2D(i);

    float4 blend = Interpolation_C2_InterpAndDeriv(f);
    float4 res0 = lerp(hash.xyxz, hash.zwyw, blend.yyxx);
    float2 resDelta = res0.yw - res0.xz;

    float noise = res0.x + resDelta.x * blend.x;

    return noise;
}

float ComputeRing(float2 uv_, float2 screenPos)
{
    float2 pos = 2.0f * uv_ - 1.0f;

#ifndef FLARE_PREVIEW
    float iTime = _Time.y;
#else
    float iTime = 0;
#endif

    float r = 1.0f;

    float ang = FastAtan2(pos.y, pos.x);

    float2 sc;
    float noiseAng = ang * _FlareNoiseFrequency;
    sincos(noiseAng, sc.x, sc.y);

    float noise = abs(abs(GenerateValueNoise2D(_FlareNoiseAmplitude * sc + _FlareElementIndex.xx + _FlareNoiseSpeed * iTime)));

    float sdfBlocker = CircleSDF(pos, float2(0.0f, 0.0f), r);
    float sdf;
    sdf = abs(CircleSDF(pos, 0.0f.xx, (1.0f - _FlareRingThickness))) - _FlareRingThickness;
    sdf = max(noise * sdf, sdfBlocker);

    sdf = saturate(sdf / ((_FlareEdgeOffset - r)));

#if defined(FLARE_INVERSE_SDF)
    sdf = saturate(sdf);
    sdf = InverseGradient(sdf);
#endif

    sdf = pow(saturate(sdf), _FlareFalloff);

    float sdfBlockerCutoff = SDFBlocker(pos, screenPos, _FlareSize.y / _FlareSize.x, 1.0f);
    sdf *= saturate(-sdfBlockerCutoff > 0.0f);

    return sdf;
}

float4 GetFlareShape(float2 uv, float2 screenPos)
{
    float4 flareColor = 1.0f;

    float shape;

    if (_FlareType == SRPLENSFLARETYPE_CIRCLE)
        shape = ComputeCircle(uv, screenPos);
    else if (_FlareType == SRPLENSFLARETYPE_POLYGON)
        shape = ComputePolygon(uv, screenPos);
    else if (_FlareType == SRPLENSFLARETYPE_RING)
        shape = ComputeRing(uv, screenPos);
    else if (_FlareType == SRPLENSFLARETYPE_IMAGE)
    {
        shape = 1.0f;
        flareColor = SAMPLE_TEXTURE2D(_FlareTex, sampler_FlareTex, uv);
        float sdfBlocker = SDFBlocker(2.0f * uv - 1.0f, screenPos, _FlareSize.y / _FlareSize.x, 1.0f);
        flareColor *= saturate(-sdfBlocker > 0.0f);
    }
    else
    {
        // Not possible, if the code execute this lines, we have a bug on the code
        // SRPLENSFLARETYPE_LENS_FLARE_DATA_SRP should never be executed
        shape = -1.0f;
    }

#if defined(HDRP_FLARE) || defined(FLARE_PREVIEW)
    float screenRatio = _FlareScreenRatio;
#else
    float2 screenParam = GetScaledScreenParams().xy;
    float screenRatio = screenParam.y / screenParam.x;
#endif

    float2 pos = 2.0f * uv - 1.0f;
    if (_IsFlareColorRadial)
    {
        float radius = length(pos);
        if (_FlareType == SRPLENSFLARETYPE_RING)
        {
            float offset = 1.0f - _FlareRingThickness;
            float a = (1.0f / clamp(2.0f * _FlareRingThickness, _FlareRingThickness, 1.0f));
            float b = 1.0f - a;
            radius = saturate(a * radius + b);
        }
        float4 grad = SAMPLE_TEXTURE2D_LOD(_FlareRadialTint, sampler_FlareRadialTint, float2(saturate(radius), 0.0f), 0);
        flareColor *= grad;
    }
    else if (_IsFlareColorAngular)
    {
        float angle01 = (atan2(pos.y, pos.x) + PI) / TWO_PI;
        float4 grad = SAMPLE_TEXTURE2D_LOD(_FlareRadialTint, sampler_FlareRadialTint, float2(saturate(angle01), 0.0f), 0);
        flareColor *= grad;
    }
    flareColor *= _FlareColorValue;
    flareColor.rgb *= _FlareIntensity;

#ifdef FLARE_ADDITIVE_BLEND
    float4 finalValue = float4(flareColor.rgb * shape, shape * flareColor.a);
#elif defined(FLARE_SCREEN_BLEND)
    float4 finalValue = float4(flareColor.rgb * shape, shape * flareColor.a);
#elif defined(FLARE_PREMULTIPLIED_BLEND)
    float4 finalValue = float4(flareColor.rgb * shape, shape * flareColor.a);
#elif defined(FLARE_LERP_BLEND)
    float4 finalValue = float4(flareColor.rgb, shape * flareColor.a);
#else
    float4 finalValue = flareColor * shape;
#endif

    return finalValue;
}

float4 frag(VaryingsLensFlare input) : SV_Target
{
#ifndef FLARE_PREVIEW
    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
#endif

#if defined(FLARE_HAS_OCCLUSION)
    if (input.occlusion > 0.0f)
    {
        float4 col = GetFlareShape(input.texcoord, input.screenPos.xy);

        return col * input.occlusion;
    }
    else
    {
        return float4(0.0f, 0.0f, 0.0f, 0.0f);
    }
#else
    float4 col = GetFlareShape(input.texcoord, input.screenPos.xy);

    return col;
#endif
}