Import TextMesh Pro.

Assets/Resources/TextMesh Pro.meta

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

Assets/Resources/TextMesh Pro/Shaders.meta

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

Assets/Resources/TextMesh Pro/Shaders/TMP_Bitmap-Custom-Atlas.shader

@@ -0,0 +1,143 @@
+Shader "TextMeshPro/Bitmap Custom Atlas" {
+
+Properties {
+	_MainTex		("Font Atlas", 2D) = "white" {}
+	_FaceTex		("Font Texture", 2D) = "white" {}
+	[HDR]_FaceColor	("Text Color", Color) = (1,1,1,1)
+
+	_VertexOffsetX	("Vertex OffsetX", float) = 0
+	_VertexOffsetY	("Vertex OffsetY", float) = 0
+	_MaskSoftnessX	("Mask SoftnessX", float) = 0
+	_MaskSoftnessY	("Mask SoftnessY", float) = 0
+
+	_ClipRect("Clip Rect", vector) = (-32767, -32767, 32767, 32767)
+	_Padding		("Padding", float) = 0
+
+	_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
+
+	_CullMode("Cull Mode", Float) = 0
+	_ColorMask("Color Mask", Float) = 15
+}
+
+SubShader{
+
+	Tags { "Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Transparent" }
+
+	Stencil
+	{
+		Ref[_Stencil]
+		Comp[_StencilComp]
+		Pass[_StencilOp]
+		ReadMask[_StencilReadMask]
+		WriteMask[_StencilWriteMask]
+	}
+
+
+	Lighting Off
+	Cull [_CullMode]
+	ZTest [unity_GUIZTestMode]
+	ZWrite Off
+	Fog { Mode Off }
+	Blend SrcAlpha OneMinusSrcAlpha
+	ColorMask[_ColorMask]
+
+	Pass {
+		CGPROGRAM
+		#pragma vertex vert
+		#pragma fragment frag
+
+		#pragma multi_compile __ UNITY_UI_CLIP_RECT
+		#pragma multi_compile __ UNITY_UI_ALPHACLIP
+
+
+		#include "UnityCG.cginc"
+
+		struct appdata_t {
+			float4 vertex		: POSITION;
+			fixed4 color		: COLOR;
+			float2 texcoord0	: TEXCOORD0;
+			float2 texcoord1	: TEXCOORD1;
+		};
+
+		struct v2f {
+			float4	vertex		: SV_POSITION;
+			fixed4	color		: COLOR;
+			float2	texcoord0	: TEXCOORD0;
+			float2	texcoord1	: TEXCOORD1;
+			float4	mask		: TEXCOORD2;
+		};
+
+		uniform	sampler2D 	_MainTex;
+		uniform	sampler2D 	_FaceTex;
+		uniform float4		_FaceTex_ST;
+		uniform	fixed4		_FaceColor;
+
+		uniform float		_VertexOffsetX;
+		uniform float		_VertexOffsetY;
+		uniform float4		_ClipRect;
+		uniform float		_MaskSoftnessX;
+		uniform float		_MaskSoftnessY;
+
+		float2 UnpackUV(float uv)
+		{
+			float2 output;
+			output.x = floor(uv / 4096);
+			output.y = uv - 4096 * output.x;
+
+			return output * 0.001953125;
+		}
+
+		v2f vert (appdata_t v)
+		{
+			float4 vert = v.vertex;
+			vert.x += _VertexOffsetX;
+			vert.y += _VertexOffsetY;
+
+			vert.xy += (vert.w * 0.5) / _ScreenParams.xy;
+
+			float4 vPosition = UnityPixelSnap(UnityObjectToClipPos(vert));
+
+			fixed4 faceColor = v.color;
+			faceColor *= _FaceColor;
+
+			v2f OUT;
+			OUT.vertex = vPosition;
+			OUT.color = faceColor;
+			OUT.texcoord0 = v.texcoord0;
+			OUT.texcoord1 = TRANSFORM_TEX(UnpackUV(v.texcoord1), _FaceTex);
+			float2 pixelSize = vPosition.w;
+			pixelSize /= abs(float2(_ScreenParams.x * UNITY_MATRIX_P[0][0], _ScreenParams.y * UNITY_MATRIX_P[1][1]));
+
+			// Clamp _ClipRect to 16bit.
+			float4 clampedRect = clamp(_ClipRect, -2e10, 2e10);
+			OUT.mask = float4(vert.xy * 2 - clampedRect.xy - clampedRect.zw, 0.25 / (0.25 * half2(_MaskSoftnessX, _MaskSoftnessY) + pixelSize.xy));
+
+			return OUT;
+		}
+
+		fixed4 frag (v2f IN) : SV_Target
+		{
+			fixed4 color = tex2D(_MainTex, IN.texcoord0) * tex2D(_FaceTex, IN.texcoord1) * IN.color;
+
+			// Alternative implementation to UnityGet2DClipping with support for softness.
+			#if UNITY_UI_CLIP_RECT
+				half2 m = saturate((_ClipRect.zw - _ClipRect.xy - abs(IN.mask.xy)) * IN.mask.zw);
+				color *= m.x * m.y;
+			#endif
+
+			#if UNITY_UI_ALPHACLIP
+				clip(color.a - 0.001);
+			#endif
+
+			return color;
+		}
+		ENDCG
+	}
+}
+
+	CustomEditor "TMPro.EditorUtilities.TMP_BitmapShaderGUI"
+}

Assets/Resources/TextMesh Pro/Shaders/TMP_Bitmap-Custom-Atlas.shader.meta

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

Assets/Resources/TextMesh Pro/Shaders/TMP_Bitmap-Mobile.shader

@@ -0,0 +1,145 @@
+Shader "TextMeshPro/Mobile/Bitmap" {
+
+Properties {
+	_MainTex		("Font Atlas", 2D) = "white" {}
+	[HDR]_Color		("Text Color", Color) = (1,1,1,1)
+	_DiffusePower	("Diffuse Power", Range(1.0,4.0)) = 1.0
+
+	_VertexOffsetX("Vertex OffsetX", float) = 0
+	_VertexOffsetY("Vertex OffsetY", float) = 0
+	_MaskSoftnessX("Mask SoftnessX", float) = 0
+	_MaskSoftnessY("Mask SoftnessY", float) = 0
+
+	_ClipRect("Clip Rect", vector) = (-32767, -32767, 32767, 32767)
+
+	_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
+
+	_CullMode("Cull Mode", Float) = 0
+	_ColorMask("Color Mask", Float) = 15
+}
+
+SubShader {
+
+	Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+
+	Stencil
+	{
+		Ref[_Stencil]
+		Comp[_StencilComp]
+		Pass[_StencilOp]
+		ReadMask[_StencilReadMask]
+		WriteMask[_StencilWriteMask]
+	}
+
+
+	Lighting Off
+	Cull [_CullMode]
+	ZTest [unity_GUIZTestMode]
+	ZWrite Off
+	Fog { Mode Off }
+	Blend SrcAlpha OneMinusSrcAlpha
+	ColorMask[_ColorMask]
+
+	Pass {
+		CGPROGRAM
+		#pragma vertex vert
+		#pragma fragment frag
+		#pragma fragmentoption ARB_precision_hint_fastest
+
+		#pragma multi_compile __ UNITY_UI_CLIP_RECT
+		#pragma multi_compile __ UNITY_UI_ALPHACLIP
+
+
+		#include "UnityCG.cginc"
+
+		struct appdata_t {
+			float4 vertex : POSITION;
+			fixed4 color : COLOR;
+			float2 texcoord0 : TEXCOORD0;
+			float2 texcoord1 : TEXCOORD1;
+		};
+
+		struct v2f {
+			float4 vertex		: POSITION;
+			fixed4 color		: COLOR;
+			float2 texcoord0	: TEXCOORD0;
+			float4 mask			: TEXCOORD2;
+		};
+
+		sampler2D 	_MainTex;
+		fixed4		_Color;
+		float		_DiffusePower;
+
+		uniform float		_VertexOffsetX;
+		uniform float		_VertexOffsetY;
+		uniform float4		_ClipRect;
+		uniform float		_MaskSoftnessX;
+		uniform float		_MaskSoftnessY;
+
+		v2f vert (appdata_t v)
+		{
+			v2f OUT;
+			float4 vert = v.vertex;
+			vert.x += _VertexOffsetX;
+			vert.y += _VertexOffsetY;
+
+			vert.xy += (vert.w * 0.5) / _ScreenParams.xy;
+
+			OUT.vertex = UnityPixelSnap(UnityObjectToClipPos(vert));
+			OUT.color = v.color;
+			OUT.color *= _Color;
+			OUT.color.rgb *= _DiffusePower;
+			OUT.texcoord0 = v.texcoord0;
+
+			float2 pixelSize = OUT.vertex.w;
+			//pixelSize /= abs(float2(_ScreenParams.x * UNITY_MATRIX_P[0][0], _ScreenParams.y * UNITY_MATRIX_P[1][1]));
+
+			// Clamp _ClipRect to 16bit.
+			float4 clampedRect = clamp(_ClipRect, -2e10, 2e10);
+			OUT.mask = float4(vert.xy * 2 - clampedRect.xy - clampedRect.zw, 0.25 / (0.25 * half2(_MaskSoftnessX, _MaskSoftnessY) + pixelSize.xy));
+
+			return OUT;
+		}
+
+		fixed4 frag (v2f IN) : COLOR
+		{
+			fixed4 color = fixed4(IN.color.rgb, IN.color.a * tex2D(_MainTex, IN.texcoord0).a);
+
+			// Alternative implementation to UnityGet2DClipping with support for softness.
+			#if UNITY_UI_CLIP_RECT
+				half2 m = saturate((_ClipRect.zw - _ClipRect.xy - abs(IN.mask.xy)) * IN.mask.zw);
+				color *= m.x * m.y;
+			#endif
+
+			#if UNITY_UI_ALPHACLIP
+				clip(color.a - 0.001);
+			#endif
+
+			return color;
+		}
+		ENDCG
+	}
+}
+
+SubShader {
+	Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+	Lighting Off Cull Off ZTest Always ZWrite Off Fog { Mode Off }
+	Blend SrcAlpha OneMinusSrcAlpha
+	BindChannels {
+		Bind "Color", color
+		Bind "Vertex", vertex
+		Bind "TexCoord", texcoord0
+	}
+	Pass {
+		SetTexture [_MainTex] {
+			constantColor [_Color] combine constant * primary, constant * texture
+		}
+	}
+}
+
+CustomEditor "TMPro.EditorUtilities.TMP_BitmapShaderGUI"
+}

