Move third party assets to ThirdParty folder

Assets/ThirdParty/UltimateXR/Runtime/Shaders/BasicUnlit.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: e9da85e63bfadd14e957489dc336372d
+folderAsset: yes
+timeCreated: 1549309822
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/BasicUnlit/UnlitAdditiveTwoSided.shader

@@ -0,0 +1,70 @@
+Shader "UltimateXR/Basic Unlit/Unlit Additive Color (two-sided)"
+{
+	Properties
+	{
+		_MainTex ("Texture", 2D) = "white" {}
+		_Color("Color", Color) = (1, 1, 1, 1)
+		_Intensity("Intensity", Float) = 1.0
+	}
+	SubShader
+	{
+		Tags{ "Queue" = "Transparent" "RenderType" = "Transparent" "IgnoreProjector" = "True" }
+		LOD 100
+
+		Pass
+		{
+			Blend SrcAlpha One
+			Cull Off
+			ZWrite Off
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			
+			#include "UnityCG.cginc"
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+				float2 uv : TEXCOORD0;
+				float4 color : COLOR;
+
+				UNITY_VERTEX_INPUT_INSTANCE_ID
+			};
+
+			struct v2f
+			{
+				float4 vertex : POSITION;
+				float2 uv : TEXCOORD0;
+				float4 color : COLOR;
+
+				UNITY_VERTEX_OUTPUT_STEREO
+			};
+
+			sampler2D _MainTex;
+			float4 _MainTex_ST;
+			float4 _Color;
+			half _Intensity;
+			
+			v2f vert (appdata v)
+			{
+				v2f o;
+
+				UNITY_SETUP_INSTANCE_ID(v);
+				UNITY_INITIALIZE_OUTPUT(v2f, o);
+				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+				o.vertex = UnityObjectToClipPos(v.vertex);
+				o.uv = TRANSFORM_TEX(v.uv, _MainTex);
+				o.color = v.color;
+				return o;
+			}
+			
+			fixed4 frag (v2f i) : SV_Target
+			{
+				return tex2D(_MainTex, i.uv) * _Color * i.color * _Intensity;
+			}
+			ENDCG
+		}
+	}
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/BasicUnlit/UnlitAdditiveTwoSided.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 731f2584e4c10844e8a69c916286b057
+timeCreated: 1493198656
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/BasicUnlit/UnlitTransparentTwoSided.shader

@@ -0,0 +1,68 @@
+Shader "UltimateXR/Basic Unlit/Unlit Transparent Color (two-sided)"
+{
+	Properties
+	{
+		_MainTex ("Texture", 2D) = "white" {}
+		_Color("Color", Color) = (1, 1, 1, 1)
+	}
+	SubShader
+	{
+		Tags{ "Queue" = "Transparent" "RenderType" = "Transparent" "IgnoreProjector" = "True" }
+		LOD 100
+
+		Pass
+		{
+			Blend SrcAlpha OneMinusSrcAlpha
+			Cull Off
+			ZWrite Off
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			
+			#include "UnityCG.cginc"
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+				float4 color : COLOR;
+				float2 uv : TEXCOORD0;
+
+				UNITY_VERTEX_INPUT_INSTANCE_ID
+			};
+
+			struct v2f
+			{
+				float4 vertex : POSITION;
+				float4 color : COLOR;
+				float2 uv : TEXCOORD0;
+
+				UNITY_VERTEX_OUTPUT_STEREO
+			};
+
+			sampler2D _MainTex;
+			float4 _MainTex_ST;
+			float4 _Color;
+			
+			v2f vert (appdata v)
+			{
+				v2f o;
+
+				UNITY_SETUP_INSTANCE_ID(v);
+				UNITY_INITIALIZE_OUTPUT(v2f, o);
+				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+				o.vertex = UnityObjectToClipPos(v.vertex);
+				o.color = v.color;
+				o.uv = TRANSFORM_TEX(v.uv, _MainTex);
+				return o;
+			}
+			
+			fixed4 frag (v2f i) : SV_Target
+			{
+				return tex2D(_MainTex, i.uv) * _Color * i.color;
+			}
+			ENDCG
+		}
+	}
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/BasicUnlit/UnlitTransparentTwoSided.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 0feb5deb177ac2f4491169ffe1ed348e
+timeCreated: 1493198656
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/BasicUnlit/UnlitTransparentTwoSidedNoDepth.shader

