Persistent data values in shaders

Some questions: if you want the verticiets to get "brighter" (usually this means closer to white in color): why do you adjust the alpha (transparency)? To make stuff brighter I usually multiply the .rgb vector by some value greater than 1.0

You mention a "following pass" but I only see one pass in this shader. "Pass" has a very specific meaning in shaders, perhaps you meant something else? I'm not sure I understand why you can't set the brightness with a single call.

I see a _ObjectPositon variable, but I'm not sure how it is assigned a value, since there is no variable in the shader structure (up top) for it.

Suggestion:

I think you can do this in a single pass, given the distance to the object (your code looks good for this):

 float x=distance(mul(unity_ObjectToWorld, v.vertex).rgb, _ObjectPosition.rgb)

I like the infinity normalization function: 1- a/(a+x) where a is a constant that defines how fast increasing X values should scale towards one. Note: This expression will never have a value >= 1.0 (for positive X)

 float factor = 1- (1 / (1+ x));  //for x=0 factor will be close to 1 for large x factor will be close to 0
 o.vertColor.rgb= v.color.rgb * (factor*brightness);  //this COULD lead to color with a value>1.0,  might want to check and clamp them... not sure if necessary tho.

Still wrestling with this challenge and after doing some more research, I'm curious if this might be possible using a grab pass? Tried switching to vertex & fragment shader and adding a grab pass but no luck. Here's what I'm currently playing with if anyone's curious:

 Shader "Custom/Lightup-New"
 {
     Properties
     {
         _MainTex("Texture", 2D) = "white" {}
         _TexStrength("Texture Strength", Range(0, 1)) = 1
         _UnlitColor ("UnlitColor", Color) = (0,0,0,1)
         _LitColor("LitColor", Color) = (1,1,1,1)
         _BaseRadius("BaseRadius", Float) = 20
         _LightRadius("LightRadius", Float) = 40
         _Brightness ("Brightness", Float) = 1
     }
 
     SubShader
     {
 
         GrabPass{ "_GrabTexture" }
 
         Pass
         {
             CGPROGRAM
             #pragma vertex vert
             #pragma fragment frag
             #include "UnityCG.cginc"
 
             sampler2D _GrabTexture;
             float4 _ObjectPosition;
             sampler2D _MainTex;
             float _TexStrength;
             float4 _UnlitColor;
             float4 _LitColor;
             float _BaseRadius;
             float _LightRadius;
             float _Brightness;
 
             struct vertInput {
                 float4 pos : POSITION;
                 float4 color : COLOR;
                 float2 texcoord : TEXCOORD0;
             };
 
             struct vertOutput {
                 float4 pos : SV_POSITION;
                 float4 color : COLOR;
                 float2 texcoord : TEXCOORD0;
                 float4 uvgrab : TEXCOORD1;
             };
 
             vertOutput vert(vertInput input) {
                 vertOutput o;
                 UNITY_INITIALIZE_OUTPUT(vertOutput, o);
 
                 o.pos = mul(UNITY_MATRIX_MVP, input.pos);
                 o.texcoord = input.texcoord;
 
                 // Distance calculations
                 float distanceToObject = distance(mul(unity_ObjectToWorld, input.pos).xyz, _ObjectPosition.xyz);
                 float normalizedDistance = clamp (1.0 - (1.0 / (_BaseRadius-_LightRadius) * (_BaseRadius - distanceToObject)), 0, 1);
                 input.color.a = normalizedDistance * _Brightness;
                 o.color.a = input.color.a;
 
                 return o;
             }
 
             half4 frag(vertOutput output) : COLOR {
                 half4 mainTexture = tex2D(_MainTex, output.texcoord);
                 fixed4 grabTexture = tex2Dproj(_GrabTexture, UNITY_PROJ_COORD(output.uvgrab));
 
                 half4 unlitBlended = lerp(_UnlitColor, (_UnlitColor*mainTexture), _TexStrength);
                 half4 litBlended = lerp(_LitColor, (_LitColor*mainTexture), _TexStrength);
 
                 return grabTexture + lerp(unlitBlended, litBlended, output.color.a);
             }
 
             ENDCG
         }
     }
 }

Anybody have some insight into using a grab pass for this purpose? Get the impression I'm probably not using it correctly at all...

Is this something that might be possible with a compute shader? Searched high and low for a way to do this via standard shaders, but it looks like they just aren't capable of this functionality. Still a novice in this field, so it'd be great to know if this is even possible before jumping in and taking the time to experiment with compute shaders.