Assets/Resources/TextMesh Pro/Shaders/TMP_Bitmap-Mobile.shader.meta

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

Assets/Resources/TextMesh Pro/Shaders/TMP_Bitmap.shader

@@ -0,0 +1,143 @@
+Shader "TextMeshPro/Bitmap" {
+
+Properties {
+	_MainTex		("Font Atlas", 2D) = "white" {}
+	_FaceTex		("Font Texture", 2D) = "white" {}
+	[HDR]_FaceColor	("Text Color", Color) = (1,1,1,1)
+
+	_VertexOffsetX	("Vertex OffsetX", float) = 0
+	_VertexOffsetY	("Vertex OffsetY", float) = 0
+	_MaskSoftnessX	("Mask SoftnessX", float) = 0
+	_MaskSoftnessY	("Mask SoftnessY", float) = 0
+
+	_ClipRect("Clip Rect", vector) = (-32767, -32767, 32767, 32767)
+
+	_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
+
+	_CullMode("Cull Mode", Float) = 0
+	_ColorMask("Color Mask", Float) = 15
+}
+
+SubShader{
+
+	Tags { "Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Transparent" }
+
+	Stencil
+	{
+		Ref[_Stencil]
+		Comp[_StencilComp]
+		Pass[_StencilOp]
+		ReadMask[_StencilReadMask]
+		WriteMask[_StencilWriteMask]
+	}
+
+
+	Lighting Off
+	Cull [_CullMode]
+	ZTest [unity_GUIZTestMode]
+	ZWrite Off
+	Fog { Mode Off }
+	Blend SrcAlpha OneMinusSrcAlpha
+	ColorMask[_ColorMask]
+
+	Pass {
+		CGPROGRAM
+		#pragma vertex vert
+		#pragma fragment frag
+
+		#pragma multi_compile __ UNITY_UI_CLIP_RECT
+		#pragma multi_compile __ UNITY_UI_ALPHACLIP
+
+
+		#include "UnityCG.cginc"
+
+		struct appdata_t {
+			float4 vertex		: POSITION;
+			fixed4 color		: COLOR;
+			float2 texcoord0	: TEXCOORD0;
+			float2 texcoord1	: TEXCOORD1;
+		};
+
+		struct v2f {
+			float4	vertex		: SV_POSITION;
+			fixed4	color		: COLOR;
+			float2	texcoord0	: TEXCOORD0;
+			float2	texcoord1	: TEXCOORD1;
+			float4	mask		: TEXCOORD2;
+		};
+
+		uniform	sampler2D 	_MainTex;
+		uniform	sampler2D 	_FaceTex;
+		uniform float4		_FaceTex_ST;
+		uniform	fixed4		_FaceColor;
+
+		uniform float		_VertexOffsetX;
+		uniform float		_VertexOffsetY;
+		uniform float4		_ClipRect;
+		uniform float		_MaskSoftnessX;
+		uniform float		_MaskSoftnessY;
+
+		float2 UnpackUV(float uv)
+		{
+			float2 output;
+			output.x = floor(uv / 4096);
+			output.y = uv - 4096 * output.x;
+
+			return output * 0.001953125;
+		}
+
+		v2f vert (appdata_t v)
+		{
+			float4 vert = v.vertex;
+			vert.x += _VertexOffsetX;
+			vert.y += _VertexOffsetY;
+
+			vert.xy += (vert.w * 0.5) / _ScreenParams.xy;
+
+			float4 vPosition = UnityPixelSnap(UnityObjectToClipPos(vert));
+
+			fixed4 faceColor = v.color;
+			faceColor *= _FaceColor;
+
+			v2f OUT;
+			OUT.vertex = vPosition;
+			OUT.color = faceColor;
+			OUT.texcoord0 = v.texcoord0;
+			OUT.texcoord1 = TRANSFORM_TEX(UnpackUV(v.texcoord1), _FaceTex);
+			float2 pixelSize = vPosition.w;
+			pixelSize /= abs(float2(_ScreenParams.x * UNITY_MATRIX_P[0][0], _ScreenParams.y * UNITY_MATRIX_P[1][1]));
+
+			// Clamp _ClipRect to 16bit.
+			float4 clampedRect = clamp(_ClipRect, -2e10, 2e10);
+			OUT.mask = float4(vert.xy * 2 - clampedRect.xy - clampedRect.zw, 0.25 / (0.25 * half2(_MaskSoftnessX, _MaskSoftnessY) + pixelSize.xy));
+
+			return OUT;
+		}
+
+		fixed4 frag (v2f IN) : SV_Target
+		{
+			fixed4 color = tex2D(_MainTex, IN.texcoord0);
+			color = fixed4 (tex2D(_FaceTex, IN.texcoord1).rgb * IN.color.rgb, IN.color.a * color.a);
+
+			// Alternative implementation to UnityGet2DClipping with support for softness.
+			#if UNITY_UI_CLIP_RECT
+				half2 m = saturate((_ClipRect.zw - _ClipRect.xy - abs(IN.mask.xy)) * IN.mask.zw);
+				color *= m.x * m.y;
+			#endif
+
+			#if UNITY_UI_ALPHACLIP
+				clip(color.a - 0.001);
+			#endif
+
+			return color;
+		}
+		ENDCG
+	}
+}
+
+	CustomEditor "TMPro.EditorUtilities.TMP_BitmapShaderGUI"
+}

Assets/Resources/TextMesh Pro/Shaders/TMP_Bitmap.shader.meta

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

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF Overlay.shader.meta

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

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF SSD.shader.meta

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

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF-Mobile Masking.shader

