heres the basis of the shader, bit late but hope it helps someone

```
float ComputeLightMap(float3 LD, float4 lightmap, float frontMap, float backMap)
{
float hMap = (LD.r > 0.0f) ? (lightmap.x) : (lightmap.y); // Picks the correct horizontal side.
float vMap = (LD.g > 0.0f) ? (lightmap.z) : (lightmap.w); // Picks the correct Vertical side.
float dMap = (LD.b > 0.0f) ? (frontMap) : (backMap); // Picks the correct Front/back Pseudo Map
float lightMap = hMap*LD.r*LD.r + vMap*LD.g*LD.g + dMap*LD.b*LD.b; // Pythagoras!
return lightMap;
}
vertOutput vert (vertInput v)
{
vertOutput o;
o.texcoord = v.texcoord;
o.texcoord2 =v.texcoord.zw;
o.pos = UnityObjectToClipPos (v.vertex);
o.color = v.color * _TintColor;
o.ambient = UNITY_LIGHTMODEL_AMBIENT.rgb;
float3 WP = mul (unity_ObjectToWorld, v.vertex).xyz;
//particle world to tangent calculation
float3 normalDir = UnityObjectToWorldNormal(v.normal);
float3 tangentDir = normalize(mul(unity_ObjectToWorld, float4(v.tangent.xyz, 0.0)).xyz);
float3 bitangentDir = normalize(cross(normalDir, tangentDir) * v.tangent.w);
float3x3 worldToTangent = float3x3(tangentDir, bitangentDir, normalDir);
//directional light
float3 lightDirection = _WorldSpaceLightPos0.xyz;
o.tangentlightDir1 = mul(worldToTangent, lightDirection).rgb;
o.lightColor = _LightColor0.rgb;
//point light 1
float3 lightPos = float3(unity_4LightPosX0.x, unity_4LightPosY0.x, unity_4LightPosZ0.x);
float3 lightDirection2 = normalize(lightPos - WP.xyz);
o.tangentlightDir2 = mul(worldToTangent, lightDirection2);
//o.tangentlightDir2 *= float3(1,1,-1);
float range = (0.005 * sqrt(1000000 - unity_4LightAtten0.x)) / sqrt(unity_4LightAtten0.x);
range = distance(lightPos, WP.xyz) / range;
range = saturate(1.0 / (1.0 + 25.0*range*range) * saturate((1 - range) * 5.0));
o.lightColor2 = unity_LightColor[0].rgb * range;
o.normal = v.normal;
o.blend = v.blend;
return o;
}
fixed4 frag (vertOutput IN) : COLOR
{
//unity blend frames
half4 LightMapA = tex2D(_LightmapTex, IN.texcoord);
half4 LightMapB = tex2D(_LightmapTex, IN.texcoord2);
half4 LightMap = lerp(LightMapA, LightMapB, IN.blend);
//float4 LightMap = tex2D(_LightmapTex, IN.texcoord);
half4 AlphaMapA = tex2D(_AlphaTex, IN.texcoord);
half4 AlphaMapB = tex2D(_AlphaTex, IN.texcoord2);
half4 AlphaMap = lerp(AlphaMapA, AlphaMapB, IN.blend);
//float4 AlphaMap = tex2D(_AlphaTex, IN.texcoord);
// If you find better approximations for front and back map using the 4channel we have… I am all ears.
float frontMap = 0.25f * (LightMap.x+LightMap.y+LightMap.z+LightMap.w);
frontMap = pow(frontMap, 0.55);
float backMap = 1.0f - frontMap;
backMap = saturate(0.25*(1.0-IN.normal.x) + 0.5*(backMap*backMap*backMap*backMap));
//backMap *= 0.25;
//directional light
float3 lightDir = normalize(IN.tangentlightDir1); //light 1
float lightmap01 = ComputeLightMap(lightDir,LightMap,frontMap,backMap);
//point light
float3 lightDir2 = normalize(IN.tangentlightDir2); //light2
float lightmap02 = ComputeLightMap(lightDir2,LightMap,frontMap,backMap);
// light colors -
float3 lightmap01rgb = float3(lightmap01, lightmap01, lightmap01)*IN.lightColor;
float3 lightmap02rgb = float3(lightmap02, lightmap02, lightmap02)*IN.lightColor2;
lightmap01rgb += lightmap02rgb;
float4 heat = tex2D(_HeatGradientTex,float2((1-AlphaMap.r*IN.color.r),0));
float4 Light = float4(lightmap01rgb,AlphaMap.g*IN.color.a);
Light.rgb *= IN.lightColor + IN.lightColor2;
Light.rgb += IN.ambient;
Light.rgb *= IN.color.ggg;
Light.rgb += heat.rgb;
Light.a += AlphaMap.r *IN.color.r;
float4 d = Light ;
```