Shader with Brightness Limit

[Zullar]

I am working on a top-down ARPG.

2017 03 09 Gobbu Movie1

I use lighting as part of the game to limit what you can see
-Only in front of your character (or allied characters)
-Near torches
-Near graphic effects that emit light (i.e. a fireball)

However I am running into a problem where light sometimes becomes too bright and white’s out the graphics. This happens for 2 reasons.
1: Light follows the intensity = 1/x^2 inverse square law where it is extremely bright near its source and then dims proportional to distance squared as you move away from your point source. (EDIT THIS IS INCORRECT)
2: Multiple light sources overlapping

#1 and #2 are how things behave in the real word and aren’t bugs… but they don’t make the game look like I want. So really what I’m looking for is non-realistic lighting. Specifically…

A: The ability to create a custom light source. Like a point light but with intensity that fades out more gradually than a point light.
B: or a custom shader that doesn’t white out so much when things get really really bright.

Before I get started digging into this can of worms does anybody know if A or B is possible (or has already been done). Or can anybody suggest a solution to start digging into? Thanks in advance.

EDIT: It seems neither A or B is the proper way to solve this problem… but instead using Camera Post Processing

[Zullar]

For option B (a custom shader that doesn’t get too bright) I was wondering if you could make a shader that
-At 20% brightness renders as 20% bright
-At 50% brightness renders as 50% bright
-At 100% brightness renders as 100% bright
-At 200% brightness (when 2 light sources stack on top of each other) render as 120% bright instead of 200% bright
-At 300% brightness (when 3 light sources stack on top of each other) render as 135% bright instead of 300% bright

Or something along those lines.

[bgolus]

@Zullar

1: Light follows the intensity = 1/x^2 inverse square law where it is extremely bright near its source and then dims proportional to distance squared as you move away from your point source.

Unless you’re using the LWRP/URP/HDRP, or are only using per vertex lights, this is not true. Unity’s built in pipelines use completely arbitrary falloff curves based purely on the light’s range. If you were using a proper inverse square this issue would likely be happening with just a single light, not require overlapping lights.

@Zullar

A: The ability to create a custom light source. Like a point light but with intensity that fades out more gradually than a point light.

If you’re using the deferred rendering path, you can write any kind of light you want. There used to be several assets on the store that added things like area light approximations or inverse square falloff, etc. to augment or replace the built in deferred lights. This is because with deferred rendering the lighting calculation shaders and the object shaders are totally separate things and can be easily mixed and matched without necessarily having to replace all of the in-scene shader (assuming all surfaces use the same shading model and your light types can use the existing gbuffer data as is).

@Zullar

B: or a custom shader that doesn’t white out so much when things get really really bright.

Where things get complicated is even with deferred rendering, if you have anything that needs to be rendered as forward (like anything transparent, or not strictly following the expected shading model) you need a fully custom shader to handle that. A forward rendered shader has the object’s surface properties and the lighting calculations bundled together. Those assets I mentioned earlier almost all had the one “minor” caveat that they didn’t work on anything transparent.

So, if you want a custom lighting setup and want to be able to have transparent things affected by the light the same way, then you have to use a custom shader on everything.

But there’s one more big wrench in this plan. The way Unity’s lighting system works, deferred or forward, has no knowledge of more than one light at a time. You can’t write a shader that you put on an object that’ll do the kind of brightness adjustments you want because Unity’s lighting system doesn’t ever let the shaders know if there’s more than one light affecting an object!

Luckily, there is an easy solution. Render using HDR enabled on your camera and use a post process that scales the brightness over “1” down so it doesn’t blow out so quickly. You don’t even necessarily need to write one since using the post processing stack’s color grading effect should give you enough control to get something much closer to your goal.

[Zullar]

@bgolus
Thank you so much. You’ve helped me a lot over the years I appreciate it!

Will look into camera post process and see if I can get it to work.

[Zullar]

I put in a camera post process yesterday with a custom shader.

Before: No Post Process

After (Method 1): Limiting total color magnitude. (if color.mag > X then color.mag = X)

After (Method 2): Color.mag = Color.mag ^ X * brightness. With exponent X < 1 dimmer colors become brighter and brighter colors become dimmer. This makes the center of the point light dimmer… and fringes of point light brighter. Also a single light source becomes brighter than before and two overlapping bright sources become dimmer than before. Unfortunately a lot of contrast is lost.