@@ -0,0 +1,247 @@
+// Simplified SDF shader:
+// - No Shading Option (bevel / bump / env map)
+// - No Glow Option
+// - Softness is applied on both side of the outline
+
+Shader "TextMeshPro/Mobile/Distance Field - Masking" {
+
+Properties {
+	[HDR]_FaceColor		("Face Color", Color) = (1,1,1,1)
+	_FaceDilate			("Face Dilate", Range(-1,1)) = 0
+
+	[HDR]_OutlineColor	("Outline Color", Color) = (0,0,0,1)
+	_OutlineWidth		("Outline Thickness", Range(0,1)) = 0
+	_OutlineSoftness	("Outline Softness", Range(0,1)) = 0
+
+	[HDR]_UnderlayColor	("Border Color", Color) = (0,0,0,.5)
+	_UnderlayOffsetX 	("Border OffsetX", Range(-1,1)) = 0
+	_UnderlayOffsetY 	("Border OffsetY", Range(-1,1)) = 0
+	_UnderlayDilate		("Border Dilate", Range(-1,1)) = 0
+	_UnderlaySoftness 	("Border Softness", Range(0,1)) = 0
+
+	_WeightNormal		("Weight Normal", float) = 0
+	_WeightBold			("Weight Bold", float) = .5
+
+	_ShaderFlags		("Flags", float) = 0
+	_ScaleRatioA		("Scale RatioA", float) = 1
+	_ScaleRatioB		("Scale RatioB", float) = 1
+	_ScaleRatioC		("Scale RatioC", float) = 1
+
+	_MainTex			("Font Atlas", 2D) = "white" {}
+	_TextureWidth		("Texture Width", float) = 512
+	_TextureHeight		("Texture Height", float) = 512
+	_GradientScale		("Gradient Scale", float) = 5
+	_ScaleX				("Scale X", float) = 1
+	_ScaleY				("Scale Y", float) = 1
+	_PerspectiveFilter	("Perspective Correction", Range(0, 1)) = 0.875
+	_Sharpness			("Sharpness", Range(-1,1)) = 0
+
+	_VertexOffsetX		("Vertex OffsetX", float) = 0
+	_VertexOffsetY		("Vertex OffsetY", float) = 0
+
+	_ClipRect			("Clip Rect", vector) = (-32767, -32767, 32767, 32767)
+	_MaskSoftnessX		("Mask SoftnessX", float) = 0
+	_MaskSoftnessY		("Mask SoftnessY", float) = 0
+	_MaskTex			("Mask Texture", 2D) = "white" {}
+	_MaskInverse		("Inverse", float) = 0
+	_MaskEdgeColor		("Edge Color", Color) = (1,1,1,1)
+	_MaskEdgeSoftness	("Edge Softness", Range(0, 1)) = 0.01
+	_MaskWipeControl	("Wipe Position", Range(0, 1)) = 0.5
+
+	_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
+
+	_CullMode			("Cull Mode", Float) = 0
+	_ColorMask			("Color Mask", Float) = 15
+}
+
+SubShader {
+	Tags
+	{
+		"Queue"="Transparent"
+		"IgnoreProjector"="True"
+		"RenderType"="Transparent"
+	}
+
+
+	Stencil
+	{
+		Ref [_Stencil]
+		Comp [_StencilComp]
+		Pass [_StencilOp]
+		ReadMask [_StencilReadMask]
+		WriteMask [_StencilWriteMask]
+	}
+
+	Cull [_CullMode]
+	ZWrite Off
+	Lighting Off
+	Fog { Mode Off }
+	ZTest [unity_GUIZTestMode]
+	Blend One OneMinusSrcAlpha
+	ColorMask [_ColorMask]
+
+	Pass {
+		CGPROGRAM
+		#pragma vertex VertShader
+		#pragma fragment PixShader
+		#pragma shader_feature __ OUTLINE_ON
+		#pragma shader_feature __ UNDERLAY_ON UNDERLAY_INNER
+
+		#pragma multi_compile __ UNITY_UI_CLIP_RECT
+		#pragma multi_compile __ UNITY_UI_ALPHACLIP
+
+
+		#include "UnityCG.cginc"
+		#include "UnityUI.cginc"
+		#include "TMPro_Properties.cginc"
+
+		struct vertex_t {
+			float4	vertex			: POSITION;
+			float3	normal			: NORMAL;
+			fixed4	color			: COLOR;
+			float2	texcoord0		: TEXCOORD0;
+			float2	texcoord1		: TEXCOORD1;
+		};
+
+		struct pixel_t {
+			float4	vertex			: SV_POSITION;
+			fixed4	faceColor		: COLOR;
+			fixed4	outlineColor	: COLOR1;
+			float4	texcoord0		: TEXCOORD0;			// Texture UV, Mask UV
+			half4	param			: TEXCOORD1;			// Scale(x), BiasIn(y), BiasOut(z), Bias(w)
+			half4	mask			: TEXCOORD2;			// Position in clip space(xy), Softness(zw)
+		#if (UNDERLAY_ON | UNDERLAY_INNER)
+			float4	texcoord1		: TEXCOORD3;			// Texture UV, alpha, reserved
+			half2	underlayParam	: TEXCOORD4;			// Scale(x), Bias(y)
+		#endif
+		};
+
+		float _MaskWipeControl;
+		float _MaskEdgeSoftness;
+		fixed4 _MaskEdgeColor;
+		bool _MaskInverse;
+
+		pixel_t VertShader(vertex_t input)
+		{
+			float bold = step(input.texcoord1.y, 0);
+
+			float4 vert = input.vertex;
+			vert.x += _VertexOffsetX;
+			vert.y += _VertexOffsetY;
+			float4 vPosition = UnityObjectToClipPos(vert);
+
+			float2 pixelSize = vPosition.w;
+			pixelSize /= float2(_ScaleX, _ScaleY) * abs(mul((float2x2)UNITY_MATRIX_P, _ScreenParams.xy));
+
+			float scale = rsqrt(dot(pixelSize, pixelSize));
+			scale *= abs(input.texcoord1.y) * _GradientScale * (_Sharpness + 1);
+			if(UNITY_MATRIX_P[3][3] == 0) scale = lerp(abs(scale) * (1 - _PerspectiveFilter), scale, abs(dot(UnityObjectToWorldNormal(input.normal.xyz), normalize(WorldSpaceViewDir(vert)))));
+
+			float weight = lerp(_WeightNormal, _WeightBold, bold) / 4.0;
+			weight = (weight + _FaceDilate) * _ScaleRatioA * 0.5;
+
+			float layerScale = scale;
+
+			scale /= 1 + (_OutlineSoftness * _ScaleRatioA * scale);
+			float bias = (0.5 - weight) * scale - 0.5;
+			float outline = _OutlineWidth * _ScaleRatioA * 0.5 * scale;
+
+			float opacity = input.color.a;
+					#if (UNDERLAY_ON | UNDERLAY_INNER)
+					opacity = 1.0;
+					#endif
+
+			fixed4 faceColor = fixed4(input.color.rgb, opacity) * _FaceColor;
+			faceColor.rgb *= faceColor.a;
+
+			fixed4 outlineColor = _OutlineColor;
+			outlineColor.a *= opacity;
+			outlineColor.rgb *= outlineColor.a;
+			outlineColor = lerp(faceColor, outlineColor, sqrt(min(1.0, (outline * 2))));
+
+		#if (UNDERLAY_ON | UNDERLAY_INNER)
+
+			layerScale /= 1 + ((_UnderlaySoftness * _ScaleRatioC) * layerScale);
+			float layerBias = (.5 - weight) * layerScale - .5 - ((_UnderlayDilate * _ScaleRatioC) * .5 * layerScale);
+
+			float x = -(_UnderlayOffsetX * _ScaleRatioC) * _GradientScale / _TextureWidth;
+			float y = -(_UnderlayOffsetY * _ScaleRatioC) * _GradientScale / _TextureHeight;
+			float2 layerOffset = float2(x, y);
+		#endif
+
+			// Generate UV for the Masking Texture
+			float4 clampedRect = clamp(_ClipRect, -2e10, 2e10);
+			float2 maskUV = (vert.xy - clampedRect.xy) / (clampedRect.zw - clampedRect.xy);
+
+			// Structure for pixel shader
+			pixel_t output = {
+				vPosition,
+				faceColor,
+				outlineColor,
+				float4(input.texcoord0.x, input.texcoord0.y, maskUV.x, maskUV.y),
+				half4(scale, bias - outline, bias + outline, bias),
+				half4(vert.xy * 2 - clampedRect.xy - clampedRect.zw, 0.25 / (0.25 * half2(_MaskSoftnessX, _MaskSoftnessY) + pixelSize.xy)),
+			#if (UNDERLAY_ON | UNDERLAY_INNER)
+				float4(input.texcoord0 + layerOffset, input.color.a, 0),
+				half2(layerScale, layerBias),
+			#endif
+			};
+
+			return output;
+		}
+
+
+		// PIXEL SHADER
+		fixed4 PixShader(pixel_t input) : SV_Target
+		{
+			half d = tex2D(_MainTex, input.texcoord0.xy).a * input.param.x;
+			half4 c = input.faceColor * saturate(d - input.param.w);
+
+		#ifdef OUTLINE_ON
+			c = lerp(input.outlineColor, input.faceColor, saturate(d - input.param.z));
+			c *= saturate(d - input.param.y);
+		#endif
+
+		#if UNDERLAY_ON
+			d = tex2D(_MainTex, input.texcoord1.xy).a * input.underlayParam.x;
+			c += float4(_UnderlayColor.rgb * _UnderlayColor.a, _UnderlayColor.a) * saturate(d - input.underlayParam.y) * (1 - c.a);
+		#endif
+
+		#if UNDERLAY_INNER
+			half sd = saturate(d - input.param.z);
+			d = tex2D(_MainTex, input.texcoord1.xy).a * input.underlayParam.x;
+			c += float4(_UnderlayColor.rgb * _UnderlayColor.a, _UnderlayColor.a) * (1 - saturate(d - input.underlayParam.y)) * sd * (1 - c.a);
+		#endif
+
+		// Alternative implementation to UnityGet2DClipping with support for softness.
+		//#if UNITY_UI_CLIP_RECT
+			half2 m = saturate((_ClipRect.zw - _ClipRect.xy - abs(input.mask.xy)) * input.mask.zw);
+			c *= m.x * m.y;
+		//#endif
+
+		float a = abs(_MaskInverse - tex2D(_MaskTex, input.texcoord0.zw).a);
+		float t = a + (1 - _MaskWipeControl) * _MaskEdgeSoftness - _MaskWipeControl;
+		a = saturate(t / _MaskEdgeSoftness);
+		c.rgb = lerp(_MaskEdgeColor.rgb*c.a, c.rgb, a);
+		c *= a;
+
+		#if (UNDERLAY_ON | UNDERLAY_INNER)
+			c *= input.texcoord1.z;
+		#endif
+
+    #if UNITY_UI_ALPHACLIP
+			clip(c.a - 0.001);
+		#endif
+
+			return c;
+		}
+		ENDCG
+	}
+}
+
+CustomEditor "TMPro.EditorUtilities.TMP_SDFShaderGUI"
+}

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF-Mobile Masking.shader.meta

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

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF-Mobile Overlay.shader