@@ -0,0 +1,69 @@
+Shader "UltimateXR/Basic Unlit/Unlit Transparent Color (two-sided, no depth test)"
+{
+	Properties
+	{
+		_MainTex ("Texture", 2D) = "white" {}
+		_Color("Color", Color) = (1, 1, 1, 1)
+	}
+	SubShader
+	{
+		Tags{ "Queue" = "Transparent" "RenderType" = "Transparent" "IgnoreProjector" = "True" }
+		LOD 100
+
+		Pass
+		{
+			Blend SrcAlpha OneMinusSrcAlpha
+			Cull Off
+			ZWrite Off
+			ZTest Always
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			
+			#include "UnityCG.cginc"
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+				float4 color : COLOR;
+				float2 uv : TEXCOORD0;
+
+				UNITY_VERTEX_INPUT_INSTANCE_ID
+			};
+
+			struct v2f
+			{
+				float4 vertex : POSITION;
+				float4 color : COLOR;
+				float2 uv : TEXCOORD0;
+
+				UNITY_VERTEX_OUTPUT_STEREO
+			};
+
+			sampler2D _MainTex;
+			float4 _MainTex_ST;
+			float4 _Color;
+			
+			v2f vert (appdata v)
+			{
+				v2f o;
+
+				UNITY_SETUP_INSTANCE_ID(v);
+				UNITY_INITIALIZE_OUTPUT(v2f, o);
+				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+				o.vertex = UnityObjectToClipPos(v.vertex);
+				o.color = v.color;
+				o.uv = TRANSFORM_TEX(v.uv, _MainTex);
+				return o;
+			}
+			
+			fixed4 frag (v2f i) : SV_Target
+			{
+				return tex2D(_MainTex, i.uv) * _Color * i.color;
+			}
+			ENDCG
+		}
+	}
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/BasicUnlit/UnlitTransparentTwoSidedNoDepth.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 11d2f1b3cd6a7a04ba426732aa642dd7
+timeCreated: 1493198656
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/FX.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 3ebbfc89322d41046a701091deec2987
+folderAsset: yes
+timeCreated: 1549309805
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/FX/Crosshair.shader

@@ -0,0 +1,64 @@
+Shader "UltimateXR/FX/Crosshair"
+{
+	Properties
+	{
+		_MainTex ("Texture", 2D) = "white" {}
+		_Color("Color", Color) = (1, 1, 1, 1)
+	}
+	SubShader
+	{
+		Tags{ "Queue" = "Transparent+100" "RenderType" = "Transparent" "IgnoreProjector" = "True" }
+		LOD 100
+
+		Pass
+		{
+			Blend SrcAlpha OneMinusSrcAlpha
+			ZWrite Off
+			ZTest Always
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			
+			#include "UnityCG.cginc"
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+				float2 uv : TEXCOORD0;
+				float4 color : COLOR;
+			};
+
+			struct v2f
+			{
+				float4 vertex : POSITION;
+				float2 uv : TEXCOORD0;
+				float4 color : COLOR;
+			};
+
+			sampler2D _MainTex;
+			float4 _MainTex_ST;
+			float4 _Color;
+			
+			v2f vert (appdata v)
+			{
+				v2f o;
+/*
+				UNITY_SETUP_INSTANCE_ID(v);
+				UNITY_INITIALIZE_OUTPUT(v2f, o);
+				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);*/
+
+				o.vertex = UnityObjectToClipPos(v.vertex);
+				o.uv = TRANSFORM_TEX(v.uv, _MainTex);
+				o.color = v.color;
+				return o;
+			}
+			
+			fixed4 frag (v2f i) : SV_Target
+			{
+				return tex2D(_MainTex, i.uv) * _Color * i.color;
+			}
+			ENDCG
+		}
+	}
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/FX/Crosshair.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: e77fcd338db79e343a13773f944c1593
+timeCreated: 1493198656
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/FX/ElectricRay.shader

