备份CatanBuilding瘦身独立工程

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/BlendModes.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: baf1d09e18b500d41a714f6207ddda2d
+folderAsset: yes
+timeCreated: 1536402197
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/BlendModes/Spine-Skeleton-PMA-Additive.shader

@@ -0,0 +1,72 @@
+// Spine/Skeleton PMA Screen
+// - single color multiply tint
+// - unlit
+// - Premultiplied alpha Multiply blending
+// - No depth, no backface culling, no fog.
+// - ShadowCaster pass
+
+Shader "Spine/Blend Modes/Skeleton PMA Additive" {
+	Properties {
+		_Color ("Tint Color", Color) = (1,1,1,1)
+		[NoScaleOffset] _MainTex ("MainTex", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		LOD 100
+
+		Fog { Mode Off }
+		Cull Off
+		ZWrite Off
+		Blend One One
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		Pass {
+			Name "Normal"
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#include "../CGIncludes/Spine-BlendModes-NormalPass.cginc"
+			ENDCG
+		}
+
+		Pass {
+			Name "Caster"
+			Tags { "LightMode"="ShadowCaster" }
+			Offset 1, 1
+
+			ZWrite On
+			ZTest LEqual
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma multi_compile_shadowcaster
+			#pragma fragmentoption ARB_precision_hint_fastest
+			#include "../CGIncludes/Spine-BlendModes-ShadowCasterPass.cginc"
+			ENDCG
+		}
+	}
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/BlendModes/Spine-Skeleton-PMA-Additive.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 53efa1d97f5d9f74285d4330cda14e36
+timeCreated: 1496446742
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/BlendModes/Spine-Skeleton-PMA-Multiply.shader

@@ -0,0 +1,72 @@
+// Spine/Skeleton PMA Multiply
+// - single color multiply tint
+// - unlit
+// - Premultiplied alpha Multiply blending
+// - No depth, no backface culling, no fog.
+// - ShadowCaster pass
+
+Shader "Spine/Blend Modes/Skeleton PMA Multiply" {
+	Properties {
+		_Color ("Tint Color", Color) = (1,1,1,1)
+		[NoScaleOffset] _MainTex ("MainTex", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		LOD 100
+
+		Fog { Mode Off }
+		Cull Off
+		ZWrite Off
+		Blend DstColor OneMinusSrcAlpha
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		Pass {
+			Name "Normal"
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#include "../CGIncludes/Spine-BlendModes-NormalPass.cginc"
+			ENDCG
+		}
+
+		Pass {
+			Name "Caster"
+			Tags { "LightMode" = "ShadowCaster" }
+			Offset 1, 1
+
+			ZWrite On
+			ZTest LEqual
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma multi_compile_shadowcaster
+			#pragma fragmentoption ARB_precision_hint_fastest
+			#include "../CGIncludes/Spine-BlendModes-ShadowCasterPass.cginc"
+			ENDCG
+		}
+	}
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/BlendModes/Spine-Skeleton-PMA-Multiply.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 8bdcdc7ee298e594a9c20c61d25c33b6
+timeCreated: 1496446742
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/BlendModes/Spine-Skeleton-PMA-Screen.shader

@@ -0,0 +1,72 @@
+// Spine/Skeleton PMA Screen
+// - single color multiply tint
+// - unlit
+// - Premultiplied alpha Multiply blending
+// - No depth, no backface culling, no fog.
+// - ShadowCaster pass
+
+Shader "Spine/Blend Modes/Skeleton PMA Screen" {
+	Properties {
+		_Color ("Tint Color", Color) = (1,1,1,1)
+		[NoScaleOffset] _MainTex ("MainTex", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		LOD 100
+
+		Fog { Mode Off }
+		Cull Off
+		ZWrite Off
+		Blend One OneMinusSrcColor
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		Pass {
+			Name "Normal"
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#include "../CGIncludes/Spine-BlendModes-NormalPass.cginc"
+			ENDCG
+		}
+
+		Pass {
+			Name "Caster"
+			Tags { "LightMode" = "ShadowCaster" }
+			Offset 1, 1
+
+			ZWrite On
+			ZTest LEqual
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma multi_compile_shadowcaster
+			#pragma fragmentoption ARB_precision_hint_fastest
+			#include "../CGIncludes/Spine-BlendModes-ShadowCasterPass.cginc"
+			ENDCG
+		}
+	}
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/BlendModes/Spine-Skeleton-PMA-Screen.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 4e8caa36c07aacf4ab270da00784e4d9
+timeCreated: 1496448787
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 511f90ee1fe01c146836d5ed23f2e70f
+folderAsset: yes
+timeCreated: 1564083752
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-BlendModes-NormalPass.cginc

@@ -0,0 +1,39 @@
+#ifndef BLENDMODES_NORMAL_PASS_INCLUDED
+#define BLENDMODES_NORMAL_PASS_INCLUDED
+
+#include "UnityCG.cginc"
+#include "../CGIncludes/Spine-Common.cginc"
+uniform sampler2D _MainTex;
+uniform float4 _Color;
+
+struct VertexInput {
+	float4 vertex : POSITION;
+	float2 uv : TEXCOORD0;
+	float4 vertexColor : COLOR;
+};
+
+struct VertexOutput {
+	float4 pos : SV_POSITION;
+	float2 uv : TEXCOORD0;
+	float4 vertexColor : COLOR;
+};
+
+VertexOutput vert(VertexInput v) {
+	VertexOutput o;
+	o.pos = UnityObjectToClipPos(v.vertex);
+	o.uv = v.uv;
+	o.vertexColor = PMAGammaToTargetSpace(v.vertexColor) * float4(_Color.rgb * _Color.a, _Color.a); // Combine a PMA version of _Color with vertexColor.
+	return o;
+}
+
+float4 frag(VertexOutput i) : SV_Target{
+	float4 texColor = tex2D(_MainTex, i.uv);
+
+	#if defined(_STRAIGHT_ALPHA_INPUT)
+	texColor.rgb *= texColor.a;
+	#endif
+
+	return (texColor * i.vertexColor);
+}
+
+#endif

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-BlendModes-NormalPass.cginc.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 6e28a50646b0e9542a1c93c2d9d993d0
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  preprocessorOverride: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-BlendModes-ShadowCasterPass.cginc

@@ -0,0 +1,30 @@
+#ifndef BLENDMODES_SHADOWCASTER_PASS_INCLUDED
+#define BLENDMODES_SHADOWCASTER_PASS_INCLUDED
+
+#include "UnityCG.cginc"
+struct v2f {
+	V2F_SHADOW_CASTER;
+	float4 uvAndAlpha : TEXCOORD1;
+};
+
+uniform float4 _MainTex_ST;
+
+v2f vert(appdata_base v, float4 vertexColor : COLOR) {
+	v2f o;
+	TRANSFER_SHADOW_CASTER(o)
+		o.uvAndAlpha.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
+	o.uvAndAlpha.z = 0;
+	o.uvAndAlpha.a = vertexColor.a;
+	return o;
+}
+
+uniform sampler2D _MainTex;
+uniform fixed _Cutoff;
+
+float4 frag(v2f i) : SV_Target{
+	fixed4 texcol = tex2D(_MainTex, i.uvAndAlpha.xy);
+	clip(texcol.a* i.uvAndAlpha.a - _Cutoff);
+	SHADOW_CASTER_FRAGMENT(i)
+}
+
+#endif

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-BlendModes-ShadowCasterPass.cginc.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 76beace455f83a8488bf044605212b2c
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  preprocessorOverride: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-Common.cginc

@@ -0,0 +1,56 @@
+#ifndef SPINE_COMMON_INCLUDED
+#define SPINE_COMMON_INCLUDED
+
+#if defined(USE_LWRP)
+#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
+#define GammaToLinearSpace SRGBToLinear
+#define LinearToGammaSpace LinearToSRGB
+#elif defined(USE_URP)
+#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
+#define GammaToLinearSpace SRGBToLinear
+#define LinearToGammaSpace LinearToSRGB
+#else
+#include "UnityCG.cginc"
+#endif
+
+inline half3 GammaToTargetSpace(half3 gammaColor) {
+#if UNITY_COLORSPACE_GAMMA
+	return gammaColor;
+#else
+	return GammaToLinearSpace(gammaColor);
+#endif
+}
+
+inline half3 TargetToGammaSpace(half3 targetColor) {
+#if UNITY_COLORSPACE_GAMMA
+	return targetColor;
+#else
+	return LinearToGammaSpace(targetColor);
+#endif
+}
+
+inline half4 PMAGammaToTargetSpace(half4 gammaPMAColor) {
+#if UNITY_COLORSPACE_GAMMA
+	return gammaPMAColor;
+#else
+	return gammaPMAColor.a == 0 ?
+		half4(GammaToLinearSpace(gammaPMAColor.rgb), gammaPMAColor.a) :
+		half4(GammaToLinearSpace(gammaPMAColor.rgb / gammaPMAColor.a) * gammaPMAColor.a, gammaPMAColor.a);
+#endif
+}
+
+// Saturated version to prevent numerical issues that occur at CanvasRenderer
+// shader during linear-space PMA vertex color correction (countering automatic Unity conversion).
+// Note: Only use this method when the original color.rgb values lie within [0,1] range and
+// it's not an HDR color. This method is usually suitable for vertex color.
+inline half4 PMAGammaToTargetSpaceSaturated(half4 gammaPMAColor) {
+#if UNITY_COLORSPACE_GAMMA
+	return gammaPMAColor;
+#else
+	return gammaPMAColor.a == 0 ?
+		half4(GammaToLinearSpace(gammaPMAColor.rgb), gammaPMAColor.a) :
+		half4(saturate(GammaToLinearSpace(gammaPMAColor.rgb / gammaPMAColor.a)) * gammaPMAColor.a, gammaPMAColor.a);
+#endif
+}
+
+#endif

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-Common.cginc.meta

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

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-DepthOnlyPass.cginc

@@ -0,0 +1,41 @@
+#ifndef SPRITES_DEPTH_ONLY_PASS_INCLUDED
+#define SPRITES_DEPTH_ONLY_PASS_INCLUDED
+
+#include "UnityCG.cginc"
+
+sampler2D _MainTex;
+float _Cutoff;
+float _ZWriteOffset;
+
+struct VertexInput {
+	float4 positionOS : POSITION;
+	float2 texcoord : TEXCOORD0;
+	float4 vertexColor : COLOR;
+};
+
+struct VertexOutput {
+	float4 positionCS : SV_POSITION;
+	float4 texcoordAndAlpha: TEXCOORD0;
+};
+
+VertexOutput DepthOnlyVertex (VertexInput v) {
+	VertexOutput o;
+	o.positionCS = UnityObjectToClipPos(v.positionOS - float4(0, 0, _ZWriteOffset, 0));
+	o.texcoordAndAlpha.xy = v.texcoord;
+	o.texcoordAndAlpha.z = 0;
+	o.texcoordAndAlpha.a = v.vertexColor.a;
+	return o;
+}
+
+float4 DepthOnlyFragment (VertexOutput input) : SV_Target{
+	float4 texColor = tex2D(_MainTex, input.texcoordAndAlpha.rg);
+
+	#if defined(_STRAIGHT_ALPHA_INPUT)
+	texColor.rgb *= texColor.a;
+	#endif
+
+	clip(texColor.a * input.texcoordAndAlpha.a - _Cutoff);
+	return 0;
+}
+
+#endif

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-DepthOnlyPass.cginc.meta

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

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-Outline-Common.cginc

@@ -0,0 +1,53 @@
+#ifndef SPINE_OUTLINE_COMMON_INCLUDED
+#define SPINE_OUTLINE_COMMON_INCLUDED
+
+float4 computeOutlinePixel(sampler2D mainTexture, float2 mainTextureTexelSize,
+	float2 uv, float vertexColorAlpha,
+	float OutlineWidth, float OutlineReferenceTexWidth, float OutlineMipLevel,
+	float OutlineSmoothness, float ThresholdEnd, float OutlineOpaqueAlpha, float4 OutlineColor) {
+
+	float4 texColor = fixed4(0, 0, 0, 0);
+
+	float outlineWidthCompensated = OutlineWidth / (OutlineReferenceTexWidth * mainTextureTexelSize.x);
+	float xOffset = mainTextureTexelSize.x * outlineWidthCompensated;
+	float yOffset = mainTextureTexelSize.y * outlineWidthCompensated;
+	float xOffsetDiagonal = mainTextureTexelSize.x * outlineWidthCompensated * 0.7;
+	float yOffsetDiagonal = mainTextureTexelSize.y * outlineWidthCompensated * 0.7;
+
+	float pixelCenter = tex2D(mainTexture, uv).a;
+
+	float4 uvCenterWithLod = float4(uv, 0, OutlineMipLevel);
+	float pixelTop = tex2Dlod(mainTexture, uvCenterWithLod + float4(0, yOffset, 0, 0)).a;
+	float pixelBottom = tex2Dlod(mainTexture, uvCenterWithLod + float4(0, -yOffset, 0, 0)).a;
+	float pixelLeft = tex2Dlod(mainTexture, uvCenterWithLod + float4(-xOffset, 0, 0, 0)).a;
+	float pixelRight = tex2Dlod(mainTexture, uvCenterWithLod + float4(xOffset, 0, 0, 0)).a;
+#if _USE8NEIGHBOURHOOD_ON
+	float numSamples = 8;
+	float pixelTopLeft = tex2Dlod(mainTexture, uvCenterWithLod + float4(-xOffsetDiagonal, yOffsetDiagonal, 0, 0)).a;
+	float pixelTopRight = tex2Dlod(mainTexture, uvCenterWithLod + float4(xOffsetDiagonal, yOffsetDiagonal, 0, 0)).a;
+	float pixelBottomLeft = tex2Dlod(mainTexture, uvCenterWithLod + float4(-xOffsetDiagonal, -yOffsetDiagonal, 0, 0)).a;
+	float pixelBottomRight = tex2Dlod(mainTexture, uvCenterWithLod + float4(xOffsetDiagonal, -yOffsetDiagonal, 0, 0)).a;
+	float average = (pixelTop + pixelBottom + pixelLeft + pixelRight +
+		pixelTopLeft + pixelTopRight + pixelBottomLeft + pixelBottomRight)
+		* vertexColorAlpha / numSamples;
+#else // 4 neighbourhood
+	float numSamples = 4;
+	float average = (pixelTop + pixelBottom + pixelLeft + pixelRight) * vertexColorAlpha / numSamples;
+#endif
+	float thresholdStart = ThresholdEnd * (1.0 - OutlineSmoothness);
+	float outlineAlpha = saturate(saturate((average - thresholdStart) / (ThresholdEnd - thresholdStart)) - pixelCenter);
+	outlineAlpha = pixelCenter > OutlineOpaqueAlpha ? 0 : outlineAlpha;
+	return lerp(texColor, OutlineColor, outlineAlpha);
+}
+
+float4 computeOutlinePixel(sampler2D mainTexture, float2 mainTextureTexelSize,
+	float2 uv, float vertexColorAlpha,
+	float OutlineWidth, float OutlineReferenceTexWidth, float OutlineMipLevel,
+	float OutlineSmoothness, float ThresholdEnd, float4 OutlineColor) {
+
+	return computeOutlinePixel(mainTexture, mainTextureTexelSize,
+		uv, vertexColorAlpha, OutlineWidth, OutlineReferenceTexWidth, OutlineMipLevel,
+		OutlineSmoothness, ThresholdEnd, 1.0, OutlineColor);
+}
+
+#endif

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-Outline-Common.cginc.meta

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

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-Skeleton-Lit-Common-Shadow.cginc

@@ -0,0 +1,30 @@
+#ifndef SKELETON_LIT_COMMON_SHADOW_INCLUDED
+#define SKELETON_LIT_COMMON_SHADOW_INCLUDED
+
+#include "UnityCG.cginc"
+struct v2f { 
+	V2F_SHADOW_CASTER;
+	float4 uvAndAlpha : TEXCOORD1;
+};
+
+uniform float4 _MainTex_ST;
+
+v2f vertShadow(appdata_base v, float4 vertexColor : COLOR) {
+	v2f o;
+	TRANSFER_SHADOW_CASTER(o)
+	o.uvAndAlpha.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
+	o.uvAndAlpha.z = 0;
+	o.uvAndAlpha.a = vertexColor.a;
+	return o;
+}
+
+uniform sampler2D _MainTex;
+uniform fixed SHADOW_CUTOFF;
+
+float4 fragShadow (v2f i) : SV_Target {
+	fixed4 texcol = tex2D(_MainTex, i.uvAndAlpha.xy);
+	clip(texcol.a * i.uvAndAlpha.a - SHADOW_CUTOFF);
+	SHADOW_CASTER_FRAGMENT(i)
+}
+
+#endif

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-Skeleton-Lit-Common-Shadow.cginc.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: c7297b25c81d2494e8e73b742e3c7345
+timeCreated: 1564083752
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-Skeleton-Lit-Common.cginc

@@ -0,0 +1,133 @@
+#ifndef SKELETON_LIT_COMMON_INCLUDED
+#define SKELETON_LIT_COMMON_INCLUDED
+
+#include "UnityCG.cginc"
+#include "CGIncludes/Spine-Common.cginc"
+
+// ES2.0/WebGL/3DS can not do loops with non-constant-expression iteration counts :(
+#if defined(SHADER_API_GLES)
+#define LIGHT_LOOP_LIMIT 8
+#elif defined(SHADER_API_N3DS)
+#define LIGHT_LOOP_LIMIT 4
+#else
+#define LIGHT_LOOP_LIMIT unity_VertexLightParams.x
+#endif
+
+
+////////////////////////////////////////
+// Alpha Clipping
+//
+
+#if defined(_ALPHA_CLIP)
+	uniform fixed _Cutoff;
+	#define ALPHA_CLIP(pixel, color) clip((pixel.a * color.a) - _Cutoff);
+#else
+	#define ALPHA_CLIP(pixel, color)
+#endif
+
+half3 computeLighting (int idx, half3 dirToLight, half3 eyeNormal, half4 diffuseColor, half atten) {
+	half NdotL = max(dot(eyeNormal, dirToLight), 0.0);
+	// diffuse
+	half3 color = NdotL * diffuseColor.rgb * unity_LightColor[idx].rgb;
+	return color * atten;
+}
+
+half3 computeOneLight (int idx, float3 eyePosition, half3 eyeNormal, half4 diffuseColor) {
+	float3 dirToLight = unity_LightPosition[idx].xyz;
+	half att = 1.0;
+
+	#if defined(POINT) || defined(SPOT)
+	dirToLight -= eyePosition * unity_LightPosition[idx].w;
+
+	// distance attenuation
+	float distSqr = dot(dirToLight, dirToLight);
+	att /= (1.0 + unity_LightAtten[idx].z * distSqr);
+	if (unity_LightPosition[idx].w != 0 && distSqr > unity_LightAtten[idx].w) att = 0.0; // set to 0 if outside of range
+	distSqr = max(distSqr, 0.000001); // don't produce NaNs if some vertex position overlaps with the light
+	dirToLight *= rsqrt(distSqr);
+	#if defined(SPOT)
+
+	// spot angle attenuation
+	half rho = max(dot(dirToLight, unity_SpotDirection[idx].xyz), 0.0);
+	half spotAtt = (rho - unity_LightAtten[idx].x) * unity_LightAtten[idx].y;
+	att *= saturate(spotAtt);
+	#endif
+	#endif
+
+	att *= 0.5; // passed in light colors are 2x brighter than what used to be in FFP
+	return min (computeLighting (idx, dirToLight, eyeNormal, diffuseColor, att), 1.0);
+}
+
+int4 unity_VertexLightParams; // x: light count, y: zero, z: one (y/z needed by d3d9 vs loop instruction)
+
+struct appdata {
+	float3 pos : POSITION;
+	float3 normal : NORMAL;
+	half4 color : COLOR;
+	float2 uv0 : TEXCOORD0;
+#if defined(_TINT_BLACK_ON)
+	float2 tintBlackRG : TEXCOORD1;
+	float2 tintBlackB : TEXCOORD2;
+#endif
+	UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct VertexOutput {
+	fixed4 color : COLOR0;
+	float2 uv0 : TEXCOORD0;
+	float4 pos : SV_POSITION;
+	UNITY_VERTEX_OUTPUT_STEREO
+};
+
+VertexOutput vert (appdata v) {
+	VertexOutput o;
+	UNITY_SETUP_INSTANCE_ID(v);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+	half4 color = PMAGammaToTargetSpace(v.color);
+	float3 eyePos = UnityObjectToViewPos(float4(v.pos, 1)).xyz; //mul(UNITY_MATRIX_MV, float4(v.pos,1)).xyz;
+	half3 fixedNormal = half3(0,0,-1);
+	half3 eyeNormal = normalize(mul((float3x3)UNITY_MATRIX_IT_MV, fixedNormal));
+	o.uv0 = v.uv0;
+	o.pos = UnityObjectToClipPos(v.pos);
+
+#ifdef _DOUBLE_SIDED_LIGHTING
+	// unfortunately we have to compute the sign here in the vertex shader
+	// instead of using VFACE in fragment shader stage.
+	half faceSign = sign(eyeNormal.z);
+	eyeNormal *= faceSign;
+#endif
+
+	half3 shadowedColor;
+#if !defined(_LIGHT_AFFECTS_ADDITIVE)
+	if (color.a == 0) {
+		o.color = color;
+		return o;
+	}
+#endif // !defined(_LIGHT_AFFECTS_ADDITIVE)
+
+	// Lights
+	half3 lcolor = half4(0,0,0,1).rgb + color.rgb * glstate_lightmodel_ambient.rgb;
+	for (int il = 0; il < LIGHT_LOOP_LIMIT; ++il) {
+		lcolor += computeOneLight(il, eyePos, eyeNormal, color);
+	}
+
+	color.rgb = lcolor.rgb;
+	o.color = saturate(color);
+	return o;
+}
+
+sampler2D _MainTex;
+
+fixed4 frag (VertexOutput i) : SV_Target {
+	fixed4 tex = tex2D(_MainTex, i.uv0);
+	ALPHA_CLIP(tex, i.color);
+#if defined(_STRAIGHT_ALPHA_INPUT)
+	tex.rgb *= tex.a;
+#endif
+	fixed4 col = tex * i.color;
+	col.rgb *= 2;
+	return col;
+}
+
+#endif

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-Skeleton-Lit-Common.cginc.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 70c77c02aabd5e44f94aab48dd0be7b2
+timeCreated: 1564083752
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-Skeleton-Tint-Common.cginc

@@ -0,0 +1,27 @@
+#ifndef SKELETON_TINT_COMMON_INCLUDED
+#define SKELETON_TINT_COMMON_INCLUDED
+
+float4 fragTintedColor(float4 texColor, float3 darkTintColor, float4 lightTintColorPMA, float lightColorAlpha, float darkColorAlpha) {
+
+	float a = texColor.a * lightTintColorPMA.a;
+
+#if !defined(_STRAIGHT_ALPHA_INPUT)
+	float3 texDarkColor = (texColor.a - texColor.rgb);
+#else
+	float3 texDarkColor = (1 - texColor.rgb);
+#endif
+	float3 darkColor = texDarkColor * darkTintColor.rgb * lightColorAlpha;
+	float3 lightColor = texColor.rgb * lightTintColorPMA.rgb;
+
+	float4 fragColor = float4(darkColor + lightColor, a);
+#if defined(_STRAIGHT_ALPHA_INPUT)
+	fragColor.rgb *= texColor.a;
+#endif
+
+#if defined(_DARK_COLOR_ALPHA_ADDITIVE)
+	fragColor.a = a * (1 - darkColorAlpha);
+#endif
+	return fragColor;
+}
+
+#endif

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/CGIncludes/Spine-Skeleton-Tint-Common.cginc.meta

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

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: e8c87a44b93daed4383ca2ca5dfb3c43
+folderAsset: yes
+timeCreated: 1573827942
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/BlendModes.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 6a7bd28c2cf2e41499693d9f8f9e2e1a
+folderAsset: yes
+timeCreated: 1573829102
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/BlendModes/Spine-Skeleton-PMA-Additive-Outline.shader

@@ -0,0 +1,47 @@
+// Outline shader variant of "Spine/Blend Modes/Skeleton PMA Additive"
+
+Shader "Spine/Outline/Blend Modes/Skeleton PMA Additive" {
+	Properties {
+		_Color ("Tint Color", Color) = (1,1,1,1)
+		[NoScaleOffset] _MainTex ("MainTex", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		LOD 100
+
+		Fog { Mode Off }
+		Cull Off
+		ZWrite Off
+		Blend One One
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		UsePass "Spine/Outline/Skeleton/OUTLINE"
+
+		UsePass "Spine/Blend Modes/Skeleton PMA Additive/NORMAL"
+
+		UsePass "Spine/Blend Modes/Skeleton PMA Additive/CASTER"
+	}
+	FallBack "Spine/Blend Modes/Skeleton PMA Additive"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/BlendModes/Spine-Skeleton-PMA-Additive-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 0299ffae826705448b6c80ccc6a53b75
+timeCreated: 1573829476
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/BlendModes/Spine-Skeleton-PMA-Multiply-Outline.shader

@@ -0,0 +1,47 @@
+// Outline shader variant of "Spine/Blend Modes/Skeleton PMA Multiply"
+
+Shader "Spine/Outline/Blend Modes/Skeleton PMA Multiply" {
+	Properties {
+		_Color ("Tint Color", Color) = (1,1,1,1)
+		[NoScaleOffset] _MainTex ("MainTex", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		LOD 100
+
+		Fog { Mode Off }
+		Cull Off
+		ZWrite Off
+		Blend DstColor OneMinusSrcAlpha
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		UsePass "Spine/Outline/Skeleton/OUTLINE"
+
+		UsePass "Spine/Blend Modes/Skeleton PMA Multiply/NORMAL"
+
+		UsePass "Spine/Blend Modes/Skeleton PMA Multiply/CASTER"
+	}
+	FallBack "Spine/Blend Modes/Skeleton PMA Multiply"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/BlendModes/Spine-Skeleton-PMA-Multiply-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 4b3566a937643b8498d1ec6df5880b77
+timeCreated: 1573829476
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/BlendModes/Spine-Skeleton-PMA-Screen-Outline.shader

@@ -0,0 +1,47 @@
+// Outline shader variant of "Spine/Blend Modes/Skeleton PMA Screen"
+
+Shader "Spine/Outline/Blend Modes/Skeleton PMA Screen" {
+	Properties {
+		_Color ("Tint Color", Color) = (1,1,1,1)
+		[NoScaleOffset] _MainTex ("MainTex", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		LOD 100
+
+		Fog { Mode Off }
+		Cull Off
+		ZWrite Off
+		Blend One OneMinusSrcColor
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		UsePass "Spine/Outline/Skeleton/OUTLINE"
+
+		UsePass "Spine/Blend Modes/Skeleton PMA Screen/NORMAL"
+
+		UsePass "Spine/Blend Modes/Skeleton PMA Screen/CASTER"
+	}
+	FallBack "Spine/Blend Modes/Skeleton PMA Screen"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/BlendModes/Spine-Skeleton-PMA-Screen-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: e61a8d94e453ff641a7e39c4b11cac95
+timeCreated: 1573829476
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/CGIncludes.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 329bda94bce571446a1a149b53ccf45c
+folderAsset: yes
+timeCreated: 1574096529
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/CGIncludes/Spine-Outline-Pass.cginc

@@ -0,0 +1,93 @@
+#ifndef SPINE_OUTLINE_PASS_INCLUDED
+#define SPINE_OUTLINE_PASS_INCLUDED
+
+#include "UnityCG.cginc"
+
+#ifdef SKELETON_GRAPHIC
+#include "UnityUI.cginc"
+#endif
+
+#include "../../CGIncludes/Spine-Outline-Common.cginc"
+
+sampler2D _MainTex;
+
+float _OutlineWidth;
+float4 _OutlineColor;
+float4 _MainTex_TexelSize;
+float _ThresholdEnd;
+float _OutlineSmoothness;
+float _OutlineOpaqueAlpha;
+float _OutlineMipLevel;
+int _OutlineReferenceTexWidth;
+
+#ifdef SKELETON_GRAPHIC
+float4 _ClipRect;
+#endif
+
+struct VertexInput {
+	float4 vertex : POSITION;
+	float2 uv : TEXCOORD0;
+	float4 vertexColor : COLOR;
+	UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct VertexOutput {
+	float4 pos : SV_POSITION;
+	float2 uv : TEXCOORD0;
+	float vertexColorAlpha : COLOR;
+#ifdef SKELETON_GRAPHIC
+	float4 worldPosition : TEXCOORD1;
+#endif
+	UNITY_VERTEX_OUTPUT_STEREO
+};
+
+
+#ifdef SKELETON_GRAPHIC
+
+VertexOutput vertOutlineGraphic(VertexInput v) {
+	VertexOutput o;
+
+	UNITY_SETUP_INSTANCE_ID(v);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+	o.worldPosition = v.vertex;
+	o.pos = UnityObjectToClipPos(o.worldPosition);
+	o.uv = v.uv;
+
+#ifdef UNITY_HALF_TEXEL_OFFSET
+	o.pos.xy += (_ScreenParams.zw - 1.0) * float2(-1, 1);
+#endif
+
+	o.vertexColorAlpha = v.vertexColor.a;
+	return o;
+}
+
+#else // !SKELETON_GRAPHIC
+
+VertexOutput vertOutline(VertexInput v) {
+	VertexOutput o;
+
+	UNITY_SETUP_INSTANCE_ID(v);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+	o.pos = UnityObjectToClipPos(v.vertex);
+	o.uv = v.uv;
+	o.vertexColorAlpha = v.vertexColor.a;
+	return o;
+}
+#endif
+
+float4 fragOutline(VertexOutput i) : SV_Target {
+
+	float4 texColor = computeOutlinePixel(_MainTex, _MainTex_TexelSize.xy, i.uv, i.vertexColorAlpha,
+		_OutlineWidth, _OutlineReferenceTexWidth, _OutlineMipLevel,
+		_OutlineSmoothness, _ThresholdEnd, _OutlineOpaqueAlpha, _OutlineColor);
+
+#ifdef SKELETON_GRAPHIC
+	texColor *= UnityGet2DClipping(i.worldPosition.xy, _ClipRect);
+#endif
+
+	return texColor;
+}
+
+#endif // SPINE_OUTLINE_PASS_INCLUDED

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/CGIncludes/Spine-Outline-Pass.cginc.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 2ec781e799f97504c8a418e168759f70
+timeCreated: 1574096529
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/SkeletonGraphic.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 6e8ed065898e65f4d9303492725fb912
+folderAsset: yes
+timeCreated: 1573829873
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/SkeletonGraphic/Spine-SkeletonGraphic-Outline.shader

@@ -0,0 +1,76 @@
+// Outline shader variant of "Spine/SkeletonGraphic"
+
+Shader "Spine/Outline/SkeletonGraphic"
+{
+	Properties
+	{
+		[PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[Toggle(_CANVAS_GROUP_COMPATIBLE)] _CanvasGroupCompatible("CanvasGroup Compatible", Int) = 1
+		_Color ("Tint", Color) = (1,1,1,1)
+
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
+		[HideInInspector] _Stencil ("Stencil ID", Float) = 0
+		[HideInInspector][Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
+		[HideInInspector] _StencilWriteMask ("Stencil Write Mask", Float) = 255
+		[HideInInspector] _StencilReadMask ("Stencil Read Mask", Float) = 255
+
+		[HideInInspector] _ColorMask ("Color Mask", Float) = 15
+
+		[Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 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]
+		Fog { Mode Off }
+		Blend One OneMinusSrcAlpha
+		ColorMask [_ColorMask]
+
+		Pass {
+			Name "Outline"
+			CGPROGRAM
+			#pragma vertex vertOutlineGraphic
+			#pragma fragment fragOutline
+			#define SKELETON_GRAPHIC
+			#pragma shader_feature _ _USE8NEIGHBOURHOOD_ON
+			#include "../CGIncludes/Spine-Outline-Pass.cginc"
+			ENDCG
+		}
+
+		UsePass "Spine/SkeletonGraphic/NORMAL"
+	}
+	FallBack "Spine/SkeletonGraphic"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/SkeletonGraphic/Spine-SkeletonGraphic-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 8f5d14d2a7fedb84998c50eb96c8b748
+timeCreated: 1573829873
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/SkeletonGraphic/Spine-SkeletonGraphic-TintBlack-Outline.shader

@@ -0,0 +1,69 @@
+// Outline shader variant of "Spine/SkeletonGraphic Tint Black"
+
+Shader "Spine/Outline/SkeletonGraphic Tint Black"
+{
+	Properties
+	{
+		[PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[Toggle(_CANVAS_GROUP_COMPATIBLE)] _CanvasGroupCompatible("CanvasGroup Compatible", Int) = 1
+
+		_Color ("Tint", Color) = (1,1,1,1)
+		_Black ("Black Point", Color) = (0,0,0,0)
+
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
+		[HideInInspector] _Stencil ("Stencil ID", Float) = 0
+		[HideInInspector][Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
+		[HideInInspector] _StencilWriteMask ("Stencil Write Mask", Float) = 255
+		[HideInInspector] _StencilReadMask ("Stencil Read Mask", Float) = 255
+
+		[HideInInspector] _ColorMask ("Color Mask", Float) = 15
+
+		[Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 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]
+		Fog { Mode Off }
+		Blend One OneMinusSrcAlpha
+		ColorMask [_ColorMask]
+
+		UsePass "Spine/Outline/SkeletonGraphic/OUTLINE"
+
+		UsePass "Spine/SkeletonGraphic Tint Black/NORMAL"
+	}
+	FallBack "Spine/SkeletonGraphic Tint Black"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/SkeletonGraphic/Spine-SkeletonGraphic-TintBlack-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: d55d64dd09c46af40a319933a62fa1b2
+timeCreated: 1573830121
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Skeleton-Fill-Outline.shader

@@ -0,0 +1,44 @@
+// Outline shader variant of "Spine/Skeleton Fill"
+
+Shader "Spine/Outline/Skeleton Fill" {
+	Properties {
+		_FillColor ("FillColor", Color) = (1,1,1,1)
+		_FillPhase ("FillPhase", Range(0, 1)) = 0
+		[NoScaleOffset] _MainTex ("MainTex", 2D) = "white" {}
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" }
+		Blend One OneMinusSrcAlpha
+		Cull Off
+		ZWrite Off
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		UsePass "Spine/Outline/Skeleton/OUTLINE"
+
+		UsePass "Spine/Skeleton Fill/NORMAL"
+
+		UsePass "Spine/Skeleton Fill/CASTER"
+	}
+	FallBack "Spine/Skeleton Fill"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Skeleton-Fill-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: e158cbe58baa093438feb3d691f3daba
+timeCreated: 1573817434
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Skeleton-Lit-Outline.shader

@@ -0,0 +1,41 @@
+// Outline shader variant of "Spine/Skeleton Lit"
+
+Shader "Spine/Outline/Skeleton Lit" {
+	Properties {
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[NoScaleOffset] _MainTex ("Main Texture", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[Toggle(_DOUBLE_SIDED_LIGHTING)] _DoubleSidedLighting("Double-Sided Lighting", Int) = 0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		LOD 100
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		UsePass "Spine/Outline/Skeleton/OUTLINE"
+
+		UsePass "Spine/Skeleton Lit/NORMAL"
+
+		UsePass "Spine/Skeleton Lit/CASTER"
+	}
+	FallBack "Spine/Skeleton Lit"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Skeleton-Lit-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 10fab3f69a099be4391fe8a1ad880c65
+timeCreated: 1573828963
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Skeleton-Lit-ZWrite-Outline.shader

@@ -0,0 +1,42 @@
+// Outline shader variant of "Spine/Skeleton Lit ZWrite"
+
+Shader "Spine/Outline/Skeleton Lit ZWrite" {
+	Properties {
+		_Cutoff ("Depth alpha cutoff", Range(0,1)) = 0.1
+		_ShadowAlphaCutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[NoScaleOffset] _MainTex ("Main Texture", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[Toggle(_DOUBLE_SIDED_LIGHTING)] _DoubleSidedLighting("Double-Sided Lighting", Int) = 0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		LOD 100
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		UsePass "Spine/Outline/Skeleton/OUTLINE"
+
+		UsePass "Spine/Skeleton Lit ZWrite/NORMAL"
+
+		UsePass "Spine/Skeleton Lit ZWrite/CASTER"
+	}
+	FallBack "Spine/Skeleton Lit ZWrite"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Skeleton-Lit-ZWrite-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 756be4f2f738f6c4583bb1c90e16bf0b
+timeCreated: 1573828964
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Skeleton-Outline.shader

@@ -0,0 +1,53 @@
+// Outline shader variant of "Spine/Skeleton"
+
+Shader "Spine/Outline/Skeleton" {
+	Properties {
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[NoScaleOffset] _MainTex ("Main Texture", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" }
+
+		Fog { Mode Off }
+		Cull Off
+		ZWrite Off
+		Blend One OneMinusSrcAlpha
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		Pass {
+			Name "Outline"
+			CGPROGRAM
+			#pragma vertex vertOutline
+			#pragma fragment fragOutline
+			#pragma shader_feature _ _USE8NEIGHBOURHOOD_ON
+			#include "CGIncludes/Spine-Outline-Pass.cginc"
+			ENDCG
+		}
+
+		UsePass "Spine/Skeleton/NORMAL"
+
+		UsePass "Spine/Skeleton/CASTER"
+	}
+	FallBack "Spine/Skeleton"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Skeleton-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 28b5cf4804845fe4b868531fd0bb81d5
+timeCreated: 1573817434
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Skeleton-OutlineOnly-ZWrite.shader

@@ -0,0 +1,63 @@
+Shader "Spine/Outline/OutlineOnly-ZWrite" {
+	Properties {
+		_Cutoff ("Depth alpha cutoff", Range(0,1)) = 0.1
+		_ZWriteOffset ("Depth offset", Range(0,1)) = 0.01
+		[NoScaleOffset] _MainTex ("Main Texture", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" }
+
+		Fog { Mode Off }
+		Cull Off
+		ZWrite Off
+		Blend One OneMinusSrcAlpha
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		Pass
+		{
+			Name "DepthOnly"
+
+			ZWrite On
+			ColorMask 0
+			Cull Off
+
+			CGPROGRAM
+			#pragma vertex DepthOnlyVertex
+			#pragma fragment DepthOnlyFragment
+			#include "../CGIncludes/Spine-DepthOnlyPass.cginc"
+			ENDCG
+		}
+
+		Pass {
+			Name "Outline"
+			CGPROGRAM
+			#pragma vertex vertOutline
+			#pragma fragment fragOutline
+			#pragma shader_feature _ _USE8NEIGHBOURHOOD_ON
+			#include "CGIncludes/Spine-Outline-Pass.cginc"
+			ENDCG
+		}
+	}
+	FallBack "Spine/Skeleton"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Skeleton-OutlineOnly-ZWrite.shader.meta

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

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Skeleton-Tint-Outline.shader

@@ -0,0 +1,47 @@
+// Outline shader variant of "Spine/Skeleton Tint"
+
+Shader "Spine/Outline/Skeleton Tint" {
+	Properties {
+		_Color ("Tint Color", Color) = (1,1,1,1)
+		_Black ("Black Point", Color) = (0,0,0,0)
+		[NoScaleOffset] _MainTex ("MainTex", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		_Cutoff("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" }
+
+		Fog { Mode Off }
+		Cull Off
+		ZWrite Off
+		Blend One OneMinusSrcAlpha
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		UsePass "Spine/Outline/Skeleton/OUTLINE"
+
+		UsePass "Spine/Skeleton Tint/NORMAL"
+
+		UsePass "Spine/Skeleton Tint/CASTER"
+	}
+	FallBack "Spine/Skeleton Tint"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Skeleton-Tint-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 4f1fdc166fed03649835949d3b79cba3
+timeCreated: 1573817434
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Skeleton-TintBlack-Outline.shader

@@ -0,0 +1,48 @@
+// Outline shader variant of "Spine/Skeleton Tint Black"
+
+Shader "Spine/Outline/Skeleton Tint Black" {
+	Properties {
+		_Color ("Tint Color", Color) = (1,1,1,1)
+		_Black ("Black Point", Color) = (0,0,0,0)
+		[NoScaleOffset] _MainTex ("MainTex", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		LOD 100
+
+		Fog { Mode Off }
+		Cull Off
+		ZWrite Off
+		Blend One OneMinusSrcAlpha
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		UsePass "Spine/Outline/Skeleton/OUTLINE"
+
+		UsePass "Spine/Skeleton Tint Black/NORMAL"
+
+		UsePass "Spine/Skeleton Tint Black/CASTER"
+	}
+	FallBack "Spine/Special/Skeleton Grayscale"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Skeleton-TintBlack-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 49cf725a1e40e7742be92917f83946c3
+timeCreated: 1573828963
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Special-Skeleton-Grayscale-Outline.shader

@@ -0,0 +1,44 @@
+// Outline shader variant of "Spine/Special/Skeleton Grayscale"
+
+Shader "Spine/Outline/Special/Skeleton Grayscale" {
+	Properties {
+		_GrayPhase ("Phase", Range(0, 1)) = 1
+		[NoScaleOffset] _MainTex ("MainTex", 2D) = "white" {}
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" }
+		Blend One OneMinusSrcAlpha
+		Cull Off
+		ZWrite Off
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		UsePass "Spine/Outline/Skeleton/OUTLINE"
+
+		UsePass "Spine/Special/Skeleton Grayscale/NORMAL"
+
+		UsePass "Spine/Special/Skeleton Grayscale/CASTER"
+	}
+	FallBack "Spine/Special/Skeleton Grayscale"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Spine-Special-Skeleton-Grayscale-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 1d3e1518ae643a749b086bc7972893d2
+timeCreated: 1573828963
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Sprite.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 615182d5e489bf3478299e5bbf15dc23
+folderAsset: yes
+timeCreated: 1573830740
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Sprite/SpritesPixelLit-Outline.shader

@@ -0,0 +1,82 @@
+// Outline shader variant of "Spine/Sprite/Pixel Lit"
+
+Shader "Spine/Outline/Sprite/Pixel Lit"
+{
+	Properties
+	{
+		_MainTex ("Main Texture", 2D) = "white" {}
+		_Color ("Color", Color) = (1,1,1,1)
+
+		_BumpScale("Scale", Float) = 1.0
+		_BumpMap ("Normal Map", 2D) = "bump" {}
+
+		[MaterialToggle] PixelSnap ("Pixel snap", Float) = 0
+
+		_EmissionColor("Color", Color) = (0,0,0,0)
+		_EmissionMap("Emission", 2D) = "white" {}
+		_EmissionPower("Emission Power", Float) = 2.0
+
+		_Glossiness("Smoothness", Range(0.0, 1.0)) = 0.5
+		_GlossMapScale("Smoothness Scale", Range(0.0, 1.0)) = 1.0
+		[Gamma] _Metallic("Metallic", Range(0.0, 1.0)) = 0.0
+		_MetallicGlossMap("Metallic", 2D) = "white" {}
+
+		_DiffuseRamp ("Diffuse Ramp Texture", 2D) = "gray" {}
+
+		_FixedNormal ("Fixed Normal", Vector) = (0,0,1,1)
+		_Cutoff ("Depth alpha cutoff", Range(0,1)) = 0.5
+		_ShadowAlphaCutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		_CustomRenderQueue ("Custom Render Queue", Float) = 0.0
+
+		_OverlayColor ("Overlay Color", Color) = (0,0,0,0)
+		_Hue("Hue", Range(-0.5,0.5)) = 0.0
+		_Saturation("Saturation", Range(0,2)) = 1.0
+		_Brightness("Brightness", Range(0,2)) = 1.0
+
+		_RimPower("Rim Power", Float) = 2.0
+		_RimColor ("Rim Color", Color) = (1,1,1,1)
+
+		_BlendTex ("Blend Texture", 2D) = "white" {}
+		_BlendAmount ("Blend", Range(0,1)) = 0.0
+
+		[HideInInspector] _SrcBlend ("__src", Float) = 1.0
+		[HideInInspector] _DstBlend ("__dst", Float) = 0.0
+		[HideInInspector] _RenderQueue ("__queue", Float) = 0.0
+		[HideInInspector] _Cull ("__cull", Float) = 0.0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader
+	{
+		Tags { "Queue"="Transparent" "RenderType"="Sprite" "AlphaDepth"="False" "CanUseSpriteAtlas"="True" "IgnoreProjector"="True" }
+		LOD 200
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		UsePass "Spine/Outline/Skeleton/OUTLINE"
+
+		UsePass "Spine/Sprite/Pixel Lit/FORWARD"
+
+		UsePass "Spine/Sprite/Pixel Lit/FORWARD_DELTA"
+
+		UsePass "Spine/Sprite/Pixel Lit/SHADOWCASTER"
+	}
+
+	FallBack "Spine/Sprite/Pixel Lit"
+	CustomEditor "SpineSpriteShaderGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Sprite/SpritesPixelLit-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a27d4b27c8ecd9840a03558ccc5ad8a3
+timeCreated: 1573830741
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Sprite/SpritesUnlit-Outline.shader

@@ -0,0 +1,62 @@
+// Outline shader variant of "Spine/Sprite/Unlit"
+
+Shader "Spine/Outline/Sprite/Unlit"
+{
+	Properties
+	{
+		_MainTex ("Main Texture", 2D) = "white" {}
+		_Color ("Color", Color) = (1,1,1,1)
+
+		[MaterialToggle] PixelSnap ("Pixel snap", Float) = 0
+
+		_ZWrite ("Depth Write", Float) = 0.0
+		_Cutoff ("Depth alpha cutoff", Range(0,1)) = 0.0
+		_ShadowAlphaCutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		_CustomRenderQueue ("Custom Render Queue", Float) = 0.0
+
+		_OverlayColor ("Overlay Color", Color) = (0,0,0,0)
+		_Hue("Hue", Range(-0.5,0.5)) = 0.0
+		_Saturation("Saturation", Range(0,2)) = 1.0
+		_Brightness("Brightness", Range(0,2)) = 1.0
+
+		_BlendTex ("Blend Texture", 2D) = "white" {}
+		_BlendAmount ("Blend", Range(0,1)) = 0.0
+
+		[HideInInspector] _SrcBlend ("__src", Float) = 1.0
+		[HideInInspector] _DstBlend ("__dst", Float) = 0.0
+		[HideInInspector] _RenderQueue ("__queue", Float) = 0.0
+		[HideInInspector] _Cull ("__cull", Float) = 0.0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader
+	{
+		Tags { "Queue"="Transparent" "RenderType"="Sprite" "AlphaDepth"="False" "CanUseSpriteAtlas"="True" "IgnoreProjector"="True" }
+		LOD 100
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		UsePass "Spine/Outline/Skeleton/OUTLINE"
+
+		UsePass "Spine/Sprite/Unlit/NORMAL"
+
+		UsePass "Spine/Sprite/Unlit/SHADOWCASTER"
+	}
+	FallBack "Spine/Sprite/Unlit"
+	CustomEditor "SpineSpriteShaderGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Sprite/SpritesUnlit-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 276c07e3bdd5719458187a5823e9d96a
+timeCreated: 1573830740
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Sprite/SpritesVertexLit-Outline.shader

@@ -0,0 +1,81 @@
+// Outline shader variant of "Spine/Sprite/Vertex Lit"
+
+Shader "Spine/Outline/Sprite/Vertex Lit"
+{
+	Properties
+	{
+		_MainTex ("Main Texture", 2D) = "white" {}
+		_Color ("Color", Color) = (1,1,1,1)
+
+		_BumpScale("Scale", Float) = 1.0
+		_BumpMap ("Normal Map", 2D) = "bump" {}
+
+		[MaterialToggle] PixelSnap ("Pixel snap", Float) = 0
+
+		_EmissionColor("Color", Color) = (0,0,0,0)
+		_EmissionMap("Emission", 2D) = "white" {}
+		_EmissionPower("Emission Power", Float) = 2.0
+
+		_Glossiness("Smoothness", Range(0.0, 1.0)) = 0.5
+		_GlossMapScale("Smoothness Scale", Range(0.0, 1.0)) = 1.0
+		[Gamma] _Metallic("Metallic", Range(0.0, 1.0)) = 0.0
+		_MetallicGlossMap("Metallic", 2D) = "white" {}
+
+		_DiffuseRamp ("Diffuse Ramp Texture", 2D) = "gray" {}
+
+		_FixedNormal ("Fixed Normal", Vector) = (0,0,1,1)
+		_ZWrite ("Depth Write", Float) = 0.0
+		_Cutoff ("Depth alpha cutoff", Range(0,1)) = 0.0
+		_ShadowAlphaCutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		_CustomRenderQueue ("Custom Render Queue", Float) = 0.0
+
+		_OverlayColor ("Overlay Color", Color) = (0,0,0,0)
+		_Hue("Hue", Range(-0.5,0.5)) = 0.0
+		_Saturation("Saturation", Range(0,2)) = 1.0
+		_Brightness("Brightness", Range(0,2)) = 1.0
+
+		_RimPower("Rim Power", Float) = 2.0
+		_RimColor ("Rim Color", Color) = (1,1,1,1)
+
+		_BlendTex ("Blend Texture", 2D) = "white" {}
+		_BlendAmount ("Blend", Range(0,1)) = 0.0
+
+		[HideInInspector] _SrcBlend ("__src", Float) = 1.0
+		[HideInInspector] _DstBlend ("__dst", Float) = 0.0
+		[HideInInspector] _RenderQueue ("__queue", Float) = 0.0
+		[HideInInspector] _Cull ("__cull", Float) = 0.0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader
+	{
+		Tags { "Queue"="Transparent" "RenderType"="Sprite" "AlphaDepth"="False" "CanUseSpriteAtlas"="True" "IgnoreProjector"="True" }
+		LOD 150
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		UsePass "Spine/Outline/Skeleton/OUTLINE"
+
+		UsePass "Spine/Sprite/Vertex Lit/VERTEX"
+
+		UsePass "Spine/Sprite/Vertex Lit/SHADOWCASTER"
+	}
+
+	FallBack "Spine/Sprite/Vertex Lit"
+	CustomEditor "SpineSpriteShaderGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Outline/Sprite/SpritesVertexLit-Outline.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 30ef5dd318033004588a6481c092416a
+timeCreated: 1573830740
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 7a42d52714848d64f8ff99dddb93500e
+folderAsset: yes
+timeCreated: 1563289150
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/CGIncludes.meta

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

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/CGIncludes/Spine-SkeletonGraphic-NormalPass.cginc

@@ -0,0 +1,87 @@
+#ifndef SKELETON_GRAPHIC_NORMALPASS_INCLUDED
+#define SKELETON_GRAPHIC_NORMALPASS_INCLUDED
+
+#include "UnityCG.cginc"
+#include "UnityUI.cginc"
+#include "../../CGIncludes/Spine-Common.cginc"
+
+#pragma multi_compile __ UNITY_UI_ALPHACLIP
+
+struct VertexInput {
+	float4 vertex   : POSITION;
+	float4 color    : COLOR;
+	float2 texcoord : TEXCOORD0;
+	UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct VertexOutput {
+	float4 vertex   : SV_POSITION;
+	fixed4 color    : COLOR;
+	half2 texcoord  : TEXCOORD0;
+	float4 worldPosition : TEXCOORD1;
+	UNITY_VERTEX_OUTPUT_STEREO
+};
+
+fixed4 _Color;
+fixed4 _TextureSampleAdd;
+float4 _ClipRect;
+
+#ifdef ENABLE_FILL
+float4 _FillColor;
+float _FillPhase;
+#endif
+
+VertexOutput vert (VertexInput IN) {
+	VertexOutput 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;
+
+	#ifdef UNITY_HALF_TEXEL_OFFSET
+	OUT.vertex.xy += (_ScreenParams.zw-1.0) * float2(-1,1);
+	#endif
+
+#ifdef _CANVAS_GROUP_COMPATIBLE
+	half4 vertexColor = IN.color;
+	// CanvasGroup alpha sets vertex color alpha, but does not premultiply it to rgb components.
+	vertexColor.rgb *= vertexColor.a;
+	// Unfortunately we cannot perform the TargetToGamma and PMAGammaToTarget transformations,
+	// as these would be wrong with modified alpha.
+#else
+	// Note: CanvasRenderer performs a GammaToTargetSpace conversion on vertex color already,
+	// however incorrectly assuming straight alpha color.
+	// Saturated version used to prevent numerical issues of certain low-alpha values.
+	float4 vertexColor = PMAGammaToTargetSpaceSaturated(half4(TargetToGammaSpace(IN.color.rgb), IN.color.a));
+#endif
+	OUT.color = vertexColor * float4(_Color.rgb * _Color.a, _Color.a); // Combine a PMA version of _Color with vertexColor.
+	return OUT;
+}
+
+sampler2D _MainTex;
+
+fixed4 frag (VertexOutput IN) : SV_Target
+{
+	half4 texColor = tex2D(_MainTex, IN.texcoord);
+
+	#if defined(_STRAIGHT_ALPHA_INPUT)
+	texColor.rgb *= texColor.a;
+	#endif
+
+	half4 color = (texColor + _TextureSampleAdd) * IN.color;
+	color *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect);
+
+	#ifdef UNITY_UI_ALPHACLIP
+	clip (color.a - 0.001);
+	#endif
+
+	#ifdef ENABLE_FILL
+	color.rgb = lerp(color.rgb, (_FillColor.rgb * color.a), _FillPhase); // make sure to PMA _FillColor.
+	#endif
+	return color;
+}
+
+#endif

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/CGIncludes/Spine-SkeletonGraphic-NormalPass.cginc.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 7f1f20f6ddb670f4998f78d0417912ee
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/Spine-SkeletonGraphic-Additive.shader

@@ -0,0 +1,77 @@
+// This is a premultiply-alpha adaptation of the built-in Unity shader "UI/Default" in Unity 5.6.2 to allow Unity UI stencil masking.
+
+Shader "Spine/SkeletonGraphic Additive"
+{
+	Properties
+	{
+		[PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[Toggle(_CANVAS_GROUP_COMPATIBLE)] _CanvasGroupCompatible("CanvasGroup Compatible", Int) = 1
+		_Color ("Tint", Color) = (1,1,1,1)
+
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
+		[HideInInspector] _Stencil ("Stencil ID", Float) = 0
+		[HideInInspector][Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
+		[HideInInspector] _StencilWriteMask ("Stencil Write Mask", Float) = 255
+		[HideInInspector] _StencilReadMask ("Stencil Read Mask", Float) = 255
+
+		[HideInInspector] _ColorMask ("Color Mask", Float) = 15
+
+		[Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 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]
+		Fog { Mode Off }
+		Blend One One
+		ColorMask [_ColorMask]
+
+		Pass
+		{
+			Name "Normal"
+
+		CGPROGRAM
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#pragma shader_feature _ _CANVAS_GROUP_COMPATIBLE
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma target 2.0
+
+			#include "CGIncludes/Spine-SkeletonGraphic-NormalPass.cginc"
+		ENDCG
+		}
+	}
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/Spine-SkeletonGraphic-Additive.shader.meta

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

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/Spine-SkeletonGraphic-Fill.shader

@@ -0,0 +1,78 @@
+Shader "Spine/SkeletonGraphic Fill"
+{
+	Properties
+	{
+		_FillColor("FillColor", Color) = (1,1,1,1)
+		_FillPhase("FillPhase", Range(0, 1)) = 0
+		[PerRendererData] _MainTex("Sprite Texture", 2D) = "white" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[Toggle(_CANVAS_GROUP_COMPATIBLE)] _CanvasGroupCompatible("CanvasGroup Compatible", Int) = 1
+		_Color("Tint", Color) = (1,1,1,1)
+
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8
+		[HideInInspector] _Stencil("Stencil ID", Float) = 0
+		[HideInInspector][Enum(UnityEngine.Rendering.StencilOp)] _StencilOp("Stencil Operation", Float) = 0
+		[HideInInspector] _StencilWriteMask("Stencil Write Mask", Float) = 255
+		[HideInInspector] _StencilReadMask("Stencil Read Mask", Float) = 255
+
+		[HideInInspector] _ColorMask("Color Mask", Float) = 15
+
+		[Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip("Use Alpha Clip", Float) = 0
+
+			// Outline properties are drawn via custom editor.
+			[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+			[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+			[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+			[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+			[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+			[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+			[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+			[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 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]
+			Fog { Mode Off }
+			Blend One OneMinusSrcAlpha
+			ColorMask[_ColorMask]
+
+			Pass
+			{
+				Name "Normal"
+
+			CGPROGRAM
+				#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+				#pragma shader_feature _ _CANVAS_GROUP_COMPATIBLE
+				#pragma vertex vert
+				#pragma fragment frag
+				#pragma target 2.0
+
+				#define ENABLE_FILL
+				#include "CGIncludes/Spine-SkeletonGraphic-NormalPass.cginc"
+			ENDCG
+			}
+		}
+			CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/Spine-SkeletonGraphic-Fill.shader.meta

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

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/Spine-SkeletonGraphic-Multiply.shader

@@ -0,0 +1,77 @@
+// This is a premultiply-alpha adaptation of the built-in Unity shader "UI/Default" in Unity 5.6.2 to allow Unity UI stencil masking.
+
+Shader "Spine/SkeletonGraphic Multiply"
+{
+	Properties
+	{
+		[PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[Toggle(_CANVAS_GROUP_COMPATIBLE)] _CanvasGroupCompatible("CanvasGroup Compatible", Int) = 1
+		_Color ("Tint", Color) = (1,1,1,1)
+
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
+		[HideInInspector] _Stencil ("Stencil ID", Float) = 0
+		[HideInInspector][Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
+		[HideInInspector] _StencilWriteMask ("Stencil Write Mask", Float) = 255
+		[HideInInspector] _StencilReadMask ("Stencil Read Mask", Float) = 255
+
+		[HideInInspector] _ColorMask ("Color Mask", Float) = 15
+
+		[Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 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]
+		Fog { Mode Off }
+		Blend DstColor OneMinusSrcAlpha
+		ColorMask [_ColorMask]
+
+		Pass
+		{
+			Name "Normal"
+
+		CGPROGRAM
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#pragma shader_feature _ _CANVAS_GROUP_COMPATIBLE
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma target 2.0
+
+			#include "CGIncludes/Spine-SkeletonGraphic-NormalPass.cginc"
+		ENDCG
+		}
+	}
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/Spine-SkeletonGraphic-Multiply.shader.meta

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

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/Spine-SkeletonGraphic-Screen.shader

@@ -0,0 +1,77 @@
+// This is a premultiply-alpha adaptation of the built-in Unity shader "UI/Default" in Unity 5.6.2 to allow Unity UI stencil masking.
+
+Shader "Spine/SkeletonGraphic Screen"
+{
+	Properties
+	{
+		[PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[Toggle(_CANVAS_GROUP_COMPATIBLE)] _CanvasGroupCompatible("CanvasGroup Compatible", Int) = 1
+		_Color ("Tint", Color) = (1,1,1,1)
+
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
+		[HideInInspector] _Stencil ("Stencil ID", Float) = 0
+		[HideInInspector][Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
+		[HideInInspector] _StencilWriteMask ("Stencil Write Mask", Float) = 255
+		[HideInInspector] _StencilReadMask ("Stencil Read Mask", Float) = 255
+
+		[HideInInspector] _ColorMask ("Color Mask", Float) = 15
+
+		[Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 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]
+		Fog { Mode Off }
+		Blend One OneMinusSrcColor
+		ColorMask [_ColorMask]
+
+		Pass
+		{
+			Name "Normal"
+
+		CGPROGRAM
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#pragma shader_feature _ _CANVAS_GROUP_COMPATIBLE
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma target 2.0
+
+			#include "CGIncludes/Spine-SkeletonGraphic-NormalPass.cginc"
+		ENDCG
+		}
+	}
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/Spine-SkeletonGraphic-Screen.shader.meta

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

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/Spine-SkeletonGraphic-TintBlack.shader

@@ -0,0 +1,159 @@
+// This is a premultiply-alpha adaptation of the built-in Unity shader "UI/Default" to allow Unity UI stencil masking.
+
+Shader "Spine/SkeletonGraphic Tint Black"
+{
+	Properties
+	{
+		[PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[Toggle(_CANVAS_GROUP_COMPATIBLE)] _CanvasGroupCompatible("CanvasGroup Compatible", Int) = 1
+
+		_Color ("Tint Color", Color) = (1,1,1,1)
+		_Black ("Dark Color", Color) = (0,0,0,0)
+		[Toggle(_DARK_COLOR_ALPHA_ADDITIVE)] _DarkColorAlphaAdditive("Additive DarkColor.A", Int) = 0
+
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
+		[HideInInspector] _Stencil ("Stencil ID", Float) = 0
+		[HideInInspector][Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
+		[HideInInspector] _StencilWriteMask ("Stencil Write Mask", Float) = 255
+		[HideInInspector] _StencilReadMask ("Stencil Read Mask", Float) = 255
+
+		[HideInInspector] _ColorMask ("Color Mask", Float) = 15
+
+		[Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 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]
+		Fog { Mode Off }
+		Blend One OneMinusSrcAlpha
+		ColorMask [_ColorMask]
+
+		Pass
+		{
+			Name "Normal"
+
+		CGPROGRAM
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#pragma shader_feature _ _CANVAS_GROUP_COMPATIBLE
+			#pragma shader_feature _ _DARK_COLOR_ALPHA_ADDITIVE
+			#pragma vertex vert
+			#pragma fragment frag
+
+			#include "UnityCG.cginc"
+			#include "UnityUI.cginc"
+			#include "../CGIncludes/Spine-Common.cginc"
+
+			#pragma multi_compile __ UNITY_UI_ALPHACLIP
+
+			struct VertexInput {
+				float4 vertex   : POSITION;
+				float4 color    : COLOR;
+				float2 texcoord : TEXCOORD0;
+				float2 uv1 : TEXCOORD1;
+				float2 uv2 : TEXCOORD2;
+				UNITY_VERTEX_INPUT_INSTANCE_ID
+			};
+
+			struct VertexOutput {
+				float4 vertex   : SV_POSITION;
+				half4 color    : COLOR;
+				half2 texcoord  : TEXCOORD0;
+				float4 darkColor : TEXCOORD1;
+				float4 worldPosition : TEXCOORD2;
+			#ifdef _CANVAS_GROUP_COMPATIBLE
+				float canvasAlpha : TEXCOORD3;
+			#endif
+				UNITY_VERTEX_OUTPUT_STEREO
+			};
+
+			half4 _Color;
+			half4 _Black;
+			half4 _TextureSampleAdd;
+			float4 _ClipRect;
+
+			VertexOutput vert (VertexInput IN) {
+				VertexOutput 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.darkColor = float4(IN.uv1.r, IN.uv1.g, IN.uv2.r, IN.uv2.g);
+				OUT.darkColor.rgb = GammaToTargetSpace(OUT.darkColor.rgb) + _Black.rgb;
+
+			#ifdef _CANVAS_GROUP_COMPATIBLE
+				// CanvasGroup alpha multiplies existing vertex color alpha, but
+				// does not premultiply it to rgb components. This causes problems
+				// with additive blending (alpha = 0), which is why we store the
+				// alpha value in uv2.g (darkColor.a).
+				float originalAlpha = OUT.darkColor.a;
+				OUT.canvasAlpha = (originalAlpha == 0) ? IN.color.a : IN.color.a / originalAlpha;
+			#else
+				float originalAlpha = IN.color.a;
+			#endif
+				// Note: CanvasRenderer performs a GammaToTargetSpace conversion on vertex color already,
+				// however incorrectly assuming straight alpha color.
+				float4 vertexColor = PMAGammaToTargetSpace(half4(TargetToGammaSpace(IN.color.rgb), originalAlpha));
+
+				OUT.color = vertexColor * float4(_Color.rgb * _Color.a, _Color.a);
+				return OUT;
+			}
+
+			sampler2D _MainTex;
+			#include "../CGIncludes/Spine-Skeleton-Tint-Common.cginc"
+
+			half4 frag(VertexOutput IN) : SV_Target
+			{
+				half4 texColor = (tex2D(_MainTex, IN.texcoord) + _TextureSampleAdd);
+				texColor *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect);
+				#ifdef UNITY_UI_ALPHACLIP
+				clip(texColor.a - 0.001);
+				#endif
+
+				float4 fragColor = fragTintedColor(texColor, IN.darkColor.rgb, IN.color, _Color.a, _Black.a);
+			#ifdef _CANVAS_GROUP_COMPATIBLE
+				fragColor.rgba *= IN.canvasAlpha;
+			#endif
+				return fragColor;
+			}
+		ENDCG
+		}
+	}
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/Spine-SkeletonGraphic-TintBlack.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: f64c7bc238bb2c246b8ca1912b2b6b9c
+timeCreated: 1455080068
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/Spine-SkeletonGraphic.shader

@@ -0,0 +1,77 @@
+// This is a premultiply-alpha adaptation of the built-in Unity shader "UI/Default" in Unity 5.6.2 to allow Unity UI stencil masking.
+
+Shader "Spine/SkeletonGraphic"
+{
+	Properties
+	{
+		[PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[Toggle(_CANVAS_GROUP_COMPATIBLE)] _CanvasGroupCompatible("CanvasGroup Compatible", Int) = 1
+		_Color ("Tint", Color) = (1,1,1,1)
+
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
+		[HideInInspector] _Stencil ("Stencil ID", Float) = 0
+		[HideInInspector][Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
+		[HideInInspector] _StencilWriteMask ("Stencil Write Mask", Float) = 255
+		[HideInInspector] _StencilReadMask ("Stencil Read Mask", Float) = 255
+
+		[HideInInspector] _ColorMask ("Color Mask", Float) = 15
+
+		[Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 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]
+		Fog { Mode Off }
+		Blend One OneMinusSrcAlpha
+		ColorMask [_ColorMask]
+
+		Pass
+		{
+			Name "Normal"
+
+		CGPROGRAM
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#pragma shader_feature _ _CANVAS_GROUP_COMPATIBLE
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma target 2.0
+
+			#include "CGIncludes/Spine-SkeletonGraphic-NormalPass.cginc"
+		ENDCG
+		}
+	}
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/SkeletonGraphic/Spine-SkeletonGraphic.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: fa95b0fb6983c0f40a152e6f9aa82bfb
+timeCreated: 1455080068
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Spine-Skeleton-Fill.shader

@@ -0,0 +1,128 @@
+// - Unlit
+// - Premultiplied Alpha Blending (Optional straight alpha input)
+// - Double-sided, no depth
+
+Shader "Spine/Skeleton Fill" {
+	Properties {
+		_FillColor ("FillColor", Color) = (1,1,1,1)
+		_FillPhase ("FillPhase", Range(0, 1)) = 0
+		[NoScaleOffset] _MainTex ("MainTex", 2D) = "white" {}
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" }
+		Blend One OneMinusSrcAlpha
+		Cull Off
+		ZWrite Off
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		Pass {
+			Name "Normal"
+
+			CGPROGRAM
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#pragma vertex vert
+			#pragma fragment frag
+			#include "UnityCG.cginc"
+			#include "CGIncludes/Spine-Common.cginc"
+			sampler2D _MainTex;
+			float4 _FillColor;
+			float _FillPhase;
+
+			struct VertexInput {
+				float4 vertex : POSITION;
+				float2 uv : TEXCOORD0;
+				float4 vertexColor : COLOR;
+			};
+
+			struct VertexOutput {
+				float4 pos : SV_POSITION;
+				float2 uv : TEXCOORD0;
+				float4 vertexColor : COLOR;
+			};
+
+			VertexOutput vert (VertexInput v) {
+				VertexOutput o = (VertexOutput)0;
+				o.uv = v.uv;
+				o.vertexColor = PMAGammaToTargetSpace(v.vertexColor);
+				o.pos = UnityObjectToClipPos(v.vertex);
+				return o;
+			}
+
+			float4 frag (VertexOutput i) : SV_Target {
+				float4 rawColor = tex2D(_MainTex,i.uv);
+				float finalAlpha = (rawColor.a * i.vertexColor.a);
+
+				#if defined(_STRAIGHT_ALPHA_INPUT)
+				rawColor.rgb *= rawColor.a;
+				#endif
+
+				float3 finalColor = lerp((rawColor.rgb * i.vertexColor.rgb), (_FillColor.rgb * finalAlpha), _FillPhase); // make sure to PMA _FillColor.
+				return fixed4(finalColor, finalAlpha);
+			}
+			ENDCG
+		}
+
+		Pass {
+			Name "Caster"
+			Tags { "LightMode"="ShadowCaster" }
+			Offset 1, 1
+			ZWrite On
+			ZTest LEqual
+
+			Fog { Mode Off }
+			Cull Off
+			Lighting Off
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma multi_compile_shadowcaster
+			#pragma fragmentoption ARB_precision_hint_fastest
+			#include "UnityCG.cginc"
+			sampler2D _MainTex;
+			fixed _Cutoff;
+
+			struct VertexOutput {
+				V2F_SHADOW_CASTER;
+				float4 uvAndAlpha : TEXCOORD1;
+			};
+
+			VertexOutput vert (appdata_base v, float4 vertexColor : COLOR) {
+				VertexOutput o;
+				o.uvAndAlpha = v.texcoord;
+				o.uvAndAlpha.a = vertexColor.a;
+				TRANSFER_SHADOW_CASTER(o)
+				return o;
+			}
+
+			float4 frag (VertexOutput i) : SV_Target {
+				fixed4 texcol = tex2D(_MainTex, i.uvAndAlpha.xy);
+				clip(texcol.a * i.uvAndAlpha.a - _Cutoff);
+				SHADOW_CASTER_FRAGMENT(i)
+			}
+			ENDCG
+		}
+	}
+	FallBack "Diffuse"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Spine-Skeleton-Fill.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 45495790b394f894a967dbf44489b57b
+timeCreated: 1492385797
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Spine-Skeleton-Lit-ZWrite.shader

@@ -0,0 +1,85 @@
+// - Vertex Lit + ShadowCaster
+// - Premultiplied Alpha Blending (Optional straight alpha input)
+// - Double-sided, ZWrite
+
+Shader "Spine/Skeleton Lit ZWrite" {
+	Properties {
+		_Cutoff ("Depth alpha cutoff", Range(0,1)) = 0.1
+		_ShadowAlphaCutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[NoScaleOffset] _MainTex ("Main Texture", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[Toggle(_DOUBLE_SIDED_LIGHTING)] _DoubleSidedLighting("Double-Sided Lighting", Int) = 0
+		[MaterialToggle(_LIGHT_AFFECTS_ADDITIVE)] _LightAffectsAdditive("Light Affects Additive", Float) = 0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		LOD 100
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		Pass {
+			Name "Normal"
+
+			Tags { "LightMode"="Vertex" "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
+
+			ZWrite On
+			Cull Off
+			Blend One OneMinusSrcAlpha
+
+			CGPROGRAM
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#pragma shader_feature _ _DOUBLE_SIDED_LIGHTING
+			#pragma shader_feature _ _LIGHT_AFFECTS_ADDITIVE
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma target 2.0
+
+			#define _ALPHA_CLIP
+			#pragma multi_compile __ POINT SPOT
+			#include "CGIncludes/Spine-Skeleton-Lit-Common.cginc"
+			ENDCG
+
+	 	}
+
+		Pass {
+			Name "Caster"
+			Tags { "LightMode"="ShadowCaster" }
+			Offset 1, 1
+
+			Fog { Mode Off }
+			ZWrite On
+			ZTest LEqual
+			Cull Off
+			Lighting Off
+
+			CGPROGRAM
+			#pragma vertex vertShadow
+			#pragma fragment fragShadow
+			#pragma multi_compile_shadowcaster
+			#pragma fragmentoption ARB_precision_hint_fastest
+
+			#define SHADOW_CUTOFF _ShadowAlphaCutoff
+			#include "CGIncludes/Spine-Skeleton-Lit-Common-Shadow.cginc"
+
+			ENDCG
+		}
+	}
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Spine-Skeleton-Lit-ZWrite.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: fde05abf1f7be4b4da1caf8c8de1823a
+timeCreated: 1564082883
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Spine-Skeleton-Lit.shader

@@ -0,0 +1,83 @@
+// - Vertex Lit + ShadowCaster
+// - Premultiplied Alpha Blending (Optional straight alpha input)
+// - Double-sided, no depth
+
+Shader "Spine/Skeleton Lit" {
+	Properties {
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[NoScaleOffset] _MainTex ("Main Texture", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[Toggle(_DOUBLE_SIDED_LIGHTING)] _DoubleSidedLighting("Double-Sided Lighting", Int) = 0
+		[MaterialToggle(_LIGHT_AFFECTS_ADDITIVE)] _LightAffectsAdditive("Light Affects Additive", Float) = 0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		LOD 100
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		Pass {
+			Name "Normal"
+
+			Tags { "LightMode"="Vertex" "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
+
+			ZWrite Off
+			Cull Off
+			Blend One OneMinusSrcAlpha
+
+			CGPROGRAM
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#pragma shader_feature _ _DOUBLE_SIDED_LIGHTING
+			#pragma shader_feature _ _LIGHT_AFFECTS_ADDITIVE
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma target 2.0
+
+			#pragma multi_compile __ POINT SPOT
+			#include "CGIncludes/Spine-Skeleton-Lit-Common.cginc"
+			ENDCG
+
+	 	}
+
+		Pass {
+			Name "Caster"
+			Tags { "LightMode"="ShadowCaster" }
+			Offset 1, 1
+
+			Fog { Mode Off }
+			ZWrite On
+			ZTest LEqual
+			Cull Off
+			Lighting Off
+
+			CGPROGRAM
+			#pragma vertex vertShadow
+			#pragma fragment fragShadow
+			#pragma multi_compile_shadowcaster
+			#pragma fragmentoption ARB_precision_hint_fastest
+
+			#define SHADOW_CUTOFF _Cutoff
+			#include "CGIncludes/Spine-Skeleton-Lit-Common-Shadow.cginc"
+
+			ENDCG
+		}
+	}
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Spine-Skeleton-Lit.shader.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: bd83c75f51f5e23498ae22ffcdfe92c3
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Spine-Skeleton-Tint.shader

@@ -0,0 +1,129 @@
+// Spine/Skeleton Tint
+// - Two color tint
+// - unlit
+// - Premultiplied alpha blending (Optional straight alpha input)
+// - No depth, no backface culling, no fog.
+
+Shader "Spine/Skeleton Tint" {
+	Properties {
+		_Color ("Tint Color", Color) = (1,1,1,1)
+		_Black ("Dark Color", Color) = (0,0,0,0)
+		[NoScaleOffset] _MainTex ("MainTex", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		_Cutoff("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[Toggle(_DARK_COLOR_ALPHA_ADDITIVE)] _DarkColorAlphaAdditive("Additive DarkColor.A", Int) = 0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" }
+
+		Fog { Mode Off }
+		Cull Off
+		ZWrite Off
+		Blend One OneMinusSrcAlpha
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		Pass {
+			Name "Normal"
+
+			CGPROGRAM
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#pragma shader_feature _ _DARK_COLOR_ALPHA_ADDITIVE
+			#pragma vertex vert
+			#pragma fragment frag
+			#include "UnityCG.cginc"
+			#include "CGIncludes/Spine-Common.cginc"
+			sampler2D _MainTex;
+			float4 _Color;
+			float4 _Black;
+
+			struct VertexInput {
+				float4 vertex : POSITION;
+				float2 uv : TEXCOORD0;
+				float4 vertexColor : COLOR;
+			};
+
+			struct VertexOutput {
+				float4 pos : SV_POSITION;
+				float2 uv : TEXCOORD0;
+				float4 vertexColor : COLOR;
+			};
+
+			VertexOutput vert (VertexInput v) {
+				VertexOutput o;
+				o.pos = UnityObjectToClipPos(v.vertex);
+				o.uv = v.uv;
+				o.vertexColor = PMAGammaToTargetSpace(v.vertexColor) * float4(_Color.rgb * _Color.a, _Color.a); // Combine a PMA version of _Color with vertexColor.
+				return o;
+			}
+
+			#include "CGIncludes/Spine-Skeleton-Tint-Common.cginc"
+
+			float4 frag (VertexOutput i) : SV_Target {
+				float4 texColor = tex2D(_MainTex, i.uv);
+				return fragTintedColor(texColor, _Black.rgb, i.vertexColor, _Color.a, _Black.a);
+			}
+			ENDCG
+		}
+
+		Pass {
+			Name "Caster"
+			Tags { "LightMode"="ShadowCaster" }
+			Offset 1, 1
+			ZWrite On
+			ZTest LEqual
+
+			Fog { Mode Off }
+			Cull Off
+			Lighting Off
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma multi_compile_shadowcaster
+			#pragma fragmentoption ARB_precision_hint_fastest
+			#include "UnityCG.cginc"
+			sampler2D _MainTex;
+			fixed _Cutoff;
+
+			struct VertexOutput {
+				V2F_SHADOW_CASTER;
+				float4 uvAndAlpha : TEXCOORD1;
+			};
+
+			VertexOutput vert (appdata_base v, float4 vertexColor : COLOR) {
+				VertexOutput o;
+				o.uvAndAlpha = v.texcoord;
+				o.uvAndAlpha.a = vertexColor.a;
+				TRANSFER_SHADOW_CASTER(o)
+				return o;
+			}
+
+			float4 frag (VertexOutput i) : SV_Target {
+				fixed4 texcol = tex2D(_MainTex, i.uvAndAlpha.xy);
+				clip(texcol.a * i.uvAndAlpha.a - _Cutoff);
+				SHADOW_CASTER_FRAGMENT(i)
+			}
+			ENDCG
+		}
+	}
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Spine-Skeleton-Tint.shader.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 522f03282fd79be47b306e2ef4b593fd
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Spine-Skeleton-TintBlack.shader

@@ -0,0 +1,133 @@
+// Spine/Skeleton Tint Black
+// - Two color tint
+// - UV2 and UV3 as Black Tint color.
+// - Final black tint is (UV black data and _Black/"Black Point")
+// - unlit
+// - Premultiplied alpha blending (optional straight alpha input)
+// - No depth, no backface culling, no fog.
+
+Shader "Spine/Skeleton Tint Black" {
+	Properties {
+		_Color ("Tint Color", Color) = (1,1,1,1)
+		_Black ("Dark Color", Color) = (0,0,0,0)
+		[NoScaleOffset] _MainTex ("MainTex", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[Toggle(_DARK_COLOR_ALPHA_ADDITIVE)] _DarkColorAlphaAdditive("Additive DarkColor.A", Int) = 0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		LOD 100
+
+		Fog { Mode Off }
+		Cull Off
+		ZWrite Off
+		Blend One OneMinusSrcAlpha
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		Pass {
+			Name "Normal"
+
+			CGPROGRAM
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#pragma shader_feature _ _DARK_COLOR_ALPHA_ADDITIVE
+			#pragma vertex vert
+			#pragma fragment frag
+			#include "UnityCG.cginc"
+			#include "CGIncludes/Spine-Common.cginc"
+			sampler2D _MainTex;
+			float4 _Color;
+			float4 _Black;
+
+			struct VertexInput {
+				float4 vertex : POSITION;
+				float2 uv : TEXCOORD0;
+				float2 uv1 : TEXCOORD1;
+				float2 uv2 : TEXCOORD2;
+				float4 vertexColor : COLOR;
+			};
+
+			struct VertexOutput {
+				float4 pos : SV_POSITION;
+				float2 uv : TEXCOORD0;
+				float3 darkColor : TEXCOORD1;
+				float4 vertexColor : COLOR;
+			};
+
+			VertexOutput vert (VertexInput v) {
+				VertexOutput o;
+				o.pos = UnityObjectToClipPos(v.vertex); // Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
+				o.uv = v.uv;
+				o.vertexColor = PMAGammaToTargetSpace(v.vertexColor) * float4(_Color.rgb * _Color.a, _Color.a); // Combine a PMA version of _Color with vertexColor.
+				o.darkColor = GammaToTargetSpace(float3(v.uv1.r, v.uv1.g, v.uv2.r)) + _Black.rgb;
+				return o;
+			}
+
+			#include "CGIncludes/Spine-Skeleton-Tint-Common.cginc"
+
+			float4 frag (VertexOutput i) : SV_Target {
+				float4 texColor = tex2D(_MainTex, i.uv);
+				return fragTintedColor(texColor, i.darkColor, i.vertexColor, _Color.a, _Black.a);
+			}
+			ENDCG
+		}
+
+		Pass {
+			Name "Caster"
+			Tags { "LightMode"="ShadowCaster" }
+			Offset 1, 1
+
+			ZWrite On
+			ZTest LEqual
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma multi_compile_shadowcaster
+			#pragma fragmentoption ARB_precision_hint_fastest
+			#include "UnityCG.cginc"
+			sampler2D _MainTex;
+			fixed _Cutoff;
+
+			struct v2f {
+				V2F_SHADOW_CASTER;
+				float4 uvAndAlpha : TEXCOORD1;
+			};
+
+			v2f vert (appdata_base v, float4 vertexColor : COLOR) {
+				v2f o;
+				TRANSFER_SHADOW_CASTER(o)
+				o.uvAndAlpha = v.texcoord;
+				o.uvAndAlpha.a = vertexColor.a;
+				return o;
+			}
+
+			float4 frag (v2f i) : SV_Target {
+				fixed4 texcol = tex2D(_MainTex, i.uvAndAlpha.xy);
+				clip(texcol.a * i.uvAndAlpha.a - _Cutoff);
+				SHADOW_CASTER_FRAGMENT(i)
+			}
+			ENDCG
+		}
+	}
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Spine-Skeleton-TintBlack.shader.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: deee23ab4aa38564ead2ac05e112c169
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Spine-Skeleton.shader

@@ -0,0 +1,120 @@
+Shader "Spine/Skeleton" {
+	Properties {
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[NoScaleOffset] _MainTex ("Main Texture", 2D) = "black" {}
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" }
+
+		Fog { Mode Off }
+		Cull Off
+		ZWrite Off
+		Blend One OneMinusSrcAlpha
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		Pass {
+			Name "Normal"
+
+			CGPROGRAM
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#pragma vertex vert
+			#pragma fragment frag
+			#include "UnityCG.cginc"
+			#include "CGIncludes/Spine-Common.cginc"
+			sampler2D _MainTex;
+
+			struct VertexInput {
+				float4 vertex : POSITION;
+				float2 uv : TEXCOORD0;
+				float4 vertexColor : COLOR;
+			};
+
+			struct VertexOutput {
+				float4 pos : SV_POSITION;
+				float2 uv : TEXCOORD0;
+				float4 vertexColor : COLOR;
+			};
+
+			VertexOutput vert (VertexInput v) {
+				VertexOutput o;
+				o.pos = UnityObjectToClipPos(v.vertex);
+				o.uv = v.uv;
+				o.vertexColor = PMAGammaToTargetSpace(v.vertexColor);
+				return o;
+			}
+
+			float4 frag (VertexOutput i) : SV_Target {
+				float4 texColor = tex2D(_MainTex, i.uv);
+
+				#if defined(_STRAIGHT_ALPHA_INPUT)
+				texColor.rgb *= texColor.a;
+				#endif
+
+				return (texColor * i.vertexColor);
+			}
+			ENDCG
+		}
+
+		Pass {
+			Name "Caster"
+			Tags { "LightMode"="ShadowCaster" }
+			Offset 1, 1
+			ZWrite On
+			ZTest LEqual
+
+			Fog { Mode Off }
+			Cull Off
+			Lighting Off
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma multi_compile_shadowcaster
+			#pragma fragmentoption ARB_precision_hint_fastest
+			#include "UnityCG.cginc"
+			sampler2D _MainTex;
+			fixed _Cutoff;
+
+			struct VertexOutput {
+				V2F_SHADOW_CASTER;
+				float4 uvAndAlpha : TEXCOORD1;
+			};
+
+			VertexOutput vert (appdata_base v, float4 vertexColor : COLOR) {
+				VertexOutput o;
+				o.uvAndAlpha = v.texcoord;
+				o.uvAndAlpha.a = vertexColor.a;
+				TRANSFER_SHADOW_CASTER(o)
+				return o;
+			}
+
+			float4 frag (VertexOutput i) : SV_Target {
+				fixed4 texcol = tex2D(_MainTex, i.uvAndAlpha.xy);
+				clip(texcol.a * i.uvAndAlpha.a - _Cutoff);
+				SHADOW_CASTER_FRAGMENT(i)
+			}
+			ENDCG
+		}
+	}
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Spine-Skeleton.shader.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 1e8a610c9e01c3648bac42585e5fc676
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Spine-Special-Skeleton-Grayscale.shader

@@ -0,0 +1,128 @@
+// - Unlit
+// - Premultiplied Alpha Blending (Optional straight alpha input)
+// - Double-sided, no depth
+
+Shader "Spine/Special/Skeleton Grayscale" {
+	Properties {
+		_GrayPhase ("Phase", Range(0, 1)) = 1
+		[NoScaleOffset] _MainTex ("MainTex", 2D) = "white" {}
+		_Cutoff ("Shadow alpha cutoff", Range(0,1)) = 0.1
+		[Toggle(_STRAIGHT_ALPHA_INPUT)] _StraightAlphaInput("Straight Alpha Texture", Int) = 0
+		[HideInInspector] _StencilRef("Stencil Reference", Float) = 1.0
+		[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil Comparison", Float) = 8 // Set to Always as default
+
+		// Outline properties are drawn via custom editor.
+		[HideInInspector] _OutlineWidth("Outline Width", Range(0,8)) = 3.0
+		[HideInInspector] _OutlineColor("Outline Color", Color) = (1,1,0,1)
+		[HideInInspector] _OutlineReferenceTexWidth("Reference Texture Width", Int) = 1024
+		[HideInInspector] _ThresholdEnd("Outline Threshold", Range(0,1)) = 0.25
+		[HideInInspector] _OutlineSmoothness("Outline Smoothness", Range(0,1)) = 1.0
+		[HideInInspector][MaterialToggle(_USE8NEIGHBOURHOOD_ON)] _Use8Neighbourhood("Sample 8 Neighbours", Float) = 1
+		[HideInInspector] _OutlineOpaqueAlpha("Opaque Alpha", Range(0,1)) = 1.0
+		[HideInInspector] _OutlineMipLevel("Outline Mip Level", Range(0,3)) = 0
+	}
+
+	SubShader {
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" }
+		Blend One OneMinusSrcAlpha
+		Cull Off
+		ZWrite Off
+		Lighting Off
+
+		Stencil {
+			Ref[_StencilRef]
+			Comp[_StencilComp]
+			Pass Keep
+		}
+
+		Pass {
+			Name "Normal"
+
+			CGPROGRAM
+			#pragma shader_feature _ _STRAIGHT_ALPHA_INPUT
+			#pragma vertex vert
+			#pragma fragment frag
+			#include "UnityCG.cginc"
+			#include "CGIncludes/Spine-Common.cginc"
+			sampler2D _MainTex;
+			float _GrayPhase;
+
+			struct VertexInput {
+				float4 vertex : POSITION;
+				float2 uv : TEXCOORD0;
+				float4 vertexColor : COLOR;
+			};
+
+			struct VertexOutput {
+				float4 pos : SV_POSITION;
+				float2 uv : TEXCOORD0;
+				float4 vertexColor : COLOR;
+			};
+
+			VertexOutput vert (VertexInput v) {
+				VertexOutput o = (VertexOutput)0;
+				o.uv = v.uv;
+				o.vertexColor = PMAGammaToTargetSpace(v.vertexColor);
+				o.pos = UnityObjectToClipPos(v.vertex);
+				return o;
+			}
+
+			float4 frag (VertexOutput i) : SV_Target {
+				float4 rawColor = tex2D(_MainTex,i.uv);
+			#if defined(_STRAIGHT_ALPHA_INPUT)
+				rawColor.rgb *= rawColor.a;
+			#endif
+				float finalAlpha = (rawColor.a * i.vertexColor.a);
+
+				rawColor.rgb *= i.vertexColor.rgb;
+
+				float3 finalColor = lerp(rawColor.rgb, dot(rawColor.rgb, float3(0.3, 0.59, 0.11)), _GrayPhase);
+				return fixed4(finalColor, finalAlpha);
+			}
+			ENDCG
+		}
+
+		Pass {
+			Name "Caster"
+			Tags { "LightMode"="ShadowCaster" }
+			Offset 1, 1
+			ZWrite On
+			ZTest LEqual
+
+			Fog { Mode Off }
+			Cull Off
+			Lighting Off
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma multi_compile_shadowcaster
+			#pragma fragmentoption ARB_precision_hint_fastest
+			#include "UnityCG.cginc"
+			sampler2D _MainTex;
+			fixed _Cutoff;
+
+			struct VertexOutput {
+				V2F_SHADOW_CASTER;
+				float4 uvAndAlpha : TEXCOORD1;
+			};
+
+			VertexOutput vert (appdata_base v, float4 vertexColor : COLOR) {
+				VertexOutput o;
+				o.uvAndAlpha = v.texcoord;
+				o.uvAndAlpha.a = vertexColor.a;
+				TRANSFER_SHADOW_CASTER(o)
+				return o;
+			}
+
+			float4 frag (VertexOutput i) : SV_Target {
+				fixed4 texcol = tex2D(_MainTex, i.uvAndAlpha.xy);
+				clip(texcol.a * i.uvAndAlpha.a - _Cutoff);
+				SHADOW_CASTER_FRAGMENT(i)
+			}
+			ENDCG
+		}
+	}
+	FallBack "Diffuse"
+	CustomEditor "SpineShaderWithOutlineGUI"
+}

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Spine-Special-Skeleton-Grayscale.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: ea7e7c05f36541b4bb280f98ebda8ba1
+timeCreated: 1492385797
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Sprite.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a831a8ed72a588a48b2fb892e7f37371
+folderAsset: yes
+timeCreated: 1479419399
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Sprite/CGIncludes.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 4b6fb48f295cd8248a7566315212a3c2
+folderAsset: yes
+timeCreated: 1494092464
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Sprite/CGIncludes/ShaderMaths.cginc

@@ -0,0 +1,76 @@
+#ifndef SHADER_MATHS_INCLUDED
+#define SHADER_MATHS_INCLUDED
+
+#if defined(USE_LWRP)
+#include "Packages/com.unity.render-pipelines.lightweight/ShaderLibrary/Core.hlsl"
+#elif defined(USE_URP)
+#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+#else
+#include "UnityCG.cginc"
+#endif
+
+////////////////////////////////////////
+// Maths functions
+//
+
+inline half3 safeNormalize(half3 inVec)
+{
+	half dp3 = max(0.001f, dot(inVec, inVec));
+	return inVec * rsqrt(dp3);
+}
+
+inline float dotClamped(float3 a, float3 b)
+{
+	#if (SHADER_TARGET < 30 || defined(SHADER_API_PS3))
+		return saturate(dot(a, b));
+	#else
+		return max(0.0h, dot(a, b));
+	#endif
+}
+
+inline float oneDividedBy(float value)
+{
+	//Catches NANs
+	float sign_value = sign(value);
+	float sign_value_squared = sign_value*sign_value;
+	return sign_value_squared / ( value + sign_value_squared - 1.0);
+}
+
+inline half pow5 (half x)
+{
+	return x*x*x*x*x;
+}
+
+inline float4 quat_from_axis_angle(float3 axis, float angleRadians)
+{
+  float4 qr;
+  float half_angle = (angleRadians * 0.5);
+  qr.x = axis.x * sin(half_angle);
+  qr.y = axis.y * sin(half_angle);
+  qr.z = axis.z * sin(half_angle);
+  qr.w = cos(half_angle);
+  return qr;
+}
+
+inline float3 rotate_vertex_position(float3 position, float3 axis, float angleRadians)
+{
+  float4 q = quat_from_axis_angle(axis, angleRadians);
+  float3 v = position.xyz;
+  return v + 2.0 * cross(q.xyz, cross(q.xyz, v) + q.w * v);
+}
+
+float3 EncodeFloatRGB(float value)
+{
+   const float max24int = 256*256*256-1;
+   float3 decomp = floor( value * float3( max24int/(256*256), max24int/256, max24int ) ) / 255.0;
+   decomp.z -= decomp.y * 256.0;
+   decomp.y -= decomp.x * 256.0;
+   return decomp;
+}
+
+float DecodeFloatRGB(float3 decomp)
+{
+   return dot( decomp.xyz, float3( 255.0/256, 255.0/(256*256), 255.0/(256*256*256) ) );
+}
+
+#endif // SHADER_MATHS_INCLUDED

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Sprite/CGIncludes/ShaderMaths.cginc.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: e1de23de2025abe4a84ff2edd3f24491
+timeCreated: 1494092582
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Sprite/CGIncludes/ShaderShared.cginc

@@ -0,0 +1,472 @@
+// Upgrade NOTE: upgraded instancing buffer 'PerDrawSprite' to new syntax.
+
+#ifndef SHADER_SHARED_INCLUDED
+#define SHADER_SHARED_INCLUDED
+
+#if defined(USE_LWRP)
+#include "Packages/com.unity.render-pipelines.lightweight/ShaderLibrary/Core.hlsl"
+#include "Packages/com.esotericsoftware.spine.lwrp-shaders/Shaders/CGIncludes/SpineCoreShaders/Spine-Common.cginc"
+#elif defined(USE_URP)
+#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+#include "Packages/com.esotericsoftware.spine.urp-shaders/Shaders/Include/SpineCoreShaders/Spine-Common.cginc"
+#else
+#include "UnityCG.cginc"
+#include "../../CGIncludes/Spine-Common.cginc"
+#endif
+
+////////////////////////////////////////
+// Space functions
+//
+
+inline float4 calculateWorldPos(float4 vertex)
+{
+	return mul(unity_ObjectToWorld, vertex);
+}
+
+#if defined(USE_LWRP) || defined(USE_URP)
+// snaps post-transformed position to screen pixels
+inline float4 UnityPixelSnap(float4 pos)
+{
+	float2 hpc = _ScreenParams.xy * 0.5f;
+#if  SHADER_API_PSSL
+	// sdk 4.5 splits round into v_floor_f32(x+0.5) ... sdk 5.0 uses v_rndne_f32, for compatabilty we use the 4.5 version
+	float2 temp = ((pos.xy / pos.w) * hpc) + float2(0.5f, 0.5f);
+	float2 pixelPos = float2(__v_floor_f32(temp.x), __v_floor_f32(temp.y));
+#else
+	float2 pixelPos = round((pos.xy / pos.w) * hpc);
+#endif
+	pos.xy = pixelPos / hpc * pos.w;
+	return pos;
+}
+#endif
+
+inline float4 calculateLocalPos(float4 vertex)
+{
+#if !defined(USE_LWRP) && !defined(USE_URP)
+#ifdef UNITY_INSTANCING_ENABLED
+    vertex.xy *= _Flip.xy;
+#endif
+#endif
+
+#if defined(USE_LWRP) || defined(USE_URP)
+	float4 pos = TransformObjectToHClip(vertex.xyz);
+#else
+	float4 pos = UnityObjectToClipPos(vertex);
+#endif
+
+#ifdef PIXELSNAP_ON
+	pos = UnityPixelSnap(pos);
+#endif
+
+	return pos;
+}
+
+inline half3 calculateWorldNormal(float3 normal)
+{
+#if defined(USE_LWRP) || defined(USE_URP)
+	return TransformObjectToWorldNormal(normal);
+#else
+	return UnityObjectToWorldNormal(normal);
+#endif
+}
+
+////////////////////////////////////////
+// Normal map functions
+//
+
+#if defined(_NORMALMAP)
+
+uniform sampler2D _BumpMap;
+
+#if !defined(USE_LWRP) && !defined(USE_URP)
+uniform half _BumpScale;
+#endif
+
+half3 UnpackScaleNormal(half4 packednormal, half bumpScale)
+{
+	#if defined(UNITY_NO_DXT5nm)
+		return packednormal.xyz * 2 - 1;
+	#else
+		half3 normal;
+		normal.xy = (packednormal.wy * 2 - 1);
+		// Note: we allow scaled normals in LWRP since we might be using fewer instructions.
+		#if (SHADER_TARGET >= 30) || defined(USE_LWRP) || defined(USE_URP)
+			// SM2.0: instruction count limitation
+			// SM2.0: normal scaler is not supported
+			normal.xy *= bumpScale;
+		#endif
+		normal.z = sqrt(1.0 - saturate(dot(normal.xy, normal.xy)));
+		return normal;
+	#endif
+}
+
+
+inline half3 calculateWorldTangent(float4 tangent)
+{
+#if defined(USE_LWRP) || defined(USE_URP)
+	return TransformObjectToWorldDir(tangent.xyz);
+#else
+	return UnityObjectToWorldDir(tangent);
+#endif
+}
+
+inline half3 calculateWorldBinormal(half3 normalWorld, half3 tangentWorld, float tangentSign)
+{
+	//When calculating the binormal we have to flip it when the mesh is scaled negatively.
+	//Normally this would just be unity_WorldTransformParams.w but this isn't set correctly by Unity for its SpriteRenderer meshes so get from objectToWorld matrix scale instead.
+	half worldTransformSign = sign(unity_ObjectToWorld[0][0] * unity_ObjectToWorld[1][1] * unity_ObjectToWorld[2][2]);
+	half sign = tangentSign * worldTransformSign;
+	return cross(normalWorld, tangentWorld) * sign;
+}
+
+inline half3 calculateNormalFromBumpMap(float2 texUV, half3 tangentWorld, half3 binormalWorld, half3 normalWorld)
+{
+	half3 localNormal = UnpackScaleNormal(tex2D(_BumpMap, texUV), _BumpScale);
+	half3x3 rotation = half3x3(tangentWorld, binormalWorld, normalWorld);
+	half3 normal = normalize(mul(localNormal, rotation));
+	return normal;
+}
+
+#endif // _NORMALMAP
+
+////////////////////////////////////////
+// Blending functions
+//
+inline fixed4 prepareLitPixelForOutput(fixed4 finalPixel, fixed textureAlpha, fixed colorAlpha) : SV_Target
+{
+#if defined(_TINT_BLACK_ON)
+	const bool applyPMA = false;
+#else
+	const bool applyPMA = true;
+#endif
+
+#if defined(_ALPHABLEND_ON)
+	//Normal Alpha
+	if (applyPMA) finalPixel.rgb *= finalPixel.a;
+#elif defined(_ALPHAPREMULTIPLY_VERTEX_ONLY)
+	//PMA vertex, straight texture
+	if (applyPMA) finalPixel.rgb *= textureAlpha;
+#elif defined(_ALPHAPREMULTIPLY_ON)
+	//Pre multiplied alpha, both vertex and texture
+	// texture and vertex colors are premultiplied already
+#elif defined(_MULTIPLYBLEND)
+	//Multiply
+	finalPixel = lerp(fixed4(1,1,1,1), finalPixel, finalPixel.a);
+#elif defined(_MULTIPLYBLEND_X2)
+	//Multiply x2
+	finalPixel.rgb *= 2.0f;
+	finalPixel = lerp(fixed4(0.5f,0.5f,0.5f,0.5f), finalPixel, finalPixel.a);
+#elif defined(_ADDITIVEBLEND)
+	//Additive
+	finalPixel *= 2.0f;
+	if (applyPMA) finalPixel.rgb *= colorAlpha;
+#elif defined(_ADDITIVEBLEND_SOFT)
+	//Additive soft
+	if (applyPMA) finalPixel.rgb *= finalPixel.a;
+#else
+	//Opaque
+	finalPixel.a = 1;
+#endif
+	return finalPixel;
+}
+
+inline fixed4 calculateLitPixel(fixed4 texureColor, fixed4 color, fixed3 lighting) : SV_Target
+{
+#if !defined(_TINT_BLACK_ON)
+	fixed4 finalPixel = texureColor * color * fixed4(lighting, 1);
+#else
+	fixed4 finalPixel = texureColor * fixed4(lighting, 1);
+#endif
+	finalPixel = prepareLitPixelForOutput(finalPixel, texureColor.a, color.a);
+	return finalPixel;
+}
+
+inline fixed4 calculateLitPixel(fixed4 texureColor, fixed3 lighting) : SV_Target
+{
+	// note: we let the optimizer work, removed duplicate code.
+	return calculateLitPixel(texureColor, fixed4(1, 1, 1, 1), lighting);
+}
+
+inline fixed4 calculateAdditiveLitPixel(fixed4 texureColor, fixed4 color, fixed3 lighting) : SV_Target
+{
+	fixed4 finalPixel;
+
+#if defined(_ALPHABLEND_ON)	|| defined(_MULTIPLYBLEND)	|| defined(_MULTIPLYBLEND_X2) || defined(_ADDITIVEBLEND) || defined(_ADDITIVEBLEND_SOFT)
+	//Normal Alpha, Additive and Multiply modes
+	finalPixel.rgb = (texureColor.rgb * lighting * color.rgb) * (texureColor.a * color.a);
+	finalPixel.a = 1.0;
+#elif defined(_ALPHAPREMULTIPLY_VERTEX_ONLY)
+	//PMA vertex, straight texture
+	finalPixel.rgb = texureColor.rgb * lighting * color.rgb * texureColor.a;
+	finalPixel.a = 1.0;
+#elif defined(_ALPHAPREMULTIPLY_ON)
+	//Pre multiplied alpha, both vertex and texture
+	finalPixel.rgb = texureColor.rgb * lighting * color.rgb;
+	finalPixel.a = 1.0;
+#else
+	//Opaque
+	finalPixel.rgb = texureColor.rgb * lighting * color.rgb;
+	finalPixel.a = 1.0;
+#endif
+
+	return finalPixel;
+}
+
+inline fixed4 calculateAdditiveLitPixel(fixed4 texureColor, fixed3 lighting) : SV_Target
+{
+	fixed4 finalPixel;
+
+#if defined(_ALPHABLEND_ON)	|| defined(_ALPHAPREMULTIPLY_VERTEX_ONLY) || defined(_MULTIPLYBLEND) || defined(_MULTIPLYBLEND_X2) || defined(_ADDITIVEBLEND) || defined(_ADDITIVEBLEND_SOFT)
+	//Normal Alpha, Additive and Multiply modes
+	finalPixel.rgb = (texureColor.rgb * lighting) * texureColor.a;
+	finalPixel.a = 1.0;
+#else
+	//Pre multiplied alpha and Opaque
+	finalPixel.rgb = texureColor.rgb * lighting;
+	finalPixel.a = 1.0;
+#endif
+
+	return finalPixel;
+}
+
+inline fixed4 calculatePixel(fixed4 texureColor, fixed4 color) : SV_Target
+{
+	// note: we let the optimizer work, removed duplicate code.
+	return calculateLitPixel(texureColor, color, fixed3(1, 1, 1));
+}
+
+inline fixed4 calculatePixel(fixed4 texureColor) : SV_Target
+{
+	// note: we let the optimizer work, removed duplicate code.
+	return calculateLitPixel(texureColor, fixed4(1, 1, 1, 1), fixed3(1, 1, 1));
+}
+
+////////////////////////////////////////
+// Alpha Clipping
+//
+
+#if defined(_ALPHA_CLIP)
+
+#if !defined(USE_LWRP) && !defined(USE_URP)
+uniform fixed _Cutoff;
+#endif
+
+#define ALPHA_CLIP(pixel, color) clip((pixel.a * color.a) - _Cutoff);
+
+#else
+
+#define ALPHA_CLIP(pixel, color)
+
+#endif
+
+////////////////////////////////////////
+// Additive Slot blend mode
+// return unlit textureColor, alpha clip textureColor.a only
+//
+// [Deprecated] RETURN_UNLIT_IF_ADDITIVE_SLOT macro will be removed in future versions.
+// Use RETURN_UNLIT_IF_ADDITIVE_SLOT_TINT instead.
+#if defined(_ALPHAPREMULTIPLY_ON) && !defined(_LIGHT_AFFECTS_ADDITIVE)
+	#define RETURN_UNLIT_IF_ADDITIVE_SLOT(textureColor, vertexColor) \
+	if (vertexColor.a == 0 && (vertexColor.r || vertexColor.g || vertexColor.b)) {\
+		ALPHA_CLIP(texureColor, fixed4(1, 1, 1, 1))\
+		return texureColor * vertexColor;\
+	}
+#elif defined(_ALPHAPREMULTIPLY_VERTEX_ONLY) && !defined(_LIGHT_AFFECTS_ADDITIVE)
+	#define RETURN_UNLIT_IF_ADDITIVE_SLOT(textureColor, vertexColor) \
+	if (vertexColor.a == 0 && (vertexColor.r || vertexColor.g || vertexColor.b)) {\
+		ALPHA_CLIP(texureColor, fixed4(1, 1, 1, 1))\
+		return texureColor * texureColor.a * vertexColor;\
+	}
+#else
+	#define RETURN_UNLIT_IF_ADDITIVE_SLOT(textureColor, vertexColor)
+#endif
+
+// Replacement for deprecated RETURN_UNLIT_IF_ADDITIVE_SLOT macro.
+#if (defined(_ALPHAPREMULTIPLY_ON) || defined(_ALPHAPREMULTIPLY_VERTEX_ONLY)) && !defined(_LIGHT_AFFECTS_ADDITIVE)
+	#if defined(_TINT_BLACK_ON)
+		#define TINTED_RESULT_PIXEL(textureColor, vertexColor, darkVertexColor, lightColorA, darkColorA) fragTintedColor(texureColor, darkVertexColor, vertexColor, lightColorA, darkColorA)
+	#elif defined(_ALPHAPREMULTIPLY_VERTEX_ONLY)
+		#define TINTED_RESULT_PIXEL(textureColor, vertexColor, darkVertexColor, lightColorA, darkColorA) (texureColor * texureColor.a * vertexColor)
+	#else
+		#define TINTED_RESULT_PIXEL(textureColor, vertexColor, darkVertexColor, lightColorA, darkColorA) (texureColor * vertexColor)
+	#endif
+
+	#define RETURN_UNLIT_IF_ADDITIVE_SLOT_TINT(textureColor, vertexColor, darkVertexColor, lightColorA, darkColorA) \
+	if (vertexColor.a == 0 && (vertexColor.r || vertexColor.g || vertexColor.b)) {\
+		ALPHA_CLIP(texureColor, fixed4(1, 1, 1, 1))\
+		return TINTED_RESULT_PIXEL(textureColor, vertexColor, darkVertexColor, lightColorA, darkColorA);\
+	}
+#else
+	#define RETURN_UNLIT_IF_ADDITIVE_SLOT_TINT(textureColor, vertexColor, darkVertexColor, lightColorA, darkColorA)
+#endif
+
+////////////////////////////////////////
+// Color functions
+//
+
+#if !defined(USE_LWRP) && !defined(USE_URP)
+uniform fixed4 _Color;
+	#if defined(_TINT_BLACK_ON)
+	uniform fixed4 _Black;
+	#endif
+#endif
+
+inline fixed4 calculateVertexColor(fixed4 color)
+{
+#if defined(_ALPHAPREMULTIPLY_ON) || _ALPHAPREMULTIPLY_VERTEX_ONLY
+	return PMAGammaToTargetSpace(color) * _Color;
+#elif !defined (UNITY_COLORSPACE_GAMMA)
+	return fixed4(GammaToLinearSpace(color.rgb), color.a) * _Color;
+#else
+	return color * _Color;
+#endif
+}
+
+#if defined(_COLOR_ADJUST)
+
+#if !defined(USE_LWRP) && !defined(USE_URP)
+uniform float _Hue;
+uniform float _Saturation;
+uniform float _Brightness;
+uniform fixed4 _OverlayColor;
+#endif
+
+float3 rgb2hsv(float3 c)
+{
+  float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+  float4 p = lerp(float4(c.bg, K.wz), float4(c.gb, K.xy), step(c.b, c.g));
+  float4 q = lerp(float4(p.xyw, c.r), float4(c.r, p.yzx), step(p.x, c.r));
+
+  float d = q.x - min(q.w, q.y);
+  float e = 1.0e-10;
+  return float3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+
+float3 hsv2rgb(float3 c)
+{
+  c = float3(c.x, clamp(c.yz, 0.0, 1.0));
+  float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+  float3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
+  return c.z * lerp(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+inline fixed4 adjustColor(fixed4 color)
+{
+	float3 hsv = rgb2hsv(color.rgb);
+
+	hsv.x += _Hue;
+	hsv.y *= _Saturation;
+	hsv.z *= _Brightness;
+
+	color.rgb = hsv2rgb(hsv);
+
+	return color;
+}
+
+#define COLORISE(pixel) pixel.rgb = lerp(pixel.rgb, _OverlayColor.rgb, _OverlayColor.a * pixel.a);
+#define COLORISE_ADDITIVE(pixel) pixel.rgb = ((1.0-_OverlayColor.a) * pixel.rgb);
+
+#else  // !_COLOR_ADJUST
+
+#define COLORISE(pixel)
+#define COLORISE_ADDITIVE(pixel)
+
+#endif // !_COLOR_ADJUST
+
+////////////////////////////////////////
+// Fog
+//
+
+#if defined(_FOG) && (defined(FOG_LINEAR) || defined(FOG_EXP) || defined(FOG_EXP2))
+
+inline fixed4 applyFog(fixed4 pixel, float fogCoordOrFactorAtLWRP)
+{
+#if defined(_ADDITIVEBLEND) || defined(_ADDITIVEBLEND_SOFT)
+	//In additive mode blend from clear to black based on luminance
+	float luminance = pixel.r * 0.3 + pixel.g * 0.59 + pixel.b * 0.11;
+	fixed4 fogColor = lerp(fixed4(0,0,0,0), fixed4(0,0,0,1), luminance);
+#elif defined(_MULTIPLYBLEND)
+	//In multiplied mode fade to white based on inverse luminance
+	float luminance = pixel.r * 0.3 + pixel.g * 0.59 + pixel.b * 0.11;
+	fixed4 fogColor = lerp(fixed4(1,1,1,1), fixed4(0,0,0,0), luminance);
+#elif defined(_MULTIPLYBLEND_X2)
+	//In multipliedx2 mode fade to grey based on inverse luminance
+	float luminance = pixel.r * 0.3 + pixel.g * 0.59 + pixel.b * 0.11;
+	fixed4 fogColor = lerp(fixed4(0.5f,0.5f,0.5f,0.5f), fixed4(0,0,0,0), luminance);
+#elif defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_VERTEX_ONLY) || defined(_ALPHAPREMULTIPLY_ON)
+	//In alpha blended modes blend to fog color based on pixel alpha
+	fixed4 fogColor = lerp(fixed4(0,0,0,0), unity_FogColor, pixel.a);
+#else
+	//In opaque mode just return fog color;
+	fixed4 fogColor = unity_FogColor;
+#endif
+
+	#if defined(USE_LWRP) || defined(USE_URP)
+	pixel.rgb = MixFogColor(pixel.rgb, fogColor.rgb, fogCoordOrFactorAtLWRP);
+	#else
+	UNITY_APPLY_FOG_COLOR(fogCoordOrFactorAtLWRP, pixel, fogColor);
+	#endif
+
+	return pixel;
+}
+
+#define APPLY_FOG(pixel, input) pixel = applyFog(pixel, input.fogCoord);
+#define APPLY_FOG_LWRP(pixel, fogFactor) pixel = applyFog(pixel, fogFactor);
+
+#define APPLY_FOG_ADDITIVE(pixel, input) \
+	UNITY_APPLY_FOG_COLOR(input.fogCoord, pixel.rgb, fixed4(0,0,0,0)); // fog towards black in additive pass
+
+#else
+
+#define APPLY_FOG(pixel, input)
+#define APPLY_FOG_LWRP(pixel, fogFactor)
+#define APPLY_FOG_ADDITIVE(pixel, input)
+
+#endif
+
+////////////////////////////////////////
+// Texture functions
+//
+
+uniform sampler2D _MainTex;
+
+#if _TEXTURE_BLEND
+uniform sampler2D _BlendTex;
+#if !defined(USE_LWRP) && !defined(USE_URP)
+uniform float _BlendAmount;
+#endif
+
+inline fixed4 calculateBlendedTexturePixel(float2 texcoord)
+{
+	return (1.0-_BlendAmount) * tex2D(_MainTex, texcoord) + _BlendAmount * tex2D(_BlendTex, texcoord);
+}
+#endif // _TEXTURE_BLEND
+
+inline fixed4 calculateTexturePixel(float2 texcoord)
+{
+	fixed4 pixel;
+
+#if _TEXTURE_BLEND
+	pixel = calculateBlendedTexturePixel(texcoord);
+#else
+	pixel = tex2D(_MainTex, texcoord);
+#endif // !_TEXTURE_BLEND
+
+#if defined(_COLOR_ADJUST)
+	pixel = adjustColor(pixel);
+#endif // _COLOR_ADJUST
+
+	return pixel;
+}
+
+#if !defined(USE_LWRP) && !defined(USE_URP)
+uniform fixed4 _MainTex_ST;
+#endif
+
+inline float2 calculateTextureCoord(float4 texcoord)
+{
+	return TRANSFORM_TEX(texcoord, _MainTex);
+}
+
+
+#endif // SHADER_SHARED_INCLUDED

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Sprite/CGIncludes/ShaderShared.cginc.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: c18c5cab567666f4d8c5b2bd4e61390b
+timeCreated: 1494092582
+licenseType: Free
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/spine-4.1/Spine/Runtime/spine-unity/Shaders/Sprite/CGIncludes/SpriteLighting.cginc

@@ -0,0 +1,230 @@
+#ifndef SPRITE_LIGHTING_INCLUDED
+#define SPRITE_LIGHTING_INCLUDED
+
+//Check for using mesh normals
+#if !defined(_FIXED_NORMALS_VIEWSPACE) && !defined(_FIXED_NORMALS_VIEWSPACE_BACKFACE) && !defined(_FIXED_NORMALS_MODELSPACE) && !defined(_FIXED_NORMALS_MODELSPACE_BACKFACE) && !defined(_FIXED_NORMALS_WORLDSPACE)
+#define MESH_NORMALS
+#endif
+
+//Check for fixing backfacing tangents
+#if defined(_FIXED_NORMALS_VIEWSPACE_BACKFACE) || defined(_FIXED_NORMALS_MODELSPACE_BACKFACE)
+#define FIXED_NORMALS_BACKFACE_RENDERING
+#endif
+
+////////////////////////////////////////
+// Vertex structs
+//
+
+struct VertexInput
+{
+	float4 vertex : POSITION;
+	float4 texcoord : TEXCOORD0;
+	float4 color : COLOR;
+#if defined(MESH_NORMALS)
+	float3 normal : NORMAL;
+#endif // _FIXED_NORMALS
+#if defined(_NORMALMAP)
+	float4 tangent : TANGENT;
+#endif // _NORMALMAP
+#if defined(_TINT_BLACK_ON)
+	float2 tintBlackRG : TEXCOORD1;
+	float2 tintBlackB : TEXCOORD2;
+#endif
+	UNITY_VERTEX_INPUT_INSTANCE_ID
+
+};
+
+////////////////////////////////////////
+// Normal functions
+//
+
+#if !defined(USE_LWRP) && !defined(USE_URP)
+uniform float4 _FixedNormal = float4(0, 0, 1, 1);
+#endif
+
+inline float3 getFixedNormal()
+{
+	return _FixedNormal.xyz;
+}
+
+inline float calculateBackfacingSign(float3 worldPos)
+{
+	//If we're using fixed normals and mesh is facing away from camera, flip tangentSign
+	//Unity uses a left handed coordinate system so camera always looks down the negative z axis
+	float3 cameraForward = float3(0,0,-1);
+	float3 meshWorldForward = mul((float3x3)unity_ObjectToWorld, cameraForward);
+	float3 toCamera = _WorldSpaceCameraPos - worldPos;
+	return sign(dot(toCamera, meshWorldForward));
+}
+
+inline half3 calculateSpriteWorldNormal(VertexInput vertex, float backFaceSign)
+{
+#if defined(MESH_NORMALS)
+
+	return calculateWorldNormal(vertex.normal);
+
+#else // !MESH_NORMALS
+
+	float3 normal = getFixedNormal();
+
+#if defined(_FIXED_NORMALS_VIEWSPACE) || defined(_FIXED_NORMALS_VIEWSPACE_BACKFACE)
+	//View space fixed normal
+	//Rotate fixed normal by inverse view matrix to convert the fixed normal into world space
+	float3x3 invView = transpose((float3x3)UNITY_MATRIX_V);
+	return normalize(mul(invView, normal));
+#elif defined (_FIXED_NORMALS_WORLDSPACE)
+	//World space fixed normal
+	return normal;
+#else
+	//Model space fixed normal.
+#if defined(FIXED_NORMALS_BACKFACE_RENDERING)
+	//If back face rendering is enabled and the sprite is facing away from the camera (ie we're rendering the backface) then need to flip the normal
+	normal *= backFaceSign;
+#endif
+	return calculateWorldNormal(normal);
+#endif
+
+#endif // !MESH_NORMALS
+}
+
+inline half3 calculateSpriteViewNormal(VertexInput vertex, float backFaceSign)
+{
+#if defined(MESH_NORMALS)
+
+	return normalize(mul((float3x3)UNITY_MATRIX_IT_MV, vertex.normal));
+
+#else // !MESH_NORMALS
+
+	float3 normal = getFixedNormal();
+
+#if defined(_FIXED_NORMALS_VIEWSPACE) || defined(_FIXED_NORMALS_VIEWSPACE_BACKFACE)
+	//View space fixed normal
+	return normal;
+#elif defined (_FIXED_NORMALS_WORLDSPACE)
+	//World space fixed normal
+	return normalize(mul((float3x3)UNITY_MATRIX_V, normal));
+#else
+	//Model space fixed normal
+#if defined(FIXED_NORMALS_BACKFACE_RENDERING)
+	//If back face rendering is enabled and the sprite is facing away from the camera (ie we're rendering the backface) then need to flip the normal
+	normal *= backFaceSign;
+#endif
+	return normalize(mul((float3x3)UNITY_MATRIX_IT_MV, normal));
+#endif
+
+#endif // !MESH_NORMALS
+}
+
+////////////////////////////////////////
+// Normal map functions
+//
+
+#if defined(_NORMALMAP)
+
+inline half3 calculateSpriteWorldBinormal(VertexInput vertex, half3 normalWorld, half3 tangentWorld, float backFaceSign)
+{
+	float tangentSign = vertex.tangent.w;
+
+#if defined(FIXED_NORMALS_BACKFACE_RENDERING)
+	tangentSign *= backFaceSign;
+#endif
+
+	return calculateWorldBinormal(normalWorld, tangentWorld, tangentSign);
+}
+
+#endif // _NORMALMAP
+
+#if defined(_DIFFUSE_RAMP)
+
+
+////////////////////////////////////////
+// Diffuse ramp functions
+//
+
+uniform sampler2D _DiffuseRamp;
+
+inline fixed3 calculateDiffuseRamp(float ramp)
+{
+	return tex2D(_DiffuseRamp, float2(ramp, ramp)).rgb;
+}
+
+inline fixed3 calculateRampedDiffuse(fixed3 lightColor, float attenuation, float angleDot)
+{
+#if defined(_FULLRANGE_HARD_RAMP)
+	float d = angleDot;
+	half3 ramp = calculateDiffuseRamp(d);
+	return lightColor * ramp * attenuation;
+#elif defined(_FULLRANGE_SOFT_RAMP)
+	float d = angleDot;
+	half3 ramp = calculateDiffuseRamp(d * attenuation);
+	return lightColor * ramp;
+#elif defined(_OLD_SOFT_RAMP)
+	// for unmodified behaviour with existing projects when
+	// the HARD_DIFFUSE_RAMP define was disabled in this file.
+	// uses only the right half of the ramp texture, as
+	// negative angleDot is clamped to [0,1] before.
+	float d = angleDot * 0.5 + 0.5;
+	half3 ramp = calculateDiffuseRamp(d);
+	return lightColor * ramp * (attenuation * 2);
+#else // _OLD_HARD_RAMP
+	// old default, for unmodified behaviour with existing projects,
+	// uses only the right half of the ramp texture, as
+	// negative angleDot is clamped to [0,1] before.
+	float d = angleDot * 0.5 + 0.5;
+	half3 ramp = calculateDiffuseRamp(d * attenuation * 2);
+	return lightColor * ramp;
+#endif
+}
+#endif // _DIFFUSE_RAMP
+
+////////////////////////////////////////
+// Rim Lighting functions
+//
+
+#ifdef _RIM_LIGHTING
+#if !defined(USE_LWRP) && !defined(USE_URP)
+uniform float _RimPower;
+uniform fixed4 _RimColor;
+#endif
+
+inline fixed3 applyRimLighting(fixed3 posWorld, fixed3 normalWorld, fixed4 pixel) : SV_Target
+{
+	fixed3 viewDir = normalize(_WorldSpaceCameraPos - posWorld);
+	float invDot =  1.0 - saturate(dot(normalWorld, viewDir));
+	float rimPower = pow(invDot, _RimPower);
+	float rim = saturate(rimPower * _RimColor.a);
+
+#if defined(_DIFFUSE_RAMP)
+	rim = calculateDiffuseRamp(rim).r;
+#endif
+
+	return lerp(pixel.rgb, _RimColor.xyz * pixel.a, rim);
+}
+
+#endif  //_RIM_LIGHTING
+
+////////////////////////////////////////
+// Emission functions
+//
+
+#ifdef _EMISSION
+
+uniform sampler2D _EmissionMap;
+
+#if !defined(USE_LWRP) && !defined(USE_URP)
+uniform fixed4 _EmissionColor;
+uniform float _EmissionPower;
+#endif
+
+
+#define APPLY_EMISSION(diffuse, uv) diffuse += tex2D(_EmissionMap, uv).rgb * _EmissionColor.rgb * _EmissionPower;
+#define APPLY_EMISSION_SPECULAR(pixel, uv) pixel.rgb += (tex2D(_EmissionMap, uv).rgb * _EmissionColor.rgb * _EmissionPower) * pixel.a;
+
+#else //!_EMISSION
+
+#define APPLY_EMISSION(diffuse, uv)
+#define APPLY_EMISSION_SPECULAR(pixel, uv)
+
+#endif  //!_EMISSION
+
+#endif // SPRITE_LIGHTING_INCLUDED