@@ -0,0 +1,240 @@
+// Simplified SDF shader:
+// - No Shading Option (bevel / bump / env map)
+// - No Glow Option
+// - Softness is applied on both side of the outline
+
+Shader "TextMeshPro/Mobile/Distance Field Overlay" {
+
+Properties {
+	[HDR]_FaceColor		("Face Color", Color) = (1,1,1,1)
+	_FaceDilate			("Face Dilate", Range(-1,1)) = 0
+
+	[HDR]_OutlineColor	("Outline Color", Color) = (0,0,0,1)
+	_OutlineWidth		("Outline Thickness", Range(0,1)) = 0
+	_OutlineSoftness	("Outline Softness", Range(0,1)) = 0
+
+	[HDR]_UnderlayColor	("Border Color", Color) = (0,0,0,.5)
+	_UnderlayOffsetX 	("Border OffsetX", Range(-1,1)) = 0
+	_UnderlayOffsetY 	("Border OffsetY", Range(-1,1)) = 0
+	_UnderlayDilate		("Border Dilate", Range(-1,1)) = 0
+	_UnderlaySoftness 	("Border Softness", Range(0,1)) = 0
+
+	_WeightNormal		("Weight Normal", float) = 0
+	_WeightBold			("Weight Bold", float) = .5
+
+	_ShaderFlags		("Flags", float) = 0
+	_ScaleRatioA		("Scale RatioA", float) = 1
+	_ScaleRatioB		("Scale RatioB", float) = 1
+	_ScaleRatioC		("Scale RatioC", float) = 1
+
+	_MainTex			("Font Atlas", 2D) = "white" {}
+	_TextureWidth		("Texture Width", float) = 512
+	_TextureHeight		("Texture Height", float) = 512
+	_GradientScale		("Gradient Scale", float) = 5
+	_ScaleX				("Scale X", float) = 1
+	_ScaleY				("Scale Y", float) = 1
+	_PerspectiveFilter	("Perspective Correction", Range(0, 1)) = 0.875
+	_Sharpness			("Sharpness", Range(-1,1)) = 0
+
+	_VertexOffsetX		("Vertex OffsetX", float) = 0
+	_VertexOffsetY		("Vertex OffsetY", float) = 0
+
+	_ClipRect			("Clip Rect", vector) = (-32767, -32767, 32767, 32767)
+	_MaskSoftnessX		("Mask SoftnessX", float) = 0
+	_MaskSoftnessY		("Mask SoftnessY", float) = 0
+
+	_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
+
+	_CullMode			("Cull Mode", Float) = 0
+	_ColorMask			("Color Mask", Float) = 15
+}
+
+SubShader {
+	Tags
+  {
+		"Queue"="Overlay"
+		"IgnoreProjector"="True"
+		"RenderType"="Transparent"
+	}
+
+
+	Stencil
+	{
+		Ref [_Stencil]
+		Comp [_StencilComp]
+		Pass [_StencilOp]
+		ReadMask [_StencilReadMask]
+		WriteMask [_StencilWriteMask]
+	}
+
+	Cull [_CullMode]
+	ZWrite Off
+	Lighting Off
+	Fog { Mode Off }
+	ZTest Always
+	Blend One OneMinusSrcAlpha
+	ColorMask [_ColorMask]
+
+	Pass {
+		CGPROGRAM
+		#pragma vertex VertShader
+		#pragma fragment PixShader
+		#pragma shader_feature __ OUTLINE_ON
+		#pragma shader_feature __ UNDERLAY_ON UNDERLAY_INNER
+
+		#pragma multi_compile __ UNITY_UI_CLIP_RECT
+		#pragma multi_compile __ UNITY_UI_ALPHACLIP
+
+		#include "UnityCG.cginc"
+		#include "UnityUI.cginc"
+		#include "TMPro_Properties.cginc"
+
+		struct vertex_t {
+			UNITY_VERTEX_INPUT_INSTANCE_ID
+			float4	vertex			: POSITION;
+			float3	normal			: NORMAL;
+			fixed4	color			: COLOR;
+			float2	texcoord0		: TEXCOORD0;
+			float2	texcoord1		: TEXCOORD1;
+		};
+
+		struct pixel_t {
+			UNITY_VERTEX_INPUT_INSTANCE_ID
+			UNITY_VERTEX_OUTPUT_STEREO
+			float4	vertex			: SV_POSITION;
+			fixed4	faceColor		: COLOR;
+			fixed4	outlineColor	: COLOR1;
+			float4	texcoord0		: TEXCOORD0;			// Texture UV, Mask UV
+			half4	param			: TEXCOORD1;			// Scale(x), BiasIn(y), BiasOut(z), Bias(w)
+			half4	mask			: TEXCOORD2;			// Position in clip space(xy), Softness(zw)
+		#if (UNDERLAY_ON | UNDERLAY_INNER)
+			float4	texcoord1		: TEXCOORD3;			// Texture UV, alpha, reserved
+			half2	underlayParam	: TEXCOORD4;			// Scale(x), Bias(y)
+		#endif
+		};
+
+
+		pixel_t VertShader(vertex_t input)
+		{
+			pixel_t output;
+
+			UNITY_INITIALIZE_OUTPUT(pixel_t, output);
+			UNITY_SETUP_INSTANCE_ID(input);
+			UNITY_TRANSFER_INSTANCE_ID(input, output);
+			UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
+
+			float bold = step(input.texcoord1.y, 0);
+
+			float4 vert = input.vertex;
+			vert.x += _VertexOffsetX;
+			vert.y += _VertexOffsetY;
+			float4 vPosition = UnityObjectToClipPos(vert);
+
+			float2 pixelSize = vPosition.w;
+			pixelSize /= float2(_ScaleX, _ScaleY) * abs(mul((float2x2)UNITY_MATRIX_P, _ScreenParams.xy));
+
+			float scale = rsqrt(dot(pixelSize, pixelSize));
+			scale *= abs(input.texcoord1.y) * _GradientScale * (_Sharpness + 1);
+			if(UNITY_MATRIX_P[3][3] == 0) scale = lerp(abs(scale) * (1 - _PerspectiveFilter), scale, abs(dot(UnityObjectToWorldNormal(input.normal.xyz), normalize(WorldSpaceViewDir(vert)))));
+
+			float weight = lerp(_WeightNormal, _WeightBold, bold) / 4.0;
+			weight = (weight + _FaceDilate) * _ScaleRatioA * 0.5;
+
+			float layerScale = scale;
+
+			scale /= 1 + (_OutlineSoftness * _ScaleRatioA * scale);
+			float bias = (0.5 - weight) * scale - 0.5;
+			float outline = _OutlineWidth * _ScaleRatioA * 0.5 * scale;
+
+			float opacity = input.color.a;
+		#if (UNDERLAY_ON | UNDERLAY_INNER)
+				opacity = 1.0;
+		#endif
+
+			fixed4 faceColor = fixed4(input.color.rgb, opacity) * _FaceColor;
+			faceColor.rgb *= faceColor.a;
+
+			fixed4 outlineColor = _OutlineColor;
+			outlineColor.a *= opacity;
+			outlineColor.rgb *= outlineColor.a;
+			outlineColor = lerp(faceColor, outlineColor, sqrt(min(1.0, (outline * 2))));
+
+		#if (UNDERLAY_ON | UNDERLAY_INNER)
+			layerScale /= 1 + ((_UnderlaySoftness * _ScaleRatioC) * layerScale);
+			float layerBias = (.5 - weight) * layerScale - .5 - ((_UnderlayDilate * _ScaleRatioC) * .5 * layerScale);
+
+			float x = -(_UnderlayOffsetX * _ScaleRatioC) * _GradientScale / _TextureWidth;
+			float y = -(_UnderlayOffsetY * _ScaleRatioC) * _GradientScale / _TextureHeight;
+			float2 layerOffset = float2(x, y);
+		#endif
+
+			// Generate UV for the Masking Texture
+			float4 clampedRect = clamp(_ClipRect, -2e10, 2e10);
+			float2 maskUV = (vert.xy - clampedRect.xy) / (clampedRect.zw - clampedRect.xy);
+
+			// Populate structure for pixel shader
+			output.vertex = vPosition;
+			output.faceColor = faceColor;
+			output.outlineColor = outlineColor;
+			output.texcoord0 = float4(input.texcoord0.x, input.texcoord0.y, maskUV.x, maskUV.y);
+			output.param = half4(scale, bias - outline, bias + outline, bias);
+			output.mask = half4(vert.xy * 2 - clampedRect.xy - clampedRect.zw, 0.25 / (0.25 * half2(_MaskSoftnessX, _MaskSoftnessY) + pixelSize.xy));
+			#if (UNDERLAY_ON || UNDERLAY_INNER)
+			output.texcoord1 = float4(input.texcoord0 + layerOffset, input.color.a, 0);
+			output.underlayParam = half2(layerScale, layerBias);
+			#endif
+
+			return output;
+		}
+
+
+		// PIXEL SHADER
+		fixed4 PixShader(pixel_t input) : SV_Target
+		{
+			UNITY_SETUP_INSTANCE_ID(input);
+
+			half d = tex2D(_MainTex, input.texcoord0.xy).a * input.param.x;
+			half4 c = input.faceColor * saturate(d - input.param.w);
+
+		#ifdef OUTLINE_ON
+			c = lerp(input.outlineColor, input.faceColor, saturate(d - input.param.z));
+			c *= saturate(d - input.param.y);
+		#endif
+
+		#if UNDERLAY_ON
+			d = tex2D(_MainTex, input.texcoord1.xy).a * input.underlayParam.x;
+			c += float4(_UnderlayColor.rgb * _UnderlayColor.a, _UnderlayColor.a) * saturate(d - input.underlayParam.y) * (1 - c.a);
+		#endif
+
+		#if UNDERLAY_INNER
+			half sd = saturate(d - input.param.z);
+			d = tex2D(_MainTex, input.texcoord1.xy).a * input.underlayParam.x;
+			c += float4(_UnderlayColor.rgb * _UnderlayColor.a, _UnderlayColor.a) * (1 - saturate(d - input.underlayParam.y)) * sd * (1 - c.a);
+		#endif
+
+		// Alternative implementation to UnityGet2DClipping with support for softness.
+		#if UNITY_UI_CLIP_RECT
+			half2 m = saturate((_ClipRect.zw - _ClipRect.xy - abs(input.mask.xy)) * input.mask.zw);
+			c *= m.x * m.y;
+		#endif
+
+		#if (UNDERLAY_ON | UNDERLAY_INNER)
+			c *= input.texcoord1.z;
+		#endif
+
+    #if UNITY_UI_ALPHACLIP
+			clip(c.a - 0.001);
+		#endif
+
+			return c;
+		}
+		ENDCG
+	}
+}
+
+CustomEditor "TMPro.EditorUtilities.TMP_SDFShaderGUI"
+}

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF-Mobile Overlay.shader.meta

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

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF-Mobile SSD.shader