@@ -0,0 +1,105 @@
+Shader "UltimateXR/FX/Electric Ray"
+{
+	Properties
+	{
+		_MainTex                        ("Texture Main",            2D)               = "white" {}
+		[NoScaleOffset]_NoiseTex        ("Texture Noise",           2D)               = "white" {}
+		_Color                          ("Main Color",              Color)            = (1.0, 1.0, 1.0, 0.4)
+		_NoiseScale1                    ("Noise Scale 1",           Float)            = 0.1
+		_NoiseScale2                    ("Noise Scale 2",           Float)            = 0.2
+		_NoiseSpeed1                    ("Noise Speed 1",           Vector)           = (0.1, 0.1, 0, 0)
+		_NoiseSpeed2                    ("Noise Speed 2",           Vector)           = (-0.1, -0.1, 0, 0)
+		_NoiseAmplitude1                ("Noise Amplitude 1",       Float)            = 1
+		_NoiseAmplitude2                ("Noise Amplitude 2",       Float)            = 1
+	    _DistortTimeStart               ("Distort Time Start",      Float)            = 0
+	}
+	SubShader
+	{
+		Tags { "RenderType"="Transparent" "Queue"="Transparent"}
+		LOD 100
+
+		Pass
+		{
+			Blend SrcAlpha OneMinusSrcAlpha
+			Cull Off
+			ZWrite Off
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			
+			#include "UnityCG.cginc"
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+				float2 uv     : TEXCOORD0;
+				float4 color  : COLOR;
+
+				UNITY_VERTEX_INPUT_INSTANCE_ID
+			};
+
+			struct v2f
+			{
+				float2 uv     : TEXCOORD0;
+				float2 uv2    : TEXCOORD1;
+				float4 vertex : SV_POSITION;
+				float4 color  : COLOR;
+
+				UNITY_VERTEX_OUTPUT_STEREO
+			};
+
+			sampler2D _MainTex, _NoiseTex;
+			float4 _MainTex_ST;
+			half4  _Color;
+			half   _NoiseScale1, _NoiseScale2;
+			half4  _NoiseSpeed1, _NoiseSpeed2;
+			half   _NoiseAmplitude1, _NoiseAmplitude2;
+			half   _DistortTimeStart;
+			
+			v2f vert (appdata v)
+			{
+				v2f o;
+
+				UNITY_SETUP_INSTANCE_ID(v);
+				UNITY_INITIALIZE_OUTPUT(v2f, o);
+				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+				
+				o.uv     = TRANSFORM_TEX(v.uv, _MainTex);
+				o.uv2    = v.uv;
+				o.vertex = UnityObjectToClipPos(v.vertex);
+				o.color  = v.color;
+
+				return o;
+			}
+			
+			fixed4 frag (v2f i) : SV_Target
+			{
+				// Compute distort
+
+				half2 noiseUV1 = i.uv + (_NoiseSpeed1.xy * (_DistortTimeStart + _Time.y * 1.3));
+				half2 noiseUV2 = i.uv + (_NoiseSpeed2.xy * (_DistortTimeStart + _Time.y * 1.3));
+
+				half3 noise1 = tex2D(_NoiseTex, noiseUV1 * _NoiseScale1);
+				half3 noise2 = tex2D(_NoiseTex, noiseUV2 * _NoiseScale2);
+
+				half noiseGlobal = saturate(1.0 - (abs(i.uv2.x - 0.5) * 2));
+
+				noise1 = (noise1 - half3(0.5, 0.5, 0.5)) * 2 * _NoiseAmplitude1 * noiseGlobal;
+				noise2 = (noise2 - half3(0.5, 0.5, 0.5)) * 2 * _NoiseAmplitude2 * noiseGlobal;
+
+				// Compute
+
+				half u = i.uv.x;
+				half v = i.uv.y;
+
+				half4 mainTex = tex2D(_MainTex, half2(u, v) + noise1.xy + noise2.xy);
+				half3 finalRGB = mainTex.rgb * _Color.rgb * i.color.rgb;
+				half finalAlpha = mainTex.a * _Color.a * i.color.a;
+
+				return half4(finalRGB, finalAlpha);
+			}
+			ENDCG
+		}
+	}
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/FX/ElectricRay.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 12e1a6ed560fcf848b221655e274404d
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/FX/LaserDot.shader

@@ -0,0 +1,66 @@
+Shader "UltimateXR/FX/Laser Dot"
+{
+	Properties
+	{
+		_MainTex ("Texture", 2D) = "white" {}
+		_Color("Color", Color) = (1, 1, 1, 1)
+	}
+	SubShader
+	{
+		Tags{ "Queue" = "Transparent" "RenderType" = "Transparent" "IgnoreProjector" = "True" }
+		LOD 100
+
+		Pass
+		{
+			Blend SrcAlpha OneMinusSrcAlpha
+			Cull Off
+			ZWrite Off
+			ZTest Always
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			
+			#include "UnityCG.cginc"
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+				float2 uv : TEXCOORD0;
+
+				UNITY_VERTEX_INPUT_INSTANCE_ID
+			};
+
+			struct v2f
+			{
+				float4 vertex : POSITION;
+				float2 uv : TEXCOORD0;
+
+				UNITY_VERTEX_OUTPUT_STEREO
+			};
+
+			sampler2D _MainTex;
+			float4 _MainTex_ST;
+			float4 _Color;
+			
+			v2f vert (appdata v)
+			{
+				v2f o;
+
+				UNITY_SETUP_INSTANCE_ID(v);
+				UNITY_INITIALIZE_OUTPUT(v2f, o);
+				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+				o.vertex = UnityObjectToClipPos(v.vertex);
+				o.uv = TRANSFORM_TEX(v.uv, _MainTex);
+				return o;
+			}
+			
+			fixed4 frag (v2f i) : SV_Target
+			{
+				return tex2D(_MainTex, i.uv) * _Color;
+			}
+			ENDCG
+		}
+	}
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/FX/LaserDot.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: b4be7181cc8c60c43b5d27099bc6936b
+timeCreated: 1493198656
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/FX/MagnifyingGlass_URP.shader

