Default-Sprite with fog

I Recently Solved This Problem. Here is My Sprites-Diffuse Shader

 Shader "Sprites/Sprite-Diffuse"
 {
     Properties
     {
         [PerRendererData] _MainTex("Sprite Texture", 2D) = "white" {}
         _Color ("Tint", Color) = (1,1,1,1)
         [MaterialToggle] PixelSnap ("Pixel Snap", Float) = 1
         [PerRendererData] _AlphaTex("External Alpha", 2D) = "white" {}
         [PerRendererData] _EnableExternalAlpha ("Enable External Alpha", Float) = 0
     }
 
     SubShader
     {
         Tags{"Queue"="Transparent" "PreviewType"="Plane" "CanUseSpriteAtlas"="True"}
 
         Cull Off
         Lighting Off
         ZWrite Off
         Blend One OneMinusSrcAlpha
 
         //Pass
         //{
         CGPROGRAM
         #pragma surface surf Lambert vertex:vert nolightmap nodynlightmap keepalpha noinstancing
         #pragma multi_compile _ PIXELSNAP_ON
         #pragma multi_compile _ ETC1_EXTERNAL_ALPHA
         //#pragma multi_compile_fog
         //#include "UnityCG.cginc"
         #include "Includes/Sprites.cginc"
             
         struct Input 
         {
             float2 uv_MainTex;
             fixed4 color;
         };
 
         void vert (inout appdata_full v, out Input o)
         {
             
             #if defined(PIXELSNAP_ON)
             v.vertex = UnityPixelSnap(v.vertex);
             #endif
 
             // So Output doesnt have to be initialized?? - Does NOTHING?
             UNITY_INITIALIZE_OUTPUT(Input, o);
 
             o.color = v.color * _Color;
         }
 
         void surf(Input IN, inout SurfaceOutput o) 
         {
             fixed4 c = SampleSpriteTexture(IN.uv_MainTex) * IN.color;
             o.Albedo = c.rgb * c.a;
             o.Alpha = c.a;
         }
 
         ENDCG
         //}
     }
 
 //Fallback "Transparent/VertexLit"
 }

And I modified the "UnitySprites.cginc" include file as well which is called "Sprites.cginc" in the shader above. The modified include file is as follows:

 // Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
 
 #ifndef UNITY_SPRITES_INCLUDED
 #define UNITY_SPRITES_INCLUDED
 
 #include "UnityCG.cginc"
 
 #ifdef UNITY_INSTANCING_ENABLED
 
     UNITY_INSTANCING_CBUFFER_START(PerDrawSprite)
         // SpriteRenderer.Color while Non-Batched/Instanced.
         fixed4 unity_SpriteRendererColorArray[UNITY_INSTANCED_ARRAY_SIZE];
         // this could be smaller but that's how bit each entry is regardless of type
         float4 unity_SpriteFlipArray[UNITY_INSTANCED_ARRAY_SIZE];
     UNITY_INSTANCING_CBUFFER_END
 
     #define _RendererColor unity_SpriteRendererColorArray[unity_InstanceID]
     #define _Flip unity_SpriteFlipArray[unity_InstanceID]
 
 #endif // instancing
 
 CBUFFER_START(UnityPerDrawSprite)
 #ifndef UNITY_INSTANCING_ENABLED
     fixed4 _RendererColor;
     float4 _Flip;
 #endif
     float _EnableExternalAlpha;
 CBUFFER_END
 
 // Material Color.
 fixed4 _Color;
 
 struct appdata_t
 {
     float4 vertex   : POSITION;
     float4 color    : COLOR;
     float2 texcoord : TEXCOORD0;
     UNITY_VERTEX_INPUT_INSTANCE_ID
 };
 
 struct v2f
 {
     float4 vertex   : SV_POSITION;
     fixed4 color    : COLOR;
     float2 texcoord : TEXCOORD0;
     UNITY_FOG_COORDS(1)
     UNITY_VERTEX_OUTPUT_STEREO
 };
 
 v2f SpriteVert(appdata_t IN)
 {
     v2f OUT;
 
     UNITY_SETUP_INSTANCE_ID (IN);
     UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);
 
 #ifdef UNITY_INSTANCING_ENABLED
     IN.vertex.xy *= _Flip.xy;
 #endif
 
     OUT.vertex = UnityObjectToClipPos(IN.vertex);
     OUT.texcoord = IN.texcoord;
     OUT.color = IN.color * _Color * _RendererColor;
 
     #ifdef PIXELSNAP_ON
     OUT.vertex = UnityPixelSnap (OUT.vertex);
     #endif
 
     UNITY_TRANSFER_FOG(OUT, OUT.vertex);
 
     return OUT;
 }
 
 sampler2D _MainTex;
 sampler2D _AlphaTex;
 
 fixed4 SampleSpriteTexture (float2 uv)
 {
     fixed4 color = tex2D (_MainTex, uv);
 
 #if ETC1_EXTERNAL_ALPHA
     fixed4 alpha = tex2D (_AlphaTex, uv);
     color.a = lerp (color.a, alpha.r, _EnableExternalAlpha);
 #endif
 
     return color;
 }
 
 fixed4 SpriteFrag(v2f IN) : SV_Target
 {
     fixed4 c = SampleSpriteTexture (IN.texcoord) * IN.color;
     c.rgb *= c.a;
     
     UNITY_APPLY_FOG(IN.fogCoord, c);

     return c;
 }
 
 #endif // UNITY_SPRITES_INCLUDED

Hope this Helps.