Move third party assets to ThirdParty folder

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}