@@ -0,0 +1,74 @@
+Shader "UltimateXR/FX/Stereo Magnifying Glass (URP)"
+{
+    Properties
+    {
+        _Color         ("Albedo",             Color) = (1,1,1,1)
+		_RenderTexLeft ("RenderTextureLeft",  2D)    = "white" {}
+		_RenderTexRight("RenderTextureRight", 2D)    = "white" {}
+    }
+    SubShader
+    {
+        Tags { "RenderType"="Opaque" }
+        LOD 200
+        
+        Pass
+		{
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			
+			#include "UnityCG.cginc"
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+				float2 uv     : TEXCOORD0;
+
+				UNITY_VERTEX_INPUT_INSTANCE_ID
+			};
+
+			struct v2f
+			{
+				float4 vertex    : POSITION;
+				float2 uv        : TEXCOORD0;
+				float4 screenPos : TEXCOORD1;
+
+				UNITY_VERTEX_OUTPUT_STEREO
+			};
+
+			half4          _Color;
+			sampler2D      _RenderTexLeft;
+			sampler2D      _RenderTexRight;
+
+			v2f vert (appdata v)
+			{
+				v2f o;
+
+				UNITY_SETUP_INSTANCE_ID(v);
+				UNITY_INITIALIZE_OUTPUT(v2f, o);
+				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+				o.vertex    = UnityObjectToClipPos(v.vertex);
+				o.uv        = v.uv;
+				o.screenPos = ComputeScreenPos(o.vertex); 
+				return o;
+			}
+
+			fixed4 frag (v2f i) : SV_Target
+			{
+				UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
+
+				half2 uv = i.screenPos.xy / i.screenPos.w;
+
+				if (unity_StereoEyeIndex == 0)
+				{
+					return _Color * tex2D(_RenderTexLeft, uv);
+				}
+
+				return _Color * tex2D(_RenderTexRight, uv);
+			}
+			
+			ENDCG
+		}
+    }
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/FX/MagnifyingGlass_URP.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 7da01d438dc385a4abcf4e565f362f14
+timeCreated: 1492442075
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/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"
+}

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

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 3c84b8f9979aeca4998593b62b361776
+timeCreated: 1492442075
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/FX/PlanarReflection_URP.shader

@@ -0,0 +1,72 @@
+Shader "UltimateXR/FX/Stereo Planar Reflection (URP)"
+{
+    Properties
+    {
+        _Color("Albedo", Color) = (1,1,1,1)
+		_ReflectionTexLeft("ReflectionTextureLeft",   2D) = "white" {}
+		_ReflectionTexRight("ReflectionTextureRight", 2D) = "white" {}
+    }
+    SubShader
+    {
+        Tags { "RenderType"="Opaque" }
+        LOD 200
+        
+        Pass
+		{
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			
+			#include "UnityCG.cginc"
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+				float2 uv     : TEXCOORD0;
+
+				UNITY_VERTEX_INPUT_INSTANCE_ID
+			};
+
+			struct v2f
+			{
+				float4 vertex    : POSITION;
+				float2 uv        : TEXCOORD0;
+				float4 screenPos : TEXCOORD1;
+
+				UNITY_VERTEX_OUTPUT_STEREO
+			};
+
+			half4     _Color;
+			sampler2D _ReflectionTexLeft;
+			sampler2D _ReflectionTexRight;
+
+			v2f vert (appdata v)
+			{
+				v2f o;
+
+				UNITY_SETUP_INSTANCE_ID(v);
+				UNITY_INITIALIZE_OUTPUT(v2f, o);
+				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+				o.vertex    = UnityObjectToClipPos(v.vertex);
+				o.uv        = v.uv;
+				o.screenPos = ComputeScreenPos(o.vertex); 
+				return o;
+			}
+
+			fixed4 frag (v2f i) : SV_Target
+			{
+				UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
+
+				if(unity_StereoEyeIndex == 0)
+				{
+					return _Color * tex2D(_ReflectionTexLeft, i.screenPos.xy / i.screenPos.w);
+				}
+				
+				return _Color * tex2D(_ReflectionTexRight, i.screenPos.xy / i.screenPos.w);
+			}
+			
+			ENDCG
+		}
+    }
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/FX/PlanarReflection_URP.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 10c10bb84d1051443b90ee354b8934ee
+timeCreated: 1492442075
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/FX/Scroll.shader

