Best way to paint a Camera's Line of sight

Okay, I threw together a few scripts as a rudimentary self-teaching process for using Stencil buffer for this effect (For one, this means that it's probably a more expensive approach than my original link could/would have been, but my actively testing it right now says it's working). It's definitely not in a finalized state, but should serve as a potential starting point. I'll explain what I can as best as I can, but I wasn't kidding when I said I didn't have a solution prepared for this previously. The suggestions are primarily sourced from this answer by @Bunny83 on the subject of drawing Stencil Buffer shadows, since this will use exactly the same principle.

I also referenced https://docs.unity3d.com/$$anonymous$$anual/SL-Stencil.html constantly, for obvious-enough reasons.

The first script would be attached to the camera, and is based on https://docs.unity3d.com/ScriptReference/$$anonymous$$onoBehaviour.OnPostRender.html. In fact, the only real change I made was using a custom shader rather than "Hidden/Internal-Colored", but I'll get to that soon.

 // This shader attaches to a material on the camera projection-based box
 Shader "StencilWrite"
 {
     CGINCLUDE
         #include "UnityCG.cginc"
         struct appdata_t
         {
             float4 vertex : POSITION;
         };
         struct v2f
         {
             float4 vertex : SV_POSITION;
         };
         v2f vert(appdata_t v)
         {
             v2f o;
             o.vertex = UnityObjectToClipPos(v.vertex);
             return o;
         }
         fixed4 frag(v2f i) : SV_Target
         {
             return 0;
         }
     ENDCG
 
     SubShader
     {
         Tags { "RenderType"="Opaque" "Queue"="Geometry+1"}
         Pass
         {
             Blend SrcColor Zero
             ZWrite Off
             Cull front
             Color$$anonymous$$ask 0
             stencil
             {
                 Ref 2
                 Comp Always
                 Pass Keep
                 ZFail incrWrap
             }
             
             CGPROGRA$$anonymous$$
             #pragma vertex vert
             #pragma fragment frag
             #pragma target 2.0
             ENDCG
         }
 
         Pass
         {
             Blend SrcColor Zero
             ZWrite Off
             Cull back
             Color$$anonymous$$ask 0
 
             stencil
             {
                 Ref 2
                 Comp Always
                 Pass Keep
                 ZFail decrWrap
             }
 
             CGPROGRA$$anonymous$$
             #pragma vertex vert
             #pragma fragment frag
             #pragma target 2.0
             ENDCG
         }
     }
 }

(continued in next reply)

Edit: Fixed an edge case related to concave meshes

Next, we need a shader that will read back from the Stencil Buffer, which will be called on from the script (based on the OnPostRender() page). This simple example will just apply a color tint (_Color) with no fancy effects, but again, this is simply meant to be a potential starting point.

 // This shader is used in place of the Hidden Internal shader referenced in the OnPostRender() documentation
 Shader "StencilRead"
 {
     Properties
     {
         _Color("Color", Color) = (1,1,1,1)
     }
     SubShader
     {
         Tags { "Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Transparent" }
         Pass
         {
             Blend DstColor Zero
             ZWrite Off
             ZTest Always
             Cull Back
             stencil
             {
                 Ref 1
                 Comp Equal
                 Fail Replace
             }
             CGPROGRA$$anonymous$$
             #pragma vertex vert
             #pragma fragment frag
             #pragma target 2.0
             #include "UnityCG.cginc"
             struct appdata_t
             {
                 float4 vertex : POSITION;
                 float4 color : COLOR;
             };
             struct v2f
             {
                 fixed4 color : COLOR;
                 float4 vertex : SV_POSITION;
             };
             float4 _Color;
             v2f vert(appdata_t v)
             {
                 v2f o;
                 o.vertex = UnityObjectToClipPos(v.vertex);
                 o.color = v.color * _Color;
                 return o;
             }
             fixed4 frag(v2f i) : SV_Target
             {
                 return i.color;
             }
             ENDCG
         }
     }
 }

To be thorough, this is the script to go on the camera, condensed down due to using a less verbose shader:

 using UnityEngine;
 
 public class SimpleEffect : $$anonymous$$onoBehaviour
 {
     private $$anonymous$$aterial mat;
     private void OnPostRender()
     {
         if(!mat)
         {
             Shader s = Shader.Find("StencilRead");
             mat = new $$anonymous$$aterial(s);
         }
         GL.Push$$anonymous$$atrix();
         GL.LoadOrtho();
 
         mat.SetPass(0);
         GL.Begin(GL.QUADS);
         GL.Vertex3(0.0f, 0.0f, 0.0f);
         GL.Vertex3(1.0f, 0.0f, 0.0f);
         GL.Vertex3(1.0f, 1.0f, 0.0f);
         GL.Vertex3(0.0f, 1.0f, 0.0f);
         GL.End();
 
         GL.Pop$$anonymous$$atrix();
     }
 }