Post process shader not working with GLES

I built a post process shader which is a raycaster. It works fine with DirectX and presumably OpenGL, however it does nothing with GLES. It doesn't throw an error either. I checked the compiled version and that seems to be correct.

I have the code below, but redacted some of the non interfering parts (simple computations i.e.).

My current guesses where the problem lies:

• Tex2Dlod which might need a GLES extension

• The depth texture is unsupported or disabled for GLES

• Another reason which disabled post process shader (as with depth of field shader)

• pragma target 3 is unsupported on GLES

Does anyone have any idea where the problem lies?

 Shader "Hidden/TerrainCasterQuad" {
 Properties {
     _MainTex ("Base (RGB)", 2D) = "black" {}
 }
 
 CGINCLUDE
 
     #include "UnityCG.cginc"
 
     uniform sampler2D _MainTex;
     uniform sampler2D _CameraDepthTexture;
     
     uniform float4 _MainTex_TexelSize;
     
     uniform sampler2D _HeightMap;
     uniform sampler2D _HeightMapLin;
     uniform sampler2D _ColorMap;
     
     uniform half _HeightMapSize;
     
     uniform float _Height;
     uniform half _Noise;
     uniform half _StepSize;
     uniform half _LOD;
     uniform half _Skip;
     uniform half _SkipMin;
     uniform half _Roof;
     uniform half _Scale;
     uniform half _ShadowOffset;
     uniform half _SmoothOffset;
     
     // for fast world space reconstruction
     
     uniform float4x4 _FrustumCornersWS;
     uniform float4 _CameraWS;
      
     struct v2f {
         float4 pos : POSITION;
         float2 uv : TEXCOORD0;
         float2 uv_depth : TEXCOORD1;
         float4 interpolatedRay : TEXCOORD2;
     };
     
     v2f vert( appdata_img v )
     {
         v2f o;
         half index = v.vertex.z;
         v.vertex.z = 0.1;
         o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
         o.uv = v.texcoord.xy;
         o.uv_depth = v.texcoord.xy;
         
         #if UNITY_UV_STARTS_AT_TOP
         if (_MainTex_TexelSize.y < 0)
             o.uv.y = 1-o.uv.y;
         #endif                
         
         o.interpolatedRay = _FrustumCornersWS[(int)index];
         o.interpolatedRay.w = index;
         
         return o;
     }
     
     
     
     half4 fragTerrainCaster (v2f i) : COLOR
     {
         float origDepth = LinearEyeDepth(UNITY_SAMPLE_DEPTH(tex2D(_CameraDepthTexture,i.uv_depth)));
         ...
         int loopSize = 96;
         ...
         
         if (coord.y > _Height) {
             ...
         }
         
         for(int i = 1; i < loopSize; i++) { 
             if (travDist > origDepth || coord.y > _Height) {
                 break;
             }
             
             values = tex2Dlod(_HeightMap, float4(coord.xz / _Scale,0,0)).rgb;
             
             coordY01 = coord.y / _Height;
             if (coordY01 < values.r) {
                 found = true;
                 break;
             }
 
                         ....
             
             diff += ...;
             
             travDist += diff;
             coord += dir * diff;
         }
         
         ...
         
         if (found) {
             
             return tex2Dlod(...);
         } else {
             return tex2Dlod(...); 
         }
     }
 
 
 ENDCG
 
 SubShader {
     Pass {
         ZTest Always Cull Off ZWrite Off
         Fog { Mode off }
 
         CGPROGRAM
 
         #pragma vertex vert
         #pragma fragment fragTerrainCaster
         #pragma fragmentoption ARB_precision_hint_fastest
         #pragma target 3.0
         #pragma glsl
         
         ENDCG
     }
 }
 
 Fallback off
 
 }