@@ -0,0 +1,73 @@
+Shader "UltimateXR/FX/Scroll Dual Texture"
+{
+	Properties
+	{
+		_MainTex    ("Texture Color+Alpha", 2D)      = "white" {}
+		_Color      ("Color Background",    Color)   = (1, 1, 1, 1)
+		_ScrollTex  ("Texture Scroll",      2D)      = "white" {}
+		_ColorScroll("Color Scroll",        Color)   = (1, 1, 1, 1)
+		_Speed      ("Scroll Speed",        Vector)  = (0, 1, 0, 0)
+	}
+	SubShader
+	{
+		Tags{ "Queue" = "Transparent" "RenderType" = "Transparent" "IgnoreProjector" = "True" }
+		LOD 100
+
+		Pass
+		{
+			Blend SrcAlpha OneMinusSrcAlpha
+			Cull Off
+			ZWrite Off
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			
+			#include "UnityCG.cginc"
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+				float2 uv     : TEXCOORD0;
+			};
+
+			struct v2f
+			{
+				float4 vertex   : POSITION;
+				float2 uv       : TEXCOORD0;
+				float2 uvScroll : TEXCOORD1;
+			};
+
+			sampler2D _MainTex;
+			float4    _MainTex_ST;
+			sampler2D _ScrollTex;
+			float4    _ScrollTex_ST;
+			float4    _Color;
+			float4    _ColorScroll;
+			float4    _Speed;
+			
+			v2f vert (appdata v)
+			{
+				v2f o;
+
+				UNITY_SETUP_INSTANCE_ID(v);
+				UNITY_INITIALIZE_OUTPUT(v2f, o);
+				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+				o.vertex   = UnityObjectToClipPos(v.vertex);
+				o.uv       = TRANSFORM_TEX(v.uv, _MainTex);
+				o.uvScroll = TRANSFORM_TEX(v.uv, _ScrollTex);
+				return o;
+			}
+			
+			fixed4 frag (v2f i) : SV_Target
+			{
+				float4 colorBackground = tex2D(_MainTex,   i.uv)       * _Color;
+				float4 colorScroll     = tex2D(_ScrollTex, i.uvScroll + (_Speed.xy * _Time.y)) * _ColorScroll;
+				float4 color = colorBackground * colorScroll;
+				return color;
+			}
+			ENDCG
+		}
+	}
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/FX/Scroll.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 662cd00258dfdef4ea3985aaaa02a19a
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/FX/Stereo Planar Reflection PBR (URP).shadergraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: a620ce3f8551e4f4a92d301b7a8fa30c
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/Hands.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: a3513f71e68e64143bd1f6605dd1a09b
+folderAsset: yes
+timeCreated: 1549309814
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/Hands/Hand.shadergraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: b696962bc2ea6924596c291ba20d1286
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/Hands/TransparentHand.shader

@@ -0,0 +1,69 @@
+Shader "UltimateXR/Hands/Transparent Hand"
+{
+	Properties
+	{
+		_Color("Color", Color) = (0.5, 0.65, 1.0, 0.4)
+		_RimPower ("Rim Power", Range(1.0, 32.0)) = 10.0
+	}
+	SubShader
+	{
+		Tags { "RenderType"="Transparent" "Queue" = "Transparent"  }
+		LOD 100
+
+		Pass
+		{
+			Blend SrcAlpha One
+			Cull Off
+			ZWrite Off
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			
+			#include "UnityCG.cginc"
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+				float3 normal : NORMAL;
+
+				UNITY_VERTEX_INPUT_INSTANCE_ID
+			};
+
+			struct v2f
+			{
+				float4 vertex : SV_POSITION;
+				float3 normal : TEXCOORD0;
+				float3 viewDir : TEXCOORD1;
+
+				UNITY_VERTEX_OUTPUT_STEREO
+			};
+
+			half4 _Color;
+			half _RimPower;
+			
+			v2f vert (appdata v)
+			{
+				v2f o;
+
+				UNITY_SETUP_INSTANCE_ID(v);
+				UNITY_INITIALIZE_OUTPUT(v2f, o);
+				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+				o.vertex = UnityObjectToClipPos(v.vertex);
+				o.normal = v.normal;
+				o.viewDir = normalize(ObjSpaceViewDir(v.vertex));
+				return o;
+			}
+			
+			fixed4 frag (v2f i) : SV_Target
+			{
+				fixed4 col = _Color;
+				col.a = cos(dot(i.normal, i.viewDir));
+				col.a = pow(col.a, _RimPower) * _Color.a;
+				return col;
+			}
+			ENDCG
+		}
+	}
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/Hands/TransparentHand.shader.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 4e49f8816b02a1e458ef5a19638e9010
+timeCreated: 1512032411
+licenseType: Pro
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/PBR.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2ede03b3d2cfeb4458fd8d7fa0589f9f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/PBR/TintedMask.shadergraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 065514bb17cd50c4a9d4bc4de5ef5bf0
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/UI.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: d5570f1f875d8244d9223000ae0a60cf
+folderAsset: yes
+timeCreated: 1549309832
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/UI/UIAdditive.shader