@@ -0,0 +1,106 @@
+// Simplified SDF shader:
+// - No Shading Option (bevel / bump / env map)
+// - No Glow Option
+// - Softness is applied on both side of the outline
+
+Shader "TextMeshPro/Mobile/Distance Field SSD" {
+
+Properties {
+	[HDR]_FaceColor		("Face Color", Color) = (1,1,1,1)
+	_FaceDilate			("Face Dilate", Range(-1,1)) = 0
+
+	[HDR]_OutlineColor	("Outline Color", Color) = (0,0,0,1)
+	_OutlineWidth		("Outline Thickness", Range(0,1)) = 0
+	_OutlineSoftness	("Outline Softness", Range(0,1)) = 0
+
+	[HDR]_UnderlayColor		("Border Color", Color) = (0,0,0,.5)
+	_UnderlayOffsetX 	("Border OffsetX", Range(-1,1)) = 0
+	_UnderlayOffsetY 	("Border OffsetY", Range(-1,1)) = 0
+	_UnderlayDilate		("Border Dilate", Range(-1,1)) = 0
+	_UnderlaySoftness 	("Border Softness", Range(0,1)) = 0
+
+	_WeightNormal		("Weight Normal", float) = 0
+	_WeightBold			("Weight Bold", float) = .5
+
+	_ShaderFlags		("Flags", float) = 0
+	_ScaleRatioA		("Scale RatioA", float) = 1
+	_ScaleRatioB		("Scale RatioB", float) = 1
+	_ScaleRatioC		("Scale RatioC", float) = 1
+
+	_MainTex			("Font Atlas", 2D) = "white" {}
+	_TextureWidth		("Texture Width", float) = 512
+	_TextureHeight		("Texture Height", float) = 512
+	_GradientScale		("Gradient Scale", float) = 5
+	_ScaleX				("Scale X", float) = 1
+	_ScaleY				("Scale Y", float) = 1
+	_PerspectiveFilter	("Perspective Correction", Range(0, 1)) = 0.875
+	_Sharpness			("Sharpness", Range(-1,1)) = 0
+
+	_VertexOffsetX		("Vertex OffsetX", float) = 0
+	_VertexOffsetY		("Vertex OffsetY", float) = 0
+
+	_ClipRect			("Clip Rect", vector) = (-32767, -32767, 32767, 32767)
+	_MaskSoftnessX		("Mask SoftnessX", float) = 0
+	_MaskSoftnessY		("Mask SoftnessY", float) = 0
+	_MaskTex			("Mask Texture", 2D) = "white" {}
+	_MaskInverse		("Inverse", float) = 0
+	_MaskEdgeColor		("Edge Color", Color) = (1,1,1,1)
+	_MaskEdgeSoftness	("Edge Softness", Range(0, 1)) = 0.01
+	_MaskWipeControl	("Wipe Position", Range(0, 1)) = 0.5
+
+	_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
+
+    _CullMode           ("Cull Mode", Float) = 0
+	_ColorMask			("Color Mask", Float) = 15
+}
+
+SubShader {
+	Tags {
+		"Queue"="Transparent"
+		"IgnoreProjector"="True"
+		"RenderType"="Transparent"
+	}
+
+	Stencil
+	{
+		Ref [_Stencil]
+		Comp [_StencilComp]
+		Pass [_StencilOp]
+		ReadMask [_StencilReadMask]
+		WriteMask [_StencilWriteMask]
+	}
+
+	Cull [_CullMode]
+	ZWrite Off
+	Lighting Off
+	Fog { Mode Off }
+	ZTest [unity_GUIZTestMode]
+	Blend One OneMinusSrcAlpha
+	ColorMask [_ColorMask]
+
+	Pass {
+		CGPROGRAM
+		#pragma vertex VertShader
+		#pragma fragment PixShader
+		#pragma shader_feature __ OUTLINE_ON
+		#pragma shader_feature __ UNDERLAY_ON UNDERLAY_INNER
+
+		#pragma multi_compile __ UNITY_UI_CLIP_RECT
+		#pragma multi_compile __ UNITY_UI_ALPHACLIP
+
+		#include "UnityCG.cginc"
+		#include "UnityUI.cginc"
+		#include "TMPro_Properties.cginc"
+
+		#include "TMPro_Mobile.cginc"
+
+		ENDCG
+	}
+}
+
+CustomEditor "TMPro.EditorUtilities.TMP_SDFShaderGUI"
+}

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF-Mobile SSD.shader.meta

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

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF-Mobile.shader

