﻿
      float _EmissionIntensity;
      float _LightmapEmissionScale;
      float _Backlight;
      float4 _RGBSubPixelTex_ST;

      float4 RGBSubPixelConvert(sampler2D mainTex, sampler2D rgbTex, float2 uv0, float2 uv1, float3 viewDir, float3 worldNormal)
      {
      	//our emission map
        uv0 = round(uv0 * _RGBSubPixelTex_ST.xy) / _RGBSubPixelTex_ST.xy;
		float4 e = tex2D (mainTex, uv0);

      	//viewing angle for tilt shift
        float3 rawWorldNormal = worldNormal;
        float3 vertexNormal = mul(unity_WorldToObject, float4(rawWorldNormal, 0));
		float4 worldNormals = mul(unity_ObjectToWorld,float4(vertexNormal, 0));
        float VdotN = dot(viewDir, worldNormals);

      	//correct for gamma if being used for a VRC Stream script.
     	//ONLY on stream panels, not video panels.
    	e.rgb = lerp(e.rgb, pow(e.rgb,2.2), _ApplyGamma);

      	//do RGB pixels
        uv1 *= _RGBSubPixelTex_ST.xy + _RGBSubPixelTex_ST.zw;
        float3 rgbpixel = tex2D(rgbTex, uv1);

        float backlight = dot(rgbpixel, 0.5);
		backlight *= 0.005;
		backlight = lerp(0, backlight, _Backlight);

      	//sample the main textures color channels to derive how strong any given subpixel should be, 
      	//and then adjust the intensity of the subpixel by the color correction values
        float pixelR = ((1 + rgbpixel.r) * rgbpixel.r) * e.r;
        float pixelG = ((1 + rgbpixel.g) * rgbpixel.g) * e.g;
        float pixelB = ((1 + rgbpixel.b) * rgbpixel.b) * e.b;

      	//add the backlight, if there is any, and ensure that it only happens within
      	//the area of a subpixel. We don't want lightleak through the black areas of the texture.
        pixelR += backlight * rgbpixel.r;
        pixelG += backlight * rgbpixel.g;
        pixelB += backlight * rgbpixel.b;

      	//return all of our pixel values in a float3
        float3 pixelValue = float3(pixelR, pixelG, pixelB);

      	//do the color shift at large viewing angles, shifting to whatever color we want, based on 
      	//1 - the dot product of the viewdir and the normals, multipled, to make the dot larger.
      	//i'm sure there's a more accurate way to handle this.
        float3 screenCol = lerp(pixelValue * _EmissionIntensity, 0, max(0, (1-VdotN * 1.2)));
        
      	//if we're in the meta pass, just pass through the final color as the emission texture * the emission scale.
      	//this ensures we don't have anything else effecting our lightmap emissions (such as the tilt shifting),
      	//otherwise, we pass through the final color from above
        #ifdef UNITY_PASS_META
			float3 finalCol = e * _LightmapEmissionScale;
		#else
			float3 finalCol = screenCol;
		#endif

      	//Return it all as a float4 with an alpha of 1
        return float4(finalCol.rgb,1);
      }