Add ultimate xr

Assets/UltimateXR/Runtime/Shaders/FX/PlanarReflection_BRP.shader

@@ -0,0 +1,131 @@
+Shader "UltimateXR/FX/Stereo Planar Reflection (BRP)"
+{
+    Properties
+    {
+        _Color("Albedo", Color) = (1,1,1,1)
+        _MainTex ("Albedo (RGB)", 2D) = "white" {}
+	    _ReflectionColor("Reflection Color", Color) = (1,1,1,1)
+		_ReflectionBlurMask("Reflection Blur (R), Mask (G)", 2D) = "white" {}
+        _Smoothness ("Smoothness", range(0.0, 1.0)) = 1.0
+		_BlurAmount("Blur Amount", range(0.0, 1.0)) = 1.0
+        _Metallic ("Metallic (RGB) + Smoothness (A)", 2D) = "white" {}
+		[Normal]
+        _Normal ("Normal", 2D) = "bump" {}
+        _NormalIntensity("Normal Intensity", Range(0, 1)) = 1
+		_ReflectionTexLeft("ReflectionTextureLeft", 2D) = "white" {}
+		_ReflectionTexRight("ReflectionTextureRight", 2D) = "white" {}
+		_ReflectionIntensity("ReflectionIntensity", range(0.0, 1.0)) = 0.5
+		_DistortionIntensity("DistortionIntensity", range(0.0, 1.0)) = 0.0
+    }
+    SubShader
+    {
+        Tags { "RenderType"="Opaque" }
+        LOD 200
+        
+        CGPROGRAM
+
+        #pragma surface surf Standard fullforwardshadows
+        #pragma target 3.0
+
+        struct Input
+        {
+            float2 uv_MainTex;
+            float2 uv_Metallic;
+            float2 uv_Normal;
+            float2 uv_DistortionTex;
+            float4 screenPos;
+        };
+
+        int _Stereo;
+		half4 _Color;
+		half4 _ReflectionColor;
+        sampler2D _MainTex;
+		sampler2D _ReflectionBlurMask;
+        float _Smoothness;
+		float _BlurAmount;
+        float _NormalIntensity;
+        float _ReflectionMaxLODBias;
+        sampler2D _Metallic;
+        sampler2D _Normal;
+        sampler2D _ReflectionTexLeft;
+		sampler2D _ReflectionTexRight;
+        half _ReflectionIntensity;
+        half _DistortionIntensity;
+
+        #pragma instancing_options assumeuniformscaling
+        UNITY_INSTANCING_BUFFER_START(Props)
+        UNITY_INSTANCING_BUFFER_END(Props)
+
+		float4 GetPixelBlurredLeft(float2 coord, float bias)
+		{
+			float bias1 = floor(bias * _ReflectionMaxLODBias);
+			float bias2 = ceil (bias * _ReflectionMaxLODBias);
+
+			float4 value1 = tex2Dbias(_ReflectionTexLeft, float4(coord.x, coord.y, 0, bias1));
+			float4 value2 = tex2Dbias(_ReflectionTexLeft, float4(coord.x, coord.y, 0, bias2));
+
+			float t = (bias * _ReflectionMaxLODBias) - bias1;
+
+			return (value1 * (1 - t)) + (value2 * t);
+		}
+
+		half4 GetPixelBlurredRight(float2 coord, float bias)
+		{
+			return tex2Dbias(_ReflectionTexLeft, float4(coord.x, coord.y, 0, bias * _ReflectionMaxLODBias));
+		}
+
+        void surf (Input IN, inout SurfaceOutputStandard o)
+        {
+            float4 mainColor = tex2D (_MainTex, IN.uv_MainTex) * _Color;
+			float3 normal = UnpackNormal(tex2D(_Normal, IN.uv_Normal));
+
+			float4 reflectionBlurMask = tex2D(_ReflectionBlurMask, IN.uv_MainTex);
+
+		    float2 distortion   = normal.xy * _DistortionIntensity;
+            float2 screenCoords = IN.screenPos.xy / IN.screenPos.w;
+
+#if UNITY_SINGLE_PASS_STEREO
+
+			float4 scaleOffset = unity_StereoScaleOffset[unity_StereoEyeIndex];
+			screenCoords = (screenCoords - scaleOffset.zw) / scaleOffset.xy;
+            screenCoords = screenCoords + distortion;
+
+            float4 reflectionBlur;
+			float4 reflectionNoBlur;
+
+			if(unity_StereoEyeIndex == 0 && _Stereo > 0)
+			{
+				reflectionNoBlur = GetPixelBlurredLeft(screenCoords, 0.0);
+				reflectionBlur   = GetPixelBlurredLeft(screenCoords, 1.0);
+			}
+			else if(unity_StereoEyeIndex == 1 && _Stereo > 0)
+			{
+				reflectionNoBlur = GetPixelBlurredRight(screenCoords, 0.0);
+				reflectionBlur   = GetPixelBlurredRight(screenCoords, 1.0);
+			}
+
+#else
+
+            screenCoords = screenCoords + distortion;
+
+			float4 reflectionNoBlur = GetPixelBlurredLeft(screenCoords, 0.0);
+			float4 reflectionBlur   = GetPixelBlurredLeft(screenCoords, 1.0);
+
+#endif
+
+			float4 metallicSmoothness = tex2D(_Metallic, IN.uv_Metallic);
+			float blurAmount = reflectionBlurMask.r * _BlurAmount;
+
+            float4 reflection = _ReflectionIntensity * ((reflectionNoBlur * (1.0 - blurAmount)) + (reflectionBlur * blurAmount));
+			float4 albedo     = (reflectionBlurMask.g * reflection) + ((1 - reflectionBlurMask.g) * mainColor);
+
+			o.Albedo     = albedo.rgb;
+			o.Normal     = lerp(half3(0, 0, 1), normal, _NormalIntensity);
+            o.Alpha      = mainColor.a;
+			o.Metallic   = metallicSmoothness.r * (1.0 - reflectionBlurMask.g);
+			o.Smoothness = metallicSmoothness.g * (1.0 - reflectionBlurMask.g);
+        }
+        ENDCG
+    }
+    FallBack "Diffuse"
+}