@@ -0,0 +1,240 @@
+// Simplified SDF shader:
+// - No Shading Option (bevel / bump / env map)
+// - No Glow Option
+// - Softness is applied on both side of the outline
+
+Shader "TextMeshPro/Mobile/Distance Field" {
+
+Properties {
+	[HDR]_FaceColor     ("Face Color", Color) = (1,1,1,1)
+	_FaceDilate			("Face Dilate", Range(-1,1)) = 0
+
+	[HDR]_OutlineColor	("Outline Color", Color) = (0,0,0,1)
+	_OutlineWidth		("Outline Thickness", Range(0,1)) = 0
+	_OutlineSoftness	("Outline Softness", Range(0,1)) = 0
+
+	[HDR]_UnderlayColor	("Border Color", Color) = (0,0,0,.5)
+	_UnderlayOffsetX 	("Border OffsetX", Range(-1,1)) = 0
+	_UnderlayOffsetY 	("Border OffsetY", Range(-1,1)) = 0
+	_UnderlayDilate		("Border Dilate", Range(-1,1)) = 0
+	_UnderlaySoftness 	("Border Softness", Range(0,1)) = 0
+
+	_WeightNormal		("Weight Normal", float) = 0
+	_WeightBold			("Weight Bold", float) = .5
+
+	_ShaderFlags		("Flags", float) = 0
+	_ScaleRatioA		("Scale RatioA", float) = 1
+	_ScaleRatioB		("Scale RatioB", float) = 1
+	_ScaleRatioC		("Scale RatioC", float) = 1
+
+	_MainTex			("Font Atlas", 2D) = "white" {}
+	_TextureWidth		("Texture Width", float) = 512
+	_TextureHeight		("Texture Height", float) = 512
+	_GradientScale		("Gradient Scale", float) = 5
+	_ScaleX				("Scale X", float) = 1
+	_ScaleY				("Scale Y", float) = 1
+	_PerspectiveFilter	("Perspective Correction", Range(0, 1)) = 0.875
+	_Sharpness			("Sharpness", Range(-1,1)) = 0
+
+	_VertexOffsetX		("Vertex OffsetX", float) = 0
+	_VertexOffsetY		("Vertex OffsetY", float) = 0
+
+	_ClipRect			("Clip Rect", vector) = (-32767, -32767, 32767, 32767)
+	_MaskSoftnessX		("Mask SoftnessX", float) = 0
+	_MaskSoftnessY		("Mask SoftnessY", float) = 0
+
+	_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
+
+	_CullMode			("Cull Mode", Float) = 0
+	_ColorMask			("Color Mask", Float) = 15
+}
+
+SubShader {
+	Tags
+	{
+		"Queue"="Transparent"
+		"IgnoreProjector"="True"
+		"RenderType"="Transparent"
+	}
+
+
+	Stencil
+	{
+		Ref [_Stencil]
+		Comp [_StencilComp]
+		Pass [_StencilOp]
+		ReadMask [_StencilReadMask]
+		WriteMask [_StencilWriteMask]
+	}
+
+	Cull [_CullMode]
+	ZWrite Off
+	Lighting Off
+	Fog { Mode Off }
+	ZTest [unity_GUIZTestMode]
+	Blend One OneMinusSrcAlpha
+	ColorMask [_ColorMask]
+
+	Pass {
+		CGPROGRAM
+		#pragma vertex VertShader
+		#pragma fragment PixShader
+		#pragma shader_feature __ OUTLINE_ON
+		#pragma shader_feature __ UNDERLAY_ON UNDERLAY_INNER
+
+		#pragma multi_compile __ UNITY_UI_CLIP_RECT
+		#pragma multi_compile __ UNITY_UI_ALPHACLIP
+
+		#include "UnityCG.cginc"
+		#include "UnityUI.cginc"
+		#include "TMPro_Properties.cginc"
+
+		struct vertex_t {
+			UNITY_VERTEX_INPUT_INSTANCE_ID
+			float4	vertex			: POSITION;
+			float3	normal			: NORMAL;
+			fixed4	color			: COLOR;
+			float2	texcoord0		: TEXCOORD0;
+			float2	texcoord1		: TEXCOORD1;
+		};
+
+		struct pixel_t {
+			UNITY_VERTEX_INPUT_INSTANCE_ID
+			UNITY_VERTEX_OUTPUT_STEREO
+			float4	vertex			: SV_POSITION;
+			fixed4	faceColor		: COLOR;
+			fixed4	outlineColor	: COLOR1;
+			float4	texcoord0		: TEXCOORD0;			// Texture UV, Mask UV
+			half4	param			: TEXCOORD1;			// Scale(x), BiasIn(y), BiasOut(z), Bias(w)
+			half4	mask			: TEXCOORD2;			// Position in clip space(xy), Softness(zw)
+			#if (UNDERLAY_ON | UNDERLAY_INNER)
+			float4	texcoord1		: TEXCOORD3;			// Texture UV, alpha, reserved
+			half2	underlayParam	: TEXCOORD4;			// Scale(x), Bias(y)
+			#endif
+		};
+
+
+		pixel_t VertShader(vertex_t input)
+		{
+			pixel_t output;
+
+			UNITY_INITIALIZE_OUTPUT(pixel_t, output);
+			UNITY_SETUP_INSTANCE_ID(input);
+			UNITY_TRANSFER_INSTANCE_ID(input, output);
+			UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
+
+			float bold = step(input.texcoord1.y, 0);
+
+			float4 vert = input.vertex;
+			vert.x += _VertexOffsetX;
+			vert.y += _VertexOffsetY;
+			float4 vPosition = UnityObjectToClipPos(vert);
+
+			float2 pixelSize = vPosition.w;
+			pixelSize /= float2(_ScaleX, _ScaleY) * abs(mul((float2x2)UNITY_MATRIX_P, _ScreenParams.xy));
+
+			float scale = rsqrt(dot(pixelSize, pixelSize));
+			scale *= abs(input.texcoord1.y) * _GradientScale * (_Sharpness + 1);
+			if(UNITY_MATRIX_P[3][3] == 0) scale = lerp(abs(scale) * (1 - _PerspectiveFilter), scale, abs(dot(UnityObjectToWorldNormal(input.normal.xyz), normalize(WorldSpaceViewDir(vert)))));
+
+			float weight = lerp(_WeightNormal, _WeightBold, bold) / 4.0;
+			weight = (weight + _FaceDilate) * _ScaleRatioA * 0.5;
+
+			float layerScale = scale;
+
+			scale /= 1 + (_OutlineSoftness * _ScaleRatioA * scale);
+			float bias = (0.5 - weight) * scale - 0.5;
+			float outline = _OutlineWidth * _ScaleRatioA * 0.5 * scale;
+
+			float opacity = input.color.a;
+			#if (UNDERLAY_ON | UNDERLAY_INNER)
+			opacity = 1.0;
+			#endif
+
+			fixed4 faceColor = fixed4(input.color.rgb, opacity) * _FaceColor;
+			faceColor.rgb *= faceColor.a;
+
+			fixed4 outlineColor = _OutlineColor;
+			outlineColor.a *= opacity;
+			outlineColor.rgb *= outlineColor.a;
+			outlineColor = lerp(faceColor, outlineColor, sqrt(min(1.0, (outline * 2))));
+
+			#if (UNDERLAY_ON | UNDERLAY_INNER)
+			layerScale /= 1 + ((_UnderlaySoftness * _ScaleRatioC) * layerScale);
+			float layerBias = (.5 - weight) * layerScale - .5 - ((_UnderlayDilate * _ScaleRatioC) * .5 * layerScale);
+
+			float x = -(_UnderlayOffsetX * _ScaleRatioC) * _GradientScale / _TextureWidth;
+			float y = -(_UnderlayOffsetY * _ScaleRatioC) * _GradientScale / _TextureHeight;
+			float2 layerOffset = float2(x, y);
+			#endif
+
+			// Generate UV for the Masking Texture
+			float4 clampedRect = clamp(_ClipRect, -2e10, 2e10);
+			float2 maskUV = (vert.xy - clampedRect.xy) / (clampedRect.zw - clampedRect.xy);
+
+			// Populate structure for pixel shader
+			output.vertex = vPosition;
+			output.faceColor = faceColor;
+			output.outlineColor = outlineColor;
+			output.texcoord0 = float4(input.texcoord0.x, input.texcoord0.y, maskUV.x, maskUV.y);
+			output.param = half4(scale, bias - outline, bias + outline, bias);
+			output.mask = half4(vert.xy * 2 - clampedRect.xy - clampedRect.zw, 0.25 / (0.25 * half2(_MaskSoftnessX, _MaskSoftnessY) + pixelSize.xy));
+			#if (UNDERLAY_ON || UNDERLAY_INNER)
+			output.texcoord1 = float4(input.texcoord0 + layerOffset, input.color.a, 0);
+			output.underlayParam = half2(layerScale, layerBias);
+			#endif
+
+			return output;
+		}
+
+
+		// PIXEL SHADER
+		fixed4 PixShader(pixel_t input) : SV_Target
+		{
+			UNITY_SETUP_INSTANCE_ID(input);
+
+			half d = tex2D(_MainTex, input.texcoord0.xy).a * input.param.x;
+			half4 c = input.faceColor * saturate(d - input.param.w);
+
+			#ifdef OUTLINE_ON
+			c = lerp(input.outlineColor, input.faceColor, saturate(d - input.param.z));
+			c *= saturate(d - input.param.y);
+			#endif
+
+			#if UNDERLAY_ON
+			d = tex2D(_MainTex, input.texcoord1.xy).a * input.underlayParam.x;
+			c += float4(_UnderlayColor.rgb * _UnderlayColor.a, _UnderlayColor.a) * saturate(d - input.underlayParam.y) * (1 - c.a);
+			#endif
+
+			#if UNDERLAY_INNER
+			half sd = saturate(d - input.param.z);
+			d = tex2D(_MainTex, input.texcoord1.xy).a * input.underlayParam.x;
+			c += float4(_UnderlayColor.rgb * _UnderlayColor.a, _UnderlayColor.a) * (1 - saturate(d - input.underlayParam.y)) * sd * (1 - c.a);
+			#endif
+
+			// Alternative implementation to UnityGet2DClipping with support for softness.
+			#if UNITY_UI_CLIP_RECT
+			half2 m = saturate((_ClipRect.zw - _ClipRect.xy - abs(input.mask.xy)) * input.mask.zw);
+			c *= m.x * m.y;
+			#endif
+
+			#if (UNDERLAY_ON | UNDERLAY_INNER)
+			c *= input.texcoord1.z;
+			#endif
+
+			#if UNITY_UI_ALPHACLIP
+			clip(c.a - 0.001);
+			#endif
+
+			return c;
+		}
+		ENDCG
+	}
+}
+
+CustomEditor "TMPro.EditorUtilities.TMP_SDFShaderGUI"
+}

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF-Mobile.shader.meta

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

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF-Surface-Mobile.shader

@@ -0,0 +1,138 @@
+// Simplified version of the SDF Surface shader :
+// - No support for Bevel, Bump or envmap
+// - Diffuse only lighting
+// - Fully supports only 1 directional light. Other lights can affect it, but it will be per-vertex/SH.
+
+Shader "TextMeshPro/Mobile/Distance Field (Surface)" {
+
+Properties {
+	_FaceTex			("Fill Texture", 2D) = "white" {}
+	[HDR]_FaceColor		("Fill Color", Color) = (1,1,1,1)
+	_FaceDilate			("Face Dilate", Range(-1,1)) = 0
+
+	[HDR]_OutlineColor	("Outline Color", Color) = (0,0,0,1)
+	_OutlineTex			("Outline Texture", 2D) = "white" {}
+	_OutlineWidth		("Outline Thickness", Range(0, 1)) = 0
+	_OutlineSoftness	("Outline Softness", Range(0,1)) = 0
+
+	[HDR]_GlowColor		("Color", Color) = (0, 1, 0, 0.5)
+	_GlowOffset			("Offset", Range(-1,1)) = 0
+	_GlowInner			("Inner", Range(0,1)) = 0.05
+	_GlowOuter			("Outer", Range(0,1)) = 0.05
+	_GlowPower			("Falloff", Range(1, 0)) = 0.75
+
+	_WeightNormal		("Weight Normal", float) = 0
+	_WeightBold			("Weight Bold", float) = 0.5
+
+	// Should not be directly exposed to the user
+	_ShaderFlags		("Flags", float) = 0
+	_ScaleRatioA		("Scale RatioA", float) = 1
+	_ScaleRatioB		("Scale RatioB", float) = 1
+	_ScaleRatioC		("Scale RatioC", float) = 1
+
+	_MainTex			("Font Atlas", 2D) = "white" {}
+	_TextureWidth		("Texture Width", float) = 512
+	_TextureHeight		("Texture Height", float) = 512
+	_GradientScale		("Gradient Scale", float) = 5.0
+	_ScaleX				("Scale X", float) = 1.0
+	_ScaleY				("Scale Y", float) = 1.0
+	_PerspectiveFilter	("Perspective Correction", Range(0, 1)) = 0.875
+	_Sharpness			("Sharpness", Range(-1,1)) = 0
+
+	_VertexOffsetX		("Vertex OffsetX", float) = 0
+	_VertexOffsetY		("Vertex OffsetY", float) = 0
+
+	_CullMode			("Cull Mode", Float) = 0
+	//_MaskCoord		("Mask Coords", vector) = (0,0,0,0)
+	//_MaskSoftness		("Mask Softness", float) = 0
+}
+
+SubShader {
+
+	Tags {
+		"Queue"="Transparent"
+		"IgnoreProjector"="True"
+		"RenderType"="Transparent"
+	}
+
+	LOD 300
+	Cull [_CullMode]
+
+	CGPROGRAM
+	#pragma surface PixShader Lambert alpha:blend vertex:VertShader noforwardadd nolightmap nodirlightmap
+	#pragma target 3.0
+	#pragma shader_feature __ GLOW_ON
+
+	#include "TMPro_Properties.cginc"
+	#include "TMPro.cginc"
+
+	half _FaceShininess;
+	half _OutlineShininess;
+
+	struct Input
+	{
+		fixed4	color		: COLOR;
+		float2	uv_MainTex;
+		float2	uv2_FaceTex;
+		float2  uv2_OutlineTex;
+		float2	param;					// Weight, Scale
+		float3	viewDirEnv;
+	};
+
+	#include "TMPro_Surface.cginc"
+
+	ENDCG
+
+	// Pass to render object as a shadow caster
+	Pass
+	{
+		Name "Caster"
+		Tags { "LightMode" = "ShadowCaster" }
+		Offset 1, 1
+
+		Fog {Mode Off}
+		ZWrite On ZTest LEqual Cull Off
+
+		CGPROGRAM
+		#pragma vertex vert
+		#pragma fragment frag
+		#pragma multi_compile_shadowcaster
+		#include "UnityCG.cginc"
+
+		struct v2f {
+			V2F_SHADOW_CASTER;
+			float2	uv			: TEXCOORD1;
+			float2	uv2			: TEXCOORD3;
+			float	alphaClip	: TEXCOORD2;
+		};
+
+		uniform float4 _MainTex_ST;
+		uniform float4 _OutlineTex_ST;
+		float _OutlineWidth;
+		float _FaceDilate;
+		float _ScaleRatioA;
+
+		v2f vert( appdata_base v )
+		{
+			v2f o;
+			TRANSFER_SHADOW_CASTER(o)
+			o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
+			o.uv2 = TRANSFORM_TEX(v.texcoord, _OutlineTex);
+			o.alphaClip = o.alphaClip = (1.0 - _OutlineWidth * _ScaleRatioA - _FaceDilate * _ScaleRatioA) / 2;
+			return o;
+		}
+
+		uniform sampler2D _MainTex;
+
+		float4 frag(v2f i) : COLOR
+		{
+			fixed4 texcol = tex2D(_MainTex, i.uv).a;
+			clip(texcol.a - i.alphaClip);
+			SHADOW_CASTER_FRAGMENT(i)
+		}
+		ENDCG
+	}
+}
+
+CustomEditor "TMPro.EditorUtilities.TMP_SDFShaderGUI"
+}

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF-Surface-Mobile.shader.meta

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

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF-Surface.shader

@@ -0,0 +1,158 @@
+Shader "TextMeshPro/Distance Field (Surface)" {
+
+Properties {
+	_FaceTex			("Fill Texture", 2D) = "white" {}
+	_FaceUVSpeedX		("Face UV Speed X", Range(-5, 5)) = 0.0
+	_FaceUVSpeedY		("Face UV Speed Y", Range(-5, 5)) = 0.0
+	[HDR]_FaceColor		("Fill Color", Color) = (1,1,1,1)
+	_FaceDilate			("Face Dilate", Range(-1,1)) = 0
+
+	[HDR]_OutlineColor	("Outline Color", Color) = (0,0,0,1)
+	_OutlineTex			("Outline Texture", 2D) = "white" {}
+	_OutlineUVSpeedX	("Outline UV Speed X", Range(-5, 5)) = 0.0
+	_OutlineUVSpeedY	("Outline UV Speed Y", Range(-5, 5)) = 0.0
+	_OutlineWidth		("Outline Thickness", Range(0, 1)) = 0
+	_OutlineSoftness	("Outline Softness", Range(0,1)) = 0
+
+	_Bevel				("Bevel", Range(0,1)) = 0.5
+	_BevelOffset		("Bevel Offset", Range(-0.5,0.5)) = 0
+	_BevelWidth			("Bevel Width", Range(-.5,0.5)) = 0
+	_BevelClamp			("Bevel Clamp", Range(0,1)) = 0
+	_BevelRoundness		("Bevel Roundness", Range(0,1)) = 0
+
+	_BumpMap 			("Normalmap", 2D) = "bump" {}
+	_BumpOutline		("Bump Outline", Range(0,1)) = 0.5
+	_BumpFace			("Bump Face", Range(0,1)) = 0.5
+
+	_ReflectFaceColor	    ("Face Color", Color) = (0,0,0,1)
+	_ReflectOutlineColor	("Outline Color", Color) = (0,0,0,1)
+	_Cube 					("Reflection Cubemap", Cube) = "black" { /* TexGen CubeReflect */ }
+	_EnvMatrixRotation  	("Texture Rotation", vector) = (0, 0, 0, 0)
+	[HDR]_SpecColor		    ("Specular Color", Color) = (0,0,0,1)
+
+	_FaceShininess		("Face Shininess", Range(0,1)) = 0
+	_OutlineShininess	("Outline Shininess", Range(0,1)) = 0
+
+	[HDR]_GlowColor		("Color", Color) = (0, 1, 0, 0.5)
+	_GlowOffset			("Offset", Range(-1,1)) = 0
+	_GlowInner			("Inner", Range(0,1)) = 0.05
+	_GlowOuter			("Outer", Range(0,1)) = 0.05
+	_GlowPower			("Falloff", Range(1, 0)) = 0.75
+
+	_WeightNormal		("Weight Normal", float) = 0
+	_WeightBold			("Weight Bold", float) = 0.5
+
+	// Should not be directly exposed to the user
+	_ShaderFlags		("Flags", float) = 0
+	_ScaleRatioA		("Scale RatioA", float) = 1
+	_ScaleRatioB		("Scale RatioB", float) = 1
+	_ScaleRatioC		("Scale RatioC", float) = 1
+
+	_MainTex			("Font Atlas", 2D) = "white" {}
+	_TextureWidth		("Texture Width", float) = 512
+	_TextureHeight		("Texture Height", float) = 512
+	_GradientScale		("Gradient Scale", float) = 5.0
+	_ScaleX				("Scale X", float) = 1.0
+	_ScaleY				("Scale Y", float) = 1.0
+	_PerspectiveFilter	("Perspective Correction", Range(0, 1)) = 0.875
+	_Sharpness			("Sharpness", Range(-1,1)) = 0
+
+	_VertexOffsetX		("Vertex OffsetX", float) = 0
+	_VertexOffsetY		("Vertex OffsetY", float) = 0
+
+	_CullMode			("Cull Mode", Float) = 0
+	//_MaskCoord		("Mask Coords", vector) = (0,0,0,0)
+	//_MaskSoftness		("Mask Softness", float) = 0
+}
+
+SubShader {
+
+	Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+
+	LOD 300
+	Cull [_CullMode]
+
+	CGPROGRAM
+	#pragma surface PixShader BlinnPhong alpha:blend vertex:VertShader nolightmap nodirlightmap
+	#pragma target 3.0
+	#pragma shader_feature __ GLOW_ON
+	#pragma glsl
+
+	#include "TMPro_Properties.cginc"
+	#include "TMPro.cginc"
+
+	half _FaceShininess;
+	half _OutlineShininess;
+
+	struct Input
+	{
+		fixed4	color			: COLOR;
+		float2	uv_MainTex;
+		float2	uv2_FaceTex;
+		float2  uv2_OutlineTex;
+		float2	param;						// Weight, Scale
+		float3	viewDirEnv;
+	};
+
+
+	#define BEVEL_ON 1
+	#include "TMPro_Surface.cginc"
+
+	ENDCG
+
+	// Pass to render object as a shadow caster
+	Pass
+	{
+		Name "Caster"
+		Tags { "LightMode" = "ShadowCaster" }
+		Offset 1, 1
+
+		Fog {Mode Off}
+		ZWrite On
+		ZTest LEqual
+		Cull Off
+
+		CGPROGRAM
+		#pragma vertex vert
+		#pragma fragment frag
+		#pragma multi_compile_shadowcaster
+		#include "UnityCG.cginc"
+
+		struct v2f {
+			V2F_SHADOW_CASTER;
+			float2	uv			: TEXCOORD1;
+			float2	uv2			: TEXCOORD3;
+			float	alphaClip	: TEXCOORD2;
+		};
+
+		uniform float4 _MainTex_ST;
+		uniform float4 _OutlineTex_ST;
+		float _OutlineWidth;
+		float _FaceDilate;
+		float _ScaleRatioA;
+
+		v2f vert( appdata_base v )
+		{
+			v2f o;
+			TRANSFER_SHADOW_CASTER(o)
+			o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
+			o.uv2 = TRANSFORM_TEX(v.texcoord, _OutlineTex);
+			o.alphaClip = (1.0 - _OutlineWidth * _ScaleRatioA - _FaceDilate * _ScaleRatioA) / 2;
+			return o;
+		}
+
+		uniform sampler2D _MainTex;
+
+		float4 frag(v2f i) : COLOR
+		{
+			fixed4 texcol = tex2D(_MainTex, i.uv).a;
+			clip(texcol.a - i.alphaClip);
+			SHADOW_CASTER_FRAGMENT(i)
+		}
+		ENDCG
+	}
+}
+
+CustomEditor "TMPro.EditorUtilities.TMP_SDFShaderGUI"
+}
+

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF-Surface.shader.meta

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

Assets/Resources/TextMesh Pro/Shaders/TMP_SDF.shader.meta

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

Assets/Resources/TextMesh Pro/Shaders/TMP_Sprite.shader

@@ -0,0 +1,116 @@
+Shader "TextMeshPro/Sprite"
+{
+	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
+		
+		_CullMode ("Cull Mode", Float) = 0
+		_ColorMask ("Color Mask", Float) = 15
+		_ClipRect ("Clip Rect", vector) = (-32767, -32767, 32767, 32767)
+
+		[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 [_CullMode]
+		Lighting Off
+		ZWrite Off
+		ZTest [unity_GUIZTestMode]
+		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_CLIP_RECT
+            #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
+			};
+			
+            sampler2D _MainTex;
+			fixed4 _Color;
+			fixed4 _TextureSampleAdd;
+			float4 _ClipRect;
+            float4 _MainTex_ST;
+
+            v2f vert(appdata_t v)
+			{
+				v2f OUT;
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);
+                OUT.worldPosition = v.vertex;
+				OUT.vertex = UnityObjectToClipPos(OUT.worldPosition);
+
+                OUT.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex);
+				
+                OUT.color = v.color * _Color;
+				return OUT;
+			}
+
+			fixed4 frag(v2f IN) : SV_Target
+			{
+				half4 color = (tex2D(_MainTex, IN.texcoord) + _TextureSampleAdd) * IN.color;
+				
+                #ifdef UNITY_UI_CLIP_RECT
+					color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect);
+				#endif
+
+				#ifdef UNITY_UI_ALPHACLIP
+					clip (color.a - 0.001);
+				#endif
+
+				return color;
+			}
+		ENDCG
+		}
+	}
+}

Assets/Resources/TextMesh Pro/Shaders/TMP_Sprite.shader.meta

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

Assets/Resources/TextMesh Pro/Shaders/TMPro.cginc

@@ -0,0 +1,84 @@
+float2 UnpackUV(float uv)
+{ 
+	float2 output;
+	output.x = floor(uv / 4096);
+	output.y = uv - 4096 * output.x;
+
+	return output * 0.001953125;
+}
+
+fixed4 GetColor(half d, fixed4 faceColor, fixed4 outlineColor, half outline, half softness)
+{
+	half faceAlpha = 1-saturate((d - outline * 0.5 + softness * 0.5) / (1.0 + softness));
+	half outlineAlpha = saturate((d + outline * 0.5)) * sqrt(min(1.0, outline));
+
+	faceColor.rgb *= faceColor.a;
+	outlineColor.rgb *= outlineColor.a;
+
+	faceColor = lerp(faceColor, outlineColor, outlineAlpha);
+
+	faceColor *= faceAlpha;
+
+	return faceColor;
+}
+
+float3 GetSurfaceNormal(float4 h, float bias)
+{
+	bool raisedBevel = step(1, fmod(_ShaderFlags, 2));
+
+	h += bias+_BevelOffset;
+
+	float bevelWidth = max(.01, _OutlineWidth+_BevelWidth);
+
+  // Track outline
+	h -= .5;
+	h /= bevelWidth;
+	h = saturate(h+.5);
+
+	if(raisedBevel) h = 1 - abs(h*2.0 - 1.0);
+	h = lerp(h, sin(h*3.141592/2.0), _BevelRoundness);
+	h = min(h, 1.0-_BevelClamp);
+	h *= _Bevel * bevelWidth * _GradientScale * -2.0;
+
+	float3 va = normalize(float3(1.0, 0.0, h.y - h.x));
+	float3 vb = normalize(float3(0.0, -1.0, h.w - h.z));
+
+	return cross(va, vb);
+}
+
+float3 GetSurfaceNormal(float2 uv, float bias, float3 delta)
+{
+	// Read "height field"
+  float4 h = {tex2D(_MainTex, uv - delta.xz).a,
+				tex2D(_MainTex, uv + delta.xz).a,
+				tex2D(_MainTex, uv - delta.zy).a,
+				tex2D(_MainTex, uv + delta.zy).a};
+
+	return GetSurfaceNormal(h, bias);
+}
+
+float3 GetSpecular(float3 n, float3 l)
+{
+	float spec = pow(max(0.0, dot(n, l)), _Reflectivity);
+	return _SpecularColor.rgb * spec * _SpecularPower;
+}
+
+float4 GetGlowColor(float d, float scale)
+{
+	float glow = d - (_GlowOffset*_ScaleRatioB) * 0.5 * scale;
+	float t = lerp(_GlowInner, (_GlowOuter * _ScaleRatioB), step(0.0, glow)) * 0.5 * scale;
+	glow = saturate(abs(glow/(1.0 + t)));
+	glow = 1.0-pow(glow, _GlowPower);
+	glow *= sqrt(min(1.0, t)); // Fade off glow thinner than 1 screen pixel
+	return float4(_GlowColor.rgb, saturate(_GlowColor.a * glow * 2));
+}
+
+float4 BlendARGB(float4 overlying, float4 underlying)
+{
+	overlying.rgb *= overlying.a;
+	underlying.rgb *= underlying.a;
+	float3 blended = overlying.rgb + ((1-overlying.a)*underlying.rgb);
+	float alpha = underlying.a + (1-underlying.a)*overlying.a;
+	return float4(blended, alpha);
+}
+

Assets/Resources/TextMesh Pro/Shaders/TMPro.cginc.meta

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