Method 1 and Method 2 seem OK but not great.

Anyhow thought I’d share.

[Double_Boy]

Just curious what post processing effect did you use to achieve this? dealing with a similar issue

[Zullar]

It’s been a while so I don’t quite remember what I did. But I found my old script. I think I put it on a camera post-processor. It didn’t work that great and never found a good solution for this issue.

Shader "Hidden/Custom/BatLightClip"
{
    HLSLINCLUDE

#include "Packages/com.unity.postprocessing/PostProcessing/Shaders/StdLib.hlsl"

    TEXTURE2D_SAMPLER2D(_MainTex, sampler_MainTex);
    float _Brightness; //bat
    float _Exponent; //bat
    float _Blend;
    float _SoftClip;

    float4 BatFrag(VaryingsDefault i) : SV_Target
    {
        float4 color = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.texcoord);

        if (_Exponent != 1)
        {
            float colorMag = sqrt(color.r*color.r + color.g*color.g + color.b*color.b);
            float newColorMag = pow(colorMag, _Exponent);
            float colorMult = newColorMag / colorMag;
            color = float4(colorMult*color.r, colorMult*color.g, colorMult*color.b, 1); //color = GammaToLinearSpace(color); linear space to gammma space or something inbetween (0.4545 is linear --> gamma?)
        }

        if (_Blend > 0) //can be set to 0 to ignore
        {
            //float luminance = dot(color.rgb, float3(0.2126729, 0.7151522, 0.0721750));
            float colorMag = sqrt(color.r*color.r + color.g*color.g + color.b*color.b);
            if (colorMag > _Blend)
            {
                float dividerRatio = colorMag / _Blend;
                color = float4(color.r / dividerRatio, color.g / dividerRatio, color.b / dividerRatio, 1);// color / dividerRatio;
            }
        }
     
        if (_Brightness != 1)
        {
            color = float4(_Brightness*color.r, _Brightness*color.g, _Brightness*color.b, 1); //bat
        }

        if (_SoftClip > 0 )
        {
            float rgbMax = max(color.r, max(color.g, color.b));
            float rgbMaxNew = rgbMax / (rgbMax + 1);
            float colorMult = rgbMaxNew / rgbMax;
            color = float4(color.r * colorMult, color.g * colorMult, color.b * colorMult, 1);
        }

     
        return color;
    }

    ENDHLSL

    SubShader
    {
        Cull Off
        ZWrite Off
        ZTest Always

        Pass
        {
            HLSLPROGRAM
#pragma vertex VertDefault
#pragma fragment BatFrag
            ENDHLSL
        }
    }
}

and

[Serializable]
[PostProcess(typeof(BatLightClipRenderer), PostProcessEvent.AfterStack, "BatCustom/BatLightClipDropdownDescription")]
public sealed class BatLightClipSettings : PostProcessEffectSettings
{
    [Range(0f, 5f), Tooltip("Brightness")] //bat
    public FloatParameter brightness = new FloatParameter { value = 1f }; //bat

    [Range(0f, 3f), Tooltip("Exponent")] //bat
    public FloatParameter exponent = new FloatParameter { value = 1f }; //bat

    [Range(0f, 5f), Tooltip("Light Clip Intensity")]
    public FloatParameter blend = new FloatParameter { value = 0f };

    [Range(0f, 2f), Tooltip("Soft Clip")]
    public FloatParameter softClip = new FloatParameter { value = 0f }; //New 2021_03_01
}

public sealed class BatLightClipRenderer : PostProcessEffectRenderer<BatLightClipSettings>
{
    public override void Render(PostProcessRenderContext postProcessRenderContext)
    {
        PropertySheet propertySheet = postProcessRenderContext.propertySheets.Get(Shader.Find("Hidden/Custom/BatLightClip"));
        propertySheet.properties.SetFloat("_Brightness", settings.brightness);
        propertySheet.properties.SetFloat("_Exponent", settings.exponent);
        propertySheet.properties.SetFloat("_Blend", settings.blend);
        propertySheet.properties.SetFloat("_SoftClip", settings.softClip);
        postProcessRenderContext.command.BlitFullscreenTriangle(postProcessRenderContext.source, postProcessRenderContext.destination, propertySheet, 0);
    }
}