@@ -0,0 +1,122 @@
+// ----------------------------------------------------------------------------
+// <copyright file="AdditiveUI.shader" company="Unity Technologies / Supyrb">
+//   Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
+//   Copyright (c) 2017 Supyrb. All rights reserved.
+// </copyright>
+// <author>
+//   Johannes Deml
+//   send@johannesdeml.com
+// </author>
+// ----------------------------------------------------------------------------
+ 
+Shader "UltimateXR/UI/Additive"
+{
+    Properties
+    {
+        [PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
+        _Color ("Tint", Color) = (1,1,1,1)
+     
+        _StencilComp ("Stencil Comparison", Float) = 8
+        _Stencil ("Stencil ID", Float) = 0
+        _StencilOp ("Stencil Operation", Float) = 0
+        _StencilWriteMask ("Stencil Write Mask", Float) = 255
+        _StencilReadMask ("Stencil Read Mask", Float) = 255
+ 
+        _ColorMask ("Color Mask", Float) = 15
+ 
+        [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
+    }
+ 
+    SubShader
+    {
+        Tags
+        {
+            "Queue"="Transparent"
+            "IgnoreProjector"="True"
+            "RenderType"="Transparent"
+            "PreviewType"="Plane"
+            "CanUseSpriteAtlas"="True"
+        }
+     
+        Stencil
+        {
+            Ref [_Stencil]
+            Comp [_StencilComp]
+            Pass [_StencilOp]
+            ReadMask [_StencilReadMask]
+            WriteMask [_StencilWriteMask]
+        }
+ 
+        Cull Off
+        Lighting Off
+        ZWrite Off
+        ZTest [unity_GUIZTestMode]
+        Blend SrcAlpha One
+        ColorMask [_ColorMask]
+ 
+        Pass
+        {
+            Name "Default"
+        CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #pragma target 2.0
+ 
+            #include "UnityCG.cginc"
+            #include "UnityUI.cginc"
+ 
+            #pragma multi_compile __ UNITY_UI_ALPHACLIP
+         
+            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;
+                float4 worldPosition : TEXCOORD1;
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+         
+            fixed4 _Color;
+            fixed4 _TextureSampleAdd;
+            float4 _ClipRect;
+ 
+            v2f vert(appdata_t IN)
+            {
+                v2f OUT;
+                UNITY_SETUP_INSTANCE_ID(IN);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);
+                OUT.worldPosition = IN.vertex;
+                OUT.vertex = UnityObjectToClipPos(OUT.worldPosition);
+ 
+                OUT.texcoord = IN.texcoord;
+             
+                OUT.color = IN.color * _Color;
+                return OUT;
+            }
+ 
+            sampler2D _MainTex;
+ 
+            fixed4 frag(v2f IN) : SV_Target
+            {
+                half4 color = (tex2D(_MainTex, IN.texcoord) + _TextureSampleAdd) * IN.color;
+             
+                color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect);
+             
+                #ifdef UNITY_UI_ALPHACLIP
+                clip (color.a - 0.001);
+                #endif
+ 
+                return color;
+            }
+        ENDCG
+        }
+    }
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/UI/UIAdditive.shader.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 049fd194dc8e7194f9e809f64146958c
+timeCreated: 1534494822
+licenseType: Pro
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/UI/UIOverlayAdditive.shader

@@ -0,0 +1,122 @@
+// ----------------------------------------------------------------------------
+// <copyright file="AdditiveUI.shader" company="Unity Technologies / Supyrb">
+//   Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
+//   Copyright (c) 2017 Supyrb. All rights reserved.
+// </copyright>
+// <author>
+//   Johannes Deml
+//   send@johannesdeml.com
+// </author>
+// ----------------------------------------------------------------------------
+ 
+Shader "UltimateXR/UI/Overlay Additive"
+{
+    Properties
+    {
+        [PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
+        _Color ("Tint", Color) = (1,1,1,1)
+     
+        _StencilComp ("Stencil Comparison", Float) = 8
+        _Stencil ("Stencil ID", Float) = 0
+        _StencilOp ("Stencil Operation", Float) = 0
+        _StencilWriteMask ("Stencil Write Mask", Float) = 255
+        _StencilReadMask ("Stencil Read Mask", Float) = 255
+ 
+        _ColorMask ("Color Mask", Float) = 15
+ 
+        [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
+    }
+ 
+    SubShader
+    {
+        Tags
+        {
+            "Queue"="Overlay"
+            "IgnoreProjector"="True"
+            "RenderType"="Transparent"
+            "PreviewType"="Plane"
+            "CanUseSpriteAtlas"="True"
+        }
+     
+        Stencil
+        {
+            Ref [_Stencil]
+            Comp [_StencilComp]
+            Pass [_StencilOp]
+            ReadMask [_StencilReadMask]
+            WriteMask [_StencilWriteMask]
+        }
+ 
+        Cull Off
+        Lighting Off
+        ZWrite Off
+        ZTest Always
+        Blend SrcAlpha One
+        ColorMask [_ColorMask]
+ 
+        Pass
+        {
+            Name "Default"
+        CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #pragma target 2.0
+ 
+            #include "UnityCG.cginc"
+            #include "UnityUI.cginc"
+ 
+            #pragma multi_compile __ UNITY_UI_ALPHACLIP
+         
+            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;
+                float4 worldPosition : TEXCOORD1;
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+         
+            fixed4 _Color;
+            fixed4 _TextureSampleAdd;
+            float4 _ClipRect;
+ 
+            v2f vert(appdata_t IN)
+            {
+                v2f OUT;
+                UNITY_SETUP_INSTANCE_ID(IN);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);
+                OUT.worldPosition = IN.vertex;
+                OUT.vertex = UnityObjectToClipPos(OUT.worldPosition);
+ 
+                OUT.texcoord = IN.texcoord;
+             
+                OUT.color = IN.color * _Color;
+                return OUT;
+            }
+ 
+            sampler2D _MainTex;
+ 
+            fixed4 frag(v2f IN) : SV_Target
+            {
+                half4 color = (tex2D(_MainTex, IN.texcoord) + _TextureSampleAdd) * IN.color;
+             
+                color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect);
+             
+                #ifdef UNITY_UI_ALPHACLIP
+                clip (color.a - 0.001);
+                #endif
+ 
+                return color;
+            }
+        ENDCG
+        }
+    }
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/UI/UIOverlayAdditive.shader.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 6e52408980142f44e98c81fbc46c467d
+timeCreated: 1534494822
+licenseType: Pro
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/UI/UIOverlayAlphaBlend.shader

@@ -0,0 +1,122 @@
+// ----------------------------------------------------------------------------
+// <copyright file="AdditiveUI.shader" company="Unity Technologies / Supyrb">
+//   Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
+//   Copyright (c) 2017 Supyrb. All rights reserved.
+// </copyright>
+// <author>
+//   Johannes Deml
+//   send@johannesdeml.com
+// </author>
+// ----------------------------------------------------------------------------
+ 
+Shader "UltimateXR/UI/Overlay AlphaBlend"
+{
+    Properties
+    {
+        [PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
+        _Color ("Tint", Color) = (1,1,1,1)
+     
+        _StencilComp ("Stencil Comparison", Float) = 8
+        _Stencil ("Stencil ID", Float) = 0
+        _StencilOp ("Stencil Operation", Float) = 0
+        _StencilWriteMask ("Stencil Write Mask", Float) = 255
+        _StencilReadMask ("Stencil Read Mask", Float) = 255
+ 
+        _ColorMask ("Color Mask", Float) = 15
+ 
+        [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
+    }
+ 
+    SubShader
+    {
+        Tags
+        {
+            "Queue"="Overlay"
+            "IgnoreProjector"="True"
+            "RenderType"="Transparent"
+            "PreviewType"="Plane"
+            "CanUseSpriteAtlas"="True"
+        }
+     
+        Stencil
+        {
+            Ref [_Stencil]
+            Comp [_StencilComp]
+            Pass [_StencilOp]
+            ReadMask [_StencilReadMask]
+            WriteMask [_StencilWriteMask]
+        }
+ 
+        Cull Off
+        Lighting Off
+        ZWrite Off
+        ZTest Always
+        Blend SrcAlpha OneMinusSrcAlpha
+        ColorMask [_ColorMask]
+ 
+        Pass
+        {
+            Name "Default"
+        CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #pragma target 2.0
+ 
+            #include "UnityCG.cginc"
+            #include "UnityUI.cginc"
+ 
+            #pragma multi_compile __ UNITY_UI_ALPHACLIP
+         
+            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;
+                float4 worldPosition : TEXCOORD1;
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+         
+            fixed4 _Color;
+            fixed4 _TextureSampleAdd;
+            float4 _ClipRect;
+ 
+            v2f vert(appdata_t IN)
+            {
+                v2f OUT;
+                UNITY_SETUP_INSTANCE_ID(IN);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);
+                OUT.worldPosition = IN.vertex;
+                OUT.vertex = UnityObjectToClipPos(OUT.worldPosition);
+ 
+                OUT.texcoord = IN.texcoord;
+             
+                OUT.color = IN.color * _Color;
+                return OUT;
+            }
+ 
+            sampler2D _MainTex;
+ 
+            fixed4 frag(v2f IN) : SV_Target
+            {
+                half4 color = (tex2D(_MainTex, IN.texcoord) + _TextureSampleAdd) * IN.color;
+             
+                color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect);
+             
+                #ifdef UNITY_UI_ALPHACLIP
+                clip (color.a - 0.001);
+                #endif
+ 
+                return color;
+            }
+        ENDCG
+        }
+    }
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/UI/UIOverlayAlphaBlend.shader.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 9a81fd223199e5b41af2efbaaaa8e2ef
+timeCreated: 1534494822
+licenseType: Pro
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/Video.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 8f598a2d02c2e8c4f803d1dba5bf0578
+folderAsset: yes
+timeCreated: 1549384806
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/Video/VideoRGBTopAlphaBottomAdditive.shader

@@ -0,0 +1,64 @@
+Shader "UltimateXR/Video/Video RGB (Top) + Alpha (Bottom) Additive"
+{
+	Properties
+	{
+		_MainTex ("Texture", 2D) = "white" {}
+		_Color("Color", Color) = (1, 1, 1, 1)
+	}
+	SubShader
+	{
+		Tags{ "Queue" = "Transparent" "RenderType" = "Transparent" "IgnoreProjector" = "True" }
+		LOD 100
+
+		Pass
+		{
+			Blend SrcAlpha One
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			
+			#include "UnityCG.cginc"
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+				float2 uv     : TEXCOORD0;
+				float4 color  : COLOR;
+			};
+
+			struct v2f
+			{
+				float4 vertex : POSITION;
+				float2 uv     : TEXCOORD0;
+				float4 color  : COLOR;
+			};
+
+			sampler2D _MainTex;
+			float4    _MainTex_ST;
+			float4    _Color;
+			
+			v2f vert (appdata v)
+			{
+				v2f o;
+				o.vertex = UnityObjectToClipPos(v.vertex);
+				o.uv = TRANSFORM_TEX(v.uv, _MainTex);
+				o.color = v.color;
+				return o;
+			}
+			
+			fixed4 frag (v2f i) : SV_Target
+			{
+#if UNITY_UV_STARTS_AT_TOP
+				float4 rgb = tex2D(_MainTex, half2(i.uv.x, (i.uv.y * 0.5) + 0.5)) *_Color * i.color;
+				float  a   = tex2D(_MainTex, half2(i.uv.x, i.uv.y * 0.5)).r * _Color.a * i.color.a;
+#else
+				float4 rgb = tex2D(_MainTex, half2(i.uv.x, i.uv.y * 0.5)) *_Color * i.color;
+				float  a   = tex2D(_MainTex, half2(i.uv.x, (i.uv.y * 0.5) + 0.5)).r * _Color.a * i.color.a;
+#endif
+				return float4(rgb.rgb, a);
+			}
+			ENDCG
+		}
+	}
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/Video/VideoRGBTopAlphaBottomAdditive.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 79ed6e602aba6ca44a0efa932c839eec
+timeCreated: 1493198656
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdParty/UltimateXR/Runtime/Shaders/Video/VideoRGBTopAlphaBottomAlphaBlend.shader

@@ -0,0 +1,64 @@
+Shader "UltimateXR/Video/Video RGB (Top) + Alpha (Bottom) AlphaBlend"
+{
+	Properties
+	{
+		_MainTex ("Texture", 2D) = "white" {}
+		_Color("Color", Color) = (1, 1, 1, 1)
+	}
+	SubShader
+	{
+		Tags{ "Queue" = "Transparent" "RenderType" = "Transparent" "IgnoreProjector" = "True" }
+		LOD 100
+
+		Pass
+		{
+			Blend SrcAlpha OneMinusSrcAlpha
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			
+			#include "UnityCG.cginc"
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+				float2 uv     : TEXCOORD0;
+				float4 color  : COLOR;
+			};
+
+			struct v2f
+			{
+				float4 vertex : POSITION;
+				float2 uv     : TEXCOORD0;
+				float4 color  : COLOR;
+			};
+
+			sampler2D _MainTex;
+			float4    _MainTex_ST;
+			float4    _Color;
+			
+			v2f vert (appdata v)
+			{
+				v2f o;
+				o.vertex = UnityObjectToClipPos(v.vertex);
+				o.uv = TRANSFORM_TEX(v.uv, _MainTex);
+				o.color = v.color;
+				return o;
+			}
+			
+			fixed4 frag (v2f i) : SV_Target
+			{
+#if UNITY_UV_STARTS_AT_TOP
+				float4 rgb = tex2D(_MainTex, half2(i.uv.x, (i.uv.y * 0.5) + 0.5)) *_Color * i.color;
+				float  a   = tex2D(_MainTex, half2(i.uv.x, i.uv.y * 0.5)).r * _Color.a * i.color.a;
+#else
+				float4 rgb = tex2D(_MainTex, half2(i.uv.x, i.uv.y * 0.5)) *_Color * i.color;
+				float  a   = tex2D(_MainTex, half2(i.uv.x, (i.uv.y * 0.5) + 0.5)).r * _Color.a * i.color.a;
+#endif
+				return float4(rgb.rgb, a);
+			}
+			ENDCG
+		}
+	}
+}

Assets/ThirdParty/UltimateXR/Runtime/Shaders/Video/VideoRGBTopAlphaBottomAlphaBlend.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 0a9830b3adbf6f34a876279f96f1c45c
+timeCreated: 1493198656
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: