diff --git a/Resources/Fonts & Materials.meta b/Resources/Fonts & Materials.meta new file mode 100644 index 0000000..a11db16 --- /dev/null +++ b/Resources/Fonts & Materials.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 4b1760bb112944639a498bb1b6810320 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Resources/Sprite Assets.meta b/Resources/Sprite Assets.meta new file mode 100644 index 0000000..a176ccc --- /dev/null +++ b/Resources/Sprite Assets.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 6cf77ab37489442f8b2573a3b9c4bb8a +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Resources/Sprite Assets/EmojiOne (SoftMaskable).mat b/Resources/Sprite Assets/EmojiOne (SoftMaskable).mat new file mode 100644 index 0000000..d620be8 --- /dev/null +++ b/Resources/Sprite Assets/EmojiOne (SoftMaskable).mat @@ -0,0 +1,299 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!21 &2103686 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 1 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: TextMeshPro/Sprite (SoftMaskable) + m_Shader: {fileID: 4800000, guid: 94593ebff37d04a64936ebe46ce7e769, type: 3} + m_ShaderKeywords: UNITY_UI_CLIP_RECT + m_LightmapFlags: 5 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: -1 + stringTagMap: {} + disabledShaderPasses: [] + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _MainTex: + m_Texture: {fileID: 2800000, guid: dffef66376be4fa480fb02b19edbe903, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _ColorMask: 15 + - _Stencil: 0 + - _StencilComp: 8 + - _StencilOp: 0 + - _StencilReadMask: 255 + - _StencilWriteMask: 255 + - _UseUIAlphaClip: 0 + m_Colors: + - _ClipRect: {r: -32767, g: -32767, b: 32767, a: 32767} + - _Color: {r: 1, g: 1, b: 1, a: 1} +--- !u!114 &11400000 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 84a92b25f83d49b9bc132d206b370281, type: 3} + m_Name: EmojiOne (SoftMaskable) + m_EditorClassIdentifier: + hashCode: -1836805472 + material: {fileID: 2103686} + materialHashCode: 0 + spriteSheet: {fileID: 2800000, guid: dffef66376be4fa480fb02b19edbe903, type: 3} + spriteInfoList: + - id: 0 + x: 0 + y: 384 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: Smiling face with smiling eyes + hashCode: -1318250903 + unicode: 128522 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 1 + x: 128 + y: 384 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: 1f60b + hashCode: 57188339 + unicode: 128523 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 2 + x: 256 + y: 384 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: 1f60d + hashCode: 57188341 + unicode: 128525 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 3 + x: 384 + y: 384 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: 1f60e + hashCode: 57188340 + unicode: 128526 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 4 + x: 0 + y: 256 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: Grinning face + hashCode: -95541379 + unicode: 128512 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 5 + x: 128 + y: 256 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: 1f601 + hashCode: 57188256 + unicode: 128513 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 6 + x: 256 + y: 256 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: Face with tears of joy + hashCode: 239522663 + unicode: 128514 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 7 + x: 384 + y: 256 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: 1f603 + hashCode: 57188258 + unicode: 128515 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 8 + x: 0 + y: 128 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: 1f604 + hashCode: 57188261 + unicode: 128516 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 9 + x: 128 + y: 128 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: 1f605 + hashCode: 57188260 + unicode: 128517 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 10 + x: 256 + y: 128 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: 1f606 + hashCode: 57188263 + unicode: 128518 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 11 + x: 384 + y: 128 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: 1f609 + hashCode: 57188264 + unicode: 128521 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 12 + x: 0 + y: 0 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: 1f618 + hashCode: 57188168 + unicode: 128536 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 13 + x: 128 + y: 0 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: 1f923 + hashCode: 57200239 + unicode: 129315 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 14 + x: 256 + y: 0 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: 263a + hashCode: 1748406 + unicode: 9786 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + - id: 15 + x: 384 + y: 0 + width: 128 + height: 128 + xOffset: 0 + yOffset: 115.6 + xAdvance: 128 + scale: 1 + name: 2639 + hashCode: 1748462 + unicode: 9785 + pivot: {x: 0.5, y: 0.5} + sprite: {fileID: 0} + fallbackSpriteAssets: [] +--- !u!21 &1369835458 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 1 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: TextMeshPro/Sprite + m_Shader: {fileID: 4800000, guid: cf81c85f95fe47e1a27f6ae460cf182c, type: 3} + m_ShaderKeywords: + m_LightmapFlags: 5 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: -1 + stringTagMap: {} + disabledShaderPasses: [] + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: [] + m_Floats: [] + m_Colors: [] diff --git a/Resources/Sprite Assets/EmojiOne (SoftMaskable).mat.meta b/Resources/Sprite Assets/EmojiOne (SoftMaskable).mat.meta new file mode 100755 index 0000000..811d74a --- /dev/null +++ b/Resources/Sprite Assets/EmojiOne (SoftMaskable).mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: acbe5946f723c47d082ff9d2a58984dd +timeCreated: 1480316912 +licenseType: Pro +NativeFormatImporter: + userData: + assetBundleName: + assetBundleVariant: diff --git a/Scripts/Editor/SoftMaskableEditor.cs b/Scripts/Editor/SoftMaskableEditor.cs new file mode 100644 index 0000000..2c30b4c --- /dev/null +++ b/Scripts/Editor/SoftMaskableEditor.cs @@ -0,0 +1,255 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.UI; +using UnityEditor; +using System.Linq; +using System; +using System.Reflection; +using Object = UnityEngine.Object; +using System.IO; + +namespace Coffee.UIExtensions.Editors +{ + /// + /// SoftMask editor. + /// + [CustomEditor(typeof(SoftMaskable))] + [CanEditMultipleObjects] + public class SoftMaskableEditor : Editor + { + static readonly List s_Graphics = new List (); + Shader _shader; + Shader _mobileShader; + Shader _spriteShader; + + private void OnEnable () + { + ClearMaterialEditors (); + + _shader = Shader.Find ("TextMeshPro/Distance Field (SoftMaskable)"); + _mobileShader = Shader.Find ("TextMeshPro/Mobile/Distance Field (SoftMaskable)"); + _spriteShader = Shader.Find ("TextMeshPro/Sprite (SoftMaskable)"); + + + s_PiFontSharedMaterial = s_TypeTMPro.GetProperty ("fontSharedMaterial"); + s_PiSpriteAsset = s_TypeTMPro.GetProperty ("spriteAsset"); + s_PiRichText = s_TypeTMPro.GetProperty ("richText"); + s_PiText = s_TypeTMPro.GetProperty ("text"); + s_FiMaterial = s_TypeTMP_SpriteAsset.GetField ("material"); + s_PiFontSharedMaterials = s_TypeTMPro.GetProperty ("fontSharedMaterials"); + s_miGetSpriteAsset = s_TypeTMProSettings.GetMethod ("GetSpriteAsset", BindingFlags.Static | BindingFlags.Public); + + s_PiDefaultFontAssetPath = s_TypeTMProSettings.GetProperty ("defaultFontAssetPath", BindingFlags.Static | BindingFlags.Public); + s_PiDefaultSpriteAssetPath = s_TypeTMProSettings.GetProperty ("defaultSpriteAssetPath", BindingFlags.Static | BindingFlags.Public); + } + + private void OnDisable () + { + ClearMaterialEditors (); + } + + public override void OnInspectorGUI () + { + base.OnInspectorGUI (); + + var current = target as SoftMaskable; + current.GetComponentsInChildren (true, s_Graphics); + var fixTargets = s_Graphics.Where (x => x.gameObject != current.gameObject && !x.GetComponent () && (!x.GetComponent () || x.GetComponent ().showMaskGraphic)).ToList (); + if (0 < fixTargets.Count) + { + GUILayout.BeginHorizontal (); + EditorGUILayout.HelpBox ("There are child Graphicss that does not have a SoftMaskable component.\nAdd SoftMaskable component to them.", MessageType.Warning); + GUILayout.BeginVertical (); + if (GUILayout.Button ("Fix")) + { + foreach (var p in fixTargets) + { + p.gameObject.AddComponent (); + } + } + if (GUILayout.Button ("Ping")) + { + EditorGUIUtility.PingObject (fixTargets [0]); + } + GUILayout.EndVertical (); + GUILayout.EndHorizontal (); + } + + ShowTMProWarning (_shader, _mobileShader, _spriteShader, m => { }); + + + //var current = target as SoftMaskable; + var textMeshPro = current.GetComponent (s_TypeTMPro); + if (textMeshPro != null) + { + Material[] fontSharedMaterials = s_PiFontSharedMaterials.GetValue (textMeshPro, new object [0]) as Material[]; + ShowMaterialEditors (fontSharedMaterials, 1, fontSharedMaterials.Length - 1); + } + } + + + + static readonly Type s_TypeTMPro = AppDomain.CurrentDomain.GetAssemblies ().SelectMany (x => x.GetTypes ()).FirstOrDefault (x => x.Name == "TMP_Text"); + static readonly Type s_TypeTMP_SpriteAsset = AppDomain.CurrentDomain.GetAssemblies ().SelectMany (x => x.GetTypes ()).FirstOrDefault (x => x.Name == "TMP_SpriteAsset"); + static readonly Type s_TypeTMProSettings = AppDomain.CurrentDomain.GetAssemblies ().SelectMany (x => x.GetTypes ()).FirstOrDefault (x => x.Name == "TMP_Settings"); + static readonly Type s_TypeTMP_SubMesh = AppDomain.CurrentDomain.GetAssemblies ().SelectMany (x => x.GetTypes ()).FirstOrDefault (x => x.Name == "TMP_SubMesh"); + static readonly Type s_TypeTMP_SubMeshUI = AppDomain.CurrentDomain.GetAssemblies ().SelectMany (x => x.GetTypes ()).FirstOrDefault (x => x.Name == "TMP_SubMeshUI"); + static PropertyInfo s_PiFontSharedMaterial; + static PropertyInfo s_PiFontSharedMaterials; + static PropertyInfo s_PiSpriteAsset; + static PropertyInfo s_PiRichText; + static PropertyInfo s_PiText; + static PropertyInfo s_PiDefaultFontAssetPath; + static PropertyInfo s_PiDefaultSpriteAssetPath; + static FieldInfo s_FiMaterial; + static MethodInfo s_miGetSpriteAsset; + List _materialEditors = new List (); + + + void ClearMaterialEditors () + { + foreach (var e in _materialEditors) + { + if (e) + { + DestroyImmediate (e); + } + } + _materialEditors.Clear (); + } + + protected void ShowMaterialEditors (Material [] materials, int startIndex, int count) + { + for (int i = 0; i < count; i++) + { + if (_materialEditors.Count == i) + { + _materialEditors.Add (null); + } + + var mat = materials [startIndex + i]; + var editor = _materialEditors [i]; + if (editor && editor.target != mat) + { + DestroyImmediate (editor); + editor = null; + } + + if (!editor) + { + editor = _materialEditors [i] = Editor.CreateEditor (mat) as MaterialEditor; + } + + editor.DrawHeader (); + editor.OnInspectorGUI (); + } + } + + public void ShowTMProWarning (Shader shader, Shader mobileShader, Shader spriteShader, System.Action onCreatedMaterial) + { + var current = target as SoftMaskable; + var textMeshPro = current.GetComponent (s_TypeTMPro); + if(textMeshPro == null) + { + return; + } + + Material fontSharedMaterial = s_PiFontSharedMaterial.GetValue (textMeshPro, new object[0]) as Material; + if (fontSharedMaterial == null) + { + return; + } + + // Is the material preset for dissolve? + Material m = fontSharedMaterial; + if (m.shader != shader && m.shader != mobileShader) + { + EditorGUILayout.BeginHorizontal (); + EditorGUILayout.HelpBox (string.Format ("{0} requires '{1}' or '{2}' as a shader for material preset.", current.GetType ().Name, shader.name, mobileShader.name), MessageType.Warning); + if (GUILayout.Button ("Fix")) + { + var correctShader = m.shader.name.Contains ("Mobile") ? mobileShader : shader; + m = ModifyTMProMaterialPreset (m, correctShader, onCreatedMaterial); + s_PiFontSharedMaterial.SetValue (textMeshPro, m, new object[0]); + } + EditorGUILayout.EndHorizontal (); + return; + } + + // Is the sprite asset for dissolve? + object spriteAsset = s_PiSpriteAsset.GetValue(textMeshPro, new object[0]) ?? s_miGetSpriteAsset.Invoke(null, new object[0]); + //TMP_SpriteAsset spriteAsset = textMeshPro.spriteAsset ?? TMP_Settings.GetSpriteAsset (); + m = s_FiMaterial.GetValue(spriteAsset) as Material; + bool hasSprite = (bool)s_PiRichText.GetValue (textMeshPro, new object [0]) && (s_PiText.GetValue (textMeshPro, new object [0]) as string).Contains (" x.gameObject).ToList ().ForEach (DestroyImmediate); + current.GetComponentsInChildren (s_TypeTMP_SubMeshUI).Select (x => x.gameObject).ToList ().ForEach (DestroyImmediate); + spriteAsset = ModifyTMProSpriteAsset (m, _spriteShader, mat=> { }); + s_PiSpriteAsset.SetValue (textMeshPro, spriteAsset, new object[0]); + } + EditorGUILayout.EndHorizontal (); + return; + } + } + + Material ModifyTMProMaterialPreset (Material baseMaterial, Shader shader, System.Action onCreatedMaterial) + { + string path = AssetDatabase.GetAssetPath (baseMaterial); + string filename = Path.GetFileNameWithoutExtension (path) + " (" + typeof(SoftMaskable).Name + ")"; + string defaultAssetPath = s_PiDefaultFontAssetPath.GetValue (null, new object [0]) as string; + Material mat = Resources.Load (defaultAssetPath + filename); + if (!mat) + { + mat = new Material (baseMaterial) + { + shaderKeywords = baseMaterial.shaderKeywords, + shader = shader, + }; + onCreatedMaterial (mat); + AssetDatabase.CreateAsset (mat, Path.GetDirectoryName (path) + "/" + filename + ".mat"); + + EditorUtility.FocusProjectWindow (); + EditorGUIUtility.PingObject (mat); + } + else + { + mat.shader = shader; + } + EditorUtility.SetDirty (mat); + return mat; + } + + object ModifyTMProSpriteAsset (Material baseMaterial, Shader shader, System.Action onCreatedMaterial) + { + string path = AssetDatabase.GetAssetPath (baseMaterial); + string filename = Path.GetFileNameWithoutExtension (path) + " (" + typeof (SoftMaskable).Name + ")"; + string defaultAssetPath = s_PiDefaultSpriteAssetPath.GetValue (null, new object [0]) as string; + Object spriteAsset = Resources.Load (defaultAssetPath + filename, s_TypeTMP_SpriteAsset); + if (spriteAsset == null) + { + AssetDatabase.CopyAsset (path, Path.GetDirectoryName (path) + "/" + filename + ".mat"); + spriteAsset = Resources.Load (defaultAssetPath + filename, s_TypeTMP_SpriteAsset); + Material m = s_FiMaterial.GetValue (spriteAsset) as Material; + m.shader = shader; + m.name = shader.name; + onCreatedMaterial (m); + + EditorUtility.FocusProjectWindow (); + EditorGUIUtility.PingObject (spriteAsset); + } + else + { + Material m = s_FiMaterial.GetValue (spriteAsset) as Material; + m.shader = shader; + } + EditorUtility.SetDirty (spriteAsset); + return spriteAsset; + } + } +} \ No newline at end of file diff --git a/Scripts/Editor/SoftMaskableEditor.cs.meta b/Scripts/Editor/SoftMaskableEditor.cs.meta new file mode 100644 index 0000000..a9fef1b --- /dev/null +++ b/Scripts/Editor/SoftMaskableEditor.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: e2f5fc58cb78640d9abbb950e92109b6 +timeCreated: 1539820794 +licenseType: Pro +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/ShadersForTMPro.meta b/ShadersForTMPro.meta new file mode 100644 index 0000000..9dc3b11 --- /dev/null +++ b/ShadersForTMPro.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 16b13841706294f1db5d81e04270ddf1 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/ShadersForTMPro/TMP_SDF (SoftMaskable).shader b/ShadersForTMPro/TMP_SDF (SoftMaskable).shader new file mode 100755 index 0000000..2561d5e --- /dev/null +++ b/ShadersForTMPro/TMP_SDF (SoftMaskable).shader @@ -0,0 +1,310 @@ +Shader "TextMeshPro/Distance Field (SoftMaskable)" { + +Properties { + _FaceTex ("Face Texture", 2D) = "white" {} + _FaceUVSpeedX ("Face UV Speed X", Range(-5, 5)) = 0.0 + _FaceUVSpeedY ("Face UV Speed Y", Range(-5, 5)) = 0.0 + _FaceColor ("Face Color", Color) = (1,1,1,1) + _FaceDilate ("Face Dilate", Range(-1,1)) = 0 + + _OutlineColor ("Outline Color", Color) = (0,0,0,1) + _OutlineTex ("Outline Texture", 2D) = "white" {} + _OutlineUVSpeedX ("Outline UV Speed X", Range(-5, 5)) = 0.0 + _OutlineUVSpeedY ("Outline UV Speed Y", Range(-5, 5)) = 0.0 + _OutlineWidth ("Outline Thickness", Range(0, 1)) = 0 + _OutlineSoftness ("Outline Softness", Range(-1,1)) = 0 + + _Bevel ("Bevel", Range(0,1)) = 0.5 + _BevelOffset ("Bevel Offset", Range(-0.5,0.5)) = 0 + _BevelWidth ("Bevel Width", Range(-.5,0.5)) = 0 + _BevelClamp ("Bevel Clamp", Range(0,1)) = 0 + _BevelRoundness ("Bevel Roundness", Range(0,1)) = 0 + + _LightAngle ("Light Angle", Range(0.0, 6.2831853)) = 3.1416 + _SpecularColor ("Specular", Color) = (1,1,1,1) + _SpecularPower ("Specular", Range(0,4)) = 2.0 + _Reflectivity ("Reflectivity", Range(5.0,15.0)) = 10 + _Diffuse ("Diffuse", Range(0,1)) = 0.5 + _Ambient ("Ambient", Range(1,0)) = 0.5 + + _BumpMap ("Normal map", 2D) = "bump" {} + _BumpOutline ("Bump Outline", Range(0,1)) = 0 + _BumpFace ("Bump Face", Range(0,1)) = 0 + + _ReflectFaceColor ("Reflection Color", Color) = (0,0,0,1) + _ReflectOutlineColor("Reflection Color", Color) = (0,0,0,1) + _Cube ("Reflection Cubemap", Cube) = "black" { /* TexGen CubeReflect */ } + _EnvMatrixRotation ("Texture Rotation", vector) = (0, 0, 0, 0) + + + _UnderlayColor ("Border Color", Color) = (0,0,0, 0.5) + _UnderlayOffsetX ("Border OffsetX", Range(-1,1)) = 0 + _UnderlayOffsetY ("Border OffsetY", Range(-1,1)) = 0 + _UnderlayDilate ("Border Dilate", Range(-1,1)) = 0 + _UnderlaySoftness ("Border Softness", Range(0,1)) = 0 + + _GlowColor ("Color", Color) = (0, 1, 0, 0.5) + _GlowOffset ("Offset", Range(-1,1)) = 0 + _GlowInner ("Inner", Range(0,1)) = 0.05 + _GlowOuter ("Outer", Range(0,1)) = 0.05 + _GlowPower ("Falloff", Range(1, 0)) = 0.75 + + _WeightNormal ("Weight Normal", float) = 0 + _WeightBold ("Weight Bold", float) = 0.5 + + _ShaderFlags ("Flags", float) = 0 + _ScaleRatioA ("Scale RatioA", float) = 1 + _ScaleRatioB ("Scale RatioB", float) = 1 + _ScaleRatioC ("Scale RatioC", float) = 1 + + _MainTex ("Font Atlas", 2D) = "white" {} + _TextureWidth ("Texture Width", float) = 512 + _TextureHeight ("Texture Height", float) = 512 + _GradientScale ("Gradient Scale", float) = 5.0 + _ScaleX ("Scale X", float) = 1.0 + _ScaleY ("Scale Y", float) = 1.0 + _PerspectiveFilter ("Perspective Correction", Range(0, 1)) = 0.875 + + _VertexOffsetX ("Vertex OffsetX", float) = 0 + _VertexOffsetY ("Vertex OffsetY", float) = 0 + + _MaskCoord ("Mask Coordinates", vector) = (0, 0, 32767, 32767) + _ClipRect ("Clip Rect", vector) = (-32767, -32767, 32767, 32767) + _MaskSoftnessX ("Mask SoftnessX", float) = 0 + _MaskSoftnessY ("Mask SoftnessY", float) = 0 + + _StencilComp ("Stencil Comparison", Float) = 8 + _Stencil ("Stencil ID", Float) = 0 + _StencilOp ("Stencil Operation", Float) = 0 + _StencilWriteMask ("Stencil Write Mask", Float) = 255 + _StencilReadMask ("Stencil Read Mask", Float) = 255 + + _ColorMask ("Color Mask", Float) = 15 +} + +SubShader { + + Tags + { + "Queue"="Transparent" + "IgnoreProjector"="True" + "RenderType"="Transparent" + } + + Stencil + { + Ref [_Stencil] + Comp [_StencilComp] + Pass [_StencilOp] + ReadMask [_StencilReadMask] + WriteMask [_StencilWriteMask] + } + + Cull [_CullMode] + ZWrite Off + Lighting Off + Fog { Mode Off } + ZTest [unity_GUIZTestMode] + Blend One OneMinusSrcAlpha + ColorMask [_ColorMask] + + Pass { + CGPROGRAM + #pragma target 3.0 + #pragma vertex VertShader + #pragma fragment PixShader + #pragma shader_feature __ BEVEL_ON + #pragma shader_feature __ UNDERLAY_ON UNDERLAY_INNER + #pragma shader_feature __ GLOW_ON + + #pragma multi_compile __ UNITY_UI_CLIP_RECT + #pragma multi_compile __ UNITY_UI_ALPHACLIP + + + #include "UnityCG.cginc" + #include "UnityUI.cginc" + #include "Assets/TextMesh Pro/Resources/Shaders/TMPro_Properties.cginc" + #include "Assets/TextMesh Pro/Resources/Shaders/TMPro.cginc" + + #include "Assets/Coffee/UIExtensions/SoftMaskForUGUI/SoftMask.cginc" + #pragma shader_feature __ SOFTMASK_EDITOR + + struct vertex_t { + float4 position : POSITION; + float3 normal : NORMAL; + fixed4 color : COLOR; + float2 texcoord0 : TEXCOORD0; + float2 texcoord1 : TEXCOORD1; + }; + + + struct pixel_t { + float4 position : SV_POSITION; + fixed4 color : COLOR; + float2 atlas : TEXCOORD0; // Atlas + float4 param : TEXCOORD1; // alphaClip, scale, bias, weight + float4 mask : TEXCOORD2; // Position in object space(xy), pixel Size(zw) + float3 viewDir : TEXCOORD3; + + #if (UNDERLAY_ON || UNDERLAY_INNER) + float4 texcoord2 : TEXCOORD4; // u,v, scale, bias + fixed4 underlayColor : COLOR1; + #endif + float4 textures : TEXCOORD5; + }; + + // Used by Unity internally to handle Texture Tiling and Offset. + float4 _FaceTex_ST; + float4 _OutlineTex_ST; + + pixel_t VertShader(vertex_t input) + { + float bold = step(input.texcoord1.y, 0); + + float4 vert = input.position; + vert.x += _VertexOffsetX; + vert.y += _VertexOffsetY; + + float4 vPosition = UnityObjectToClipPos(vert); + + float2 pixelSize = vPosition.w; + pixelSize /= float2(_ScaleX, _ScaleY) * abs(mul((float2x2)UNITY_MATRIX_P, _ScreenParams.xy)); + float scale = rsqrt(dot(pixelSize, pixelSize)); + scale *= abs(input.texcoord1.y) * _GradientScale * 1.5; + if (UNITY_MATRIX_P[3][3] == 0) scale = lerp(abs(scale) * (1 - _PerspectiveFilter), scale, abs(dot(UnityObjectToWorldNormal(input.normal.xyz), normalize(WorldSpaceViewDir(vert))))); + + float weight = lerp(_WeightNormal, _WeightBold, bold) / 4.0; + weight = (weight + _FaceDilate) * _ScaleRatioA * 0.5; + + float bias =(.5 - weight) + (.5 / scale); + + float alphaClip = (1.0 - _OutlineWidth*_ScaleRatioA - _OutlineSoftness*_ScaleRatioA); + + #if GLOW_ON + alphaClip = min(alphaClip, 1.0 - _GlowOffset * _ScaleRatioB - _GlowOuter * _ScaleRatioB); + #endif + + alphaClip = alphaClip / 2.0 - ( .5 / scale) - weight; + + #if (UNDERLAY_ON || UNDERLAY_INNER) + float4 underlayColor = _UnderlayColor; + underlayColor.rgb *= underlayColor.a; + + float bScale = scale; + bScale /= 1 + ((_UnderlaySoftness*_ScaleRatioC) * bScale); + float bBias = (0.5 - weight) * bScale - 0.5 - ((_UnderlayDilate * _ScaleRatioC) * 0.5 * bScale); + + float x = -(_UnderlayOffsetX * _ScaleRatioC) * _GradientScale / _TextureWidth; + float y = -(_UnderlayOffsetY * _ScaleRatioC) * _GradientScale / _TextureHeight; + float2 bOffset = float2(x, y); + #endif + + // Generate UV for the Masking Texture + float4 clampedRect = clamp(_ClipRect, -2e10, 2e10); + float2 maskUV = (vert.xy - clampedRect.xy) / (clampedRect.zw - clampedRect.xy); + + // Support for texture tiling and offset + float2 textureUV = UnpackUV(input.texcoord1.x); + float2 faceUV = TRANSFORM_TEX(textureUV, _FaceTex); + float2 outlineUV = TRANSFORM_TEX(textureUV, _OutlineTex); + + pixel_t output = { + vPosition, + input.color, + input.texcoord0, + float4(alphaClip, scale, bias, weight), + half4(vert.xy * 2 - clampedRect.xy - clampedRect.zw, 0.25 / (0.25 * half2(_MaskSoftnessX, _MaskSoftnessY) + pixelSize.xy)), + mul((float3x3)_EnvMatrix, _WorldSpaceCameraPos.xyz - mul(unity_ObjectToWorld, vert).xyz), + #if (UNDERLAY_ON || UNDERLAY_INNER) + float4(input.texcoord0 + bOffset, bScale, bBias), + underlayColor, + #endif + float4(faceUV, outlineUV), + }; + + return output; + } + + + fixed4 PixShader(pixel_t input) : SV_Target + { + float c = tex2D(_MainTex, input.atlas).a; + + #ifndef UNDERLAY_ON + clip(c - input.param.x); + #endif + + float scale = input.param.y; + float bias = input.param.z; + float weight = input.param.w; + float sd = (bias - c) * scale; + + float outline = (_OutlineWidth * _ScaleRatioA) * scale; + float softness = (_OutlineSoftness * _ScaleRatioA) * scale; + + half4 faceColor = _FaceColor; + half4 outlineColor = _OutlineColor; + + faceColor.rgb *= input.color.rgb; + + faceColor *= tex2D(_FaceTex, input.textures.xy + float2(_FaceUVSpeedX, _FaceUVSpeedY) * _Time.y); + outlineColor *= tex2D(_OutlineTex, input.textures.zw + float2(_OutlineUVSpeedX, _OutlineUVSpeedY) * _Time.y); + + faceColor = GetColor(sd, faceColor, outlineColor, outline, softness); + + #if BEVEL_ON + float3 dxy = float3(0.5 / _TextureWidth, 0.5 / _TextureHeight, 0); + float3 n = GetSurfaceNormal(input.atlas, weight, dxy); + + float3 bump = UnpackNormal(tex2D(_BumpMap, input.textures.xy + float2(_FaceUVSpeedX, _FaceUVSpeedY) * _Time.y)).xyz; + bump *= lerp(_BumpFace, _BumpOutline, saturate(sd + outline * 0.5)); + n = normalize(n- bump); + + float3 light = normalize(float3(sin(_LightAngle), cos(_LightAngle), -1.0)); + + float3 col = GetSpecular(n, light); + faceColor.rgb += col*faceColor.a; + faceColor.rgb *= 1-(dot(n, light)*_Diffuse); + faceColor.rgb *= lerp(_Ambient, 1, n.z*n.z); + + fixed4 reflcol = texCUBE(_Cube, reflect(input.viewDir, -n)); + faceColor.rgb += reflcol.rgb * lerp(_ReflectFaceColor.rgb, _ReflectOutlineColor.rgb, saturate(sd + outline * 0.5)) * faceColor.a; + #endif + + #if UNDERLAY_ON + float d = tex2D(_MainTex, input.texcoord2.xy).a * input.texcoord2.z; + faceColor += input.underlayColor * saturate(d - input.texcoord2.w) * (1 - faceColor.a); + #endif + + #if UNDERLAY_INNER + float d = tex2D(_MainTex, input.texcoord2.xy).a * input.texcoord2.z; + faceColor += input.underlayColor * (1 - saturate(d - input.texcoord2.w)) * saturate(1 - sd) * (1 - faceColor.a); + #endif + + #if GLOW_ON + float4 glowColor = GetGlowColor(sd, scale); + faceColor.rgb += glowColor.rgb * glowColor.a; + #endif + + // Alternative implementation to UnityGet2DClipping with support for softness. + #if UNITY_UI_CLIP_RECT + half2 m = saturate((_ClipRect.zw - _ClipRect.xy - abs(input.mask.xy)) * input.mask.zw); + faceColor *= m.x * m.y; + #endif + + faceColor *= SoftMask(input.position); + + #if UNITY_UI_ALPHACLIP + clip(faceColor.a - 0.001); + #endif + + return faceColor * input.color.a; + } + + ENDCG + } +} + +Fallback "TextMeshPro/Mobile/Distance Field" +CustomEditor "TMPro.EditorUtilities.TMP_SDFShaderGUI" +} diff --git a/ShadersForTMPro/TMP_SDF (SoftMaskable).shader.meta b/ShadersForTMPro/TMP_SDF (SoftMaskable).shader.meta new file mode 100755 index 0000000..85d6a3d --- /dev/null +++ b/ShadersForTMPro/TMP_SDF (SoftMaskable).shader.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 935b7be1c88464d2eb87204fdfab5a38 +ShaderImporter: + defaultTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/ShadersForTMPro/TMP_SDF-Mobile (SoftMaskable).shader b/ShadersForTMPro/TMP_SDF-Mobile (SoftMaskable).shader new file mode 100755 index 0000000..2619f64 --- /dev/null +++ b/ShadersForTMPro/TMP_SDF-Mobile (SoftMaskable).shader @@ -0,0 +1,234 @@ +// Simplified SDF shader: +// - No Shading Option (bevel / bump / env map) +// - No Glow Option +// - Softness is applied on both side of the outline + +Shader "TextMeshPro/Mobile/Distance Field (SoftMaskable)" { + +Properties { + _FaceColor ("Face Color", Color) = (1,1,1,1) + _FaceDilate ("Face Dilate", Range(-1,1)) = 0 + + _OutlineColor ("Outline Color", Color) = (0,0,0,1) + _OutlineWidth ("Outline Thickness", Range(0,1)) = 0 + _OutlineSoftness ("Outline Softness", Range(0,1)) = 0 + + _UnderlayColor ("Border Color", Color) = (0,0,0,.5) + _UnderlayOffsetX ("Border OffsetX", Range(-1,1)) = 0 + _UnderlayOffsetY ("Border OffsetY", Range(-1,1)) = 0 + _UnderlayDilate ("Border Dilate", Range(-1,1)) = 0 + _UnderlaySoftness ("Border Softness", Range(0,1)) = 0 + + _WeightNormal ("Weight Normal", float) = 0 + _WeightBold ("Weight Bold", float) = .5 + + _ShaderFlags ("Flags", float) = 0 + _ScaleRatioA ("Scale RatioA", float) = 1 + _ScaleRatioB ("Scale RatioB", float) = 1 + _ScaleRatioC ("Scale RatioC", float) = 1 + + _MainTex ("Font Atlas", 2D) = "white" {} + _TextureWidth ("Texture Width", float) = 512 + _TextureHeight ("Texture Height", float) = 512 + _GradientScale ("Gradient Scale", float) = 5 + _ScaleX ("Scale X", float) = 1 + _ScaleY ("Scale Y", float) = 1 + _PerspectiveFilter ("Perspective Correction", Range(0, 1)) = 0.875 + + _VertexOffsetX ("Vertex OffsetX", float) = 0 + _VertexOffsetY ("Vertex OffsetY", float) = 0 + + _ClipRect ("Clip Rect", vector) = (-32767, -32767, 32767, 32767) + _MaskSoftnessX ("Mask SoftnessX", float) = 0 + _MaskSoftnessY ("Mask SoftnessY", float) = 0 + + _StencilComp ("Stencil Comparison", Float) = 8 + _Stencil ("Stencil ID", Float) = 0 + _StencilOp ("Stencil Operation", Float) = 0 + _StencilWriteMask ("Stencil Write Mask", Float) = 255 + _StencilReadMask ("Stencil Read Mask", Float) = 255 + + _ColorMask ("Color Mask", Float) = 15 +} + +SubShader { + Tags + { + "Queue"="Transparent" + "IgnoreProjector"="True" + "RenderType"="Transparent" + } + + + Stencil + { + Ref [_Stencil] + Comp [_StencilComp] + Pass [_StencilOp] + ReadMask [_StencilReadMask] + WriteMask [_StencilWriteMask] + } + + Cull [_CullMode] + ZWrite Off + Lighting Off + Fog { Mode Off } + ZTest [unity_GUIZTestMode] + Blend One OneMinusSrcAlpha + ColorMask [_ColorMask] + + Pass { + CGPROGRAM + #pragma vertex VertShader + #pragma fragment PixShader + #pragma shader_feature __ OUTLINE_ON + #pragma shader_feature __ UNDERLAY_ON UNDERLAY_INNER + + #pragma multi_compile __ UNITY_UI_CLIP_RECT + #pragma multi_compile __ UNITY_UI_ALPHACLIP + + #include "UnityCG.cginc" + #include "UnityUI.cginc" + #include "Assets/TextMesh Pro/Resources/Shaders/TMPro_Properties.cginc" + + #include "Assets/Coffee/UIExtensions/SoftMaskForUGUI/SoftMask.cginc" + #pragma shader_feature __ SOFTMASK_EDITOR + + struct vertex_t { + float4 vertex : POSITION; + float3 normal : NORMAL; + fixed4 color : COLOR; + float2 texcoord0 : TEXCOORD0; + float2 texcoord1 : TEXCOORD1; + }; + + struct pixel_t { + float4 vertex : SV_POSITION; + fixed4 faceColor : COLOR; + fixed4 outlineColor : COLOR1; + float4 texcoord0 : TEXCOORD0; // Texture UV, Mask UV + half4 param : TEXCOORD1; // Scale(x), BiasIn(y), BiasOut(z), Bias(w) + half4 mask : TEXCOORD2; // Position in clip space(xy), Softness(zw) + #if (UNDERLAY_ON | UNDERLAY_INNER) + float4 texcoord1 : TEXCOORD3; // Texture UV, alpha, reserved + half2 underlayParam : TEXCOORD4; // Scale(x), Bias(y) + #endif + }; + + + pixel_t VertShader(vertex_t input) + { + float bold = step(input.texcoord1.y, 0); + + float4 vert = input.vertex; + vert.x += _VertexOffsetX; + vert.y += _VertexOffsetY; + float4 vPosition = UnityObjectToClipPos(vert); + + float2 pixelSize = vPosition.w; + pixelSize /= float2(_ScaleX, _ScaleY) * abs(mul((float2x2)UNITY_MATRIX_P, _ScreenParams.xy)); + + float scale = rsqrt(dot(pixelSize, pixelSize)); + scale *= abs(input.texcoord1.y) * _GradientScale * 1.5; + if(UNITY_MATRIX_P[3][3] == 0) scale = lerp(abs(scale) * (1 - _PerspectiveFilter), scale, abs(dot(UnityObjectToWorldNormal(input.normal.xyz), normalize(WorldSpaceViewDir(vert))))); + + float weight = lerp(_WeightNormal, _WeightBold, bold) / 4.0; + weight = (weight + _FaceDilate) * _ScaleRatioA * 0.5; + + float layerScale = scale; + + scale /= 1 + (_OutlineSoftness * _ScaleRatioA * scale); + float bias = (0.5 - weight) * scale - 0.5; + float outline = _OutlineWidth * _ScaleRatioA * 0.5 * scale; + + float opacity = input.color.a; + #if (UNDERLAY_ON | UNDERLAY_INNER) + opacity = 1.0; + #endif + + fixed4 faceColor = fixed4(input.color.rgb, opacity) * _FaceColor; + faceColor.rgb *= faceColor.a; + + fixed4 outlineColor = _OutlineColor; + outlineColor.a *= opacity; + outlineColor.rgb *= outlineColor.a; + outlineColor = lerp(faceColor, outlineColor, sqrt(min(1.0, (outline * 2)))); + + #if (UNDERLAY_ON | UNDERLAY_INNER) + + layerScale /= 1 + ((_UnderlaySoftness * _ScaleRatioC) * layerScale); + float layerBias = (.5 - weight) * layerScale - .5 - ((_UnderlayDilate * _ScaleRatioC) * .5 * layerScale); + + float x = -(_UnderlayOffsetX * _ScaleRatioC) * _GradientScale / _TextureWidth; + float y = -(_UnderlayOffsetY * _ScaleRatioC) * _GradientScale / _TextureHeight; + float2 layerOffset = float2(x, y); + #endif + + // Generate UV for the Masking Texture + float4 clampedRect = clamp(_ClipRect, -2e10, 2e10); + float2 maskUV = (vert.xy - clampedRect.xy) / (clampedRect.zw - clampedRect.xy); + + // Structure for pixel shader + pixel_t output = { + vPosition, + faceColor, + outlineColor, + float4(input.texcoord0.x, input.texcoord0.y, maskUV.x, maskUV.y), + half4(scale, bias - outline, bias + outline, bias), + half4(vert.xy * 2 - clampedRect.xy - clampedRect.zw, 0.25 / (0.25 * half2(_MaskSoftnessX, _MaskSoftnessY) + pixelSize.xy)), + #if (UNDERLAY_ON | UNDERLAY_INNER) + float4(input.texcoord0 + layerOffset, input.color.a, 0), + half2(layerScale, layerBias), + #endif + }; + + return output; + } + + + // PIXEL SHADER + fixed4 PixShader(pixel_t input) : SV_Target + { + half d = tex2D(_MainTex, input.texcoord0.xy).a * input.param.x; + half4 c = input.faceColor * saturate(d - input.param.w); + + #ifdef OUTLINE_ON + c = lerp(input.outlineColor, input.faceColor, saturate(d - input.param.z)); + c *= saturate(d - input.param.y); + #endif + + #if UNDERLAY_ON + d = tex2D(_MainTex, input.texcoord1.xy).a * input.underlayParam.x; + c += float4(_UnderlayColor.rgb * _UnderlayColor.a, _UnderlayColor.a) * saturate(d - input.underlayParam.y) * (1 - c.a); + #endif + + #if UNDERLAY_INNER + half sd = saturate(d - input.param.z); + d = tex2D(_MainTex, input.texcoord1.xy).a * input.underlayParam.x; + c += float4(_UnderlayColor.rgb * _UnderlayColor.a, _UnderlayColor.a) * (1 - saturate(d - input.underlayParam.y)) * sd * (1 - c.a); + #endif + + // Alternative implementation to UnityGet2DClipping with support for softness. + #if UNITY_UI_CLIP_RECT + half2 m = saturate((_ClipRect.zw - _ClipRect.xy - abs(input.mask.xy)) * input.mask.zw); + c *= m.x * m.y; + #endif + + #if (UNDERLAY_ON | UNDERLAY_INNER) + c *= input.texcoord1.z; + #endif + + c *= SoftMask(input.vertex); + + #if UNITY_UI_ALPHACLIP + clip(c.a - 0.001); + #endif + + return c; + } + ENDCG + } +} + +CustomEditor "TMPro.EditorUtilities.TMP_SDFShaderGUI" +} diff --git a/ShadersForTMPro/TMP_SDF-Mobile (SoftMaskable).shader.meta b/ShadersForTMPro/TMP_SDF-Mobile (SoftMaskable).shader.meta new file mode 100755 index 0000000..bbb1dda --- /dev/null +++ b/ShadersForTMPro/TMP_SDF-Mobile (SoftMaskable).shader.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: e65241fa80a374114b3f55ed746c04d9 +ShaderImporter: + defaultTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/ShadersForTMPro/TMP_Sprite (SoftMaskable).shader b/ShadersForTMPro/TMP_Sprite (SoftMaskable).shader new file mode 100755 index 0000000..4508fb5 --- /dev/null +++ b/ShadersForTMPro/TMP_Sprite (SoftMaskable).shader @@ -0,0 +1,118 @@ +Shader "TextMeshPro/Sprite (SoftMaskable)" +{ + Properties + { + _MainTex ("Sprite Texture", 2D) = "white" {} + _Color ("Tint", Color) = (1,1,1,1) + + _StencilComp ("Stencil Comparison", Float) = 8 + _Stencil ("Stencil ID", Float) = 0 + _StencilOp ("Stencil Operation", Float) = 0 + _StencilWriteMask ("Stencil Write Mask", Float) = 255 + _StencilReadMask ("Stencil Read Mask", Float) = 255 + + _ColorMask ("Color Mask", Float) = 15 + _ClipRect ("Clip Rect", vector) = (-32767, -32767, 32767, 32767) + + [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0 + } + + SubShader + { + Tags + { + "Queue"="Transparent" + "IgnoreProjector"="True" + "RenderType"="Transparent" + "PreviewType"="Plane" + "CanUseSpriteAtlas"="True" + } + + Stencil + { + Ref [_Stencil] + Comp [_StencilComp] + Pass [_StencilOp] + ReadMask [_StencilReadMask] + WriteMask [_StencilWriteMask] + } + + Cull Off + Lighting Off + ZWrite Off + ZTest [unity_GUIZTestMode] + Blend SrcAlpha OneMinusSrcAlpha + ColorMask [_ColorMask] + + Pass + { + CGPROGRAM + #pragma vertex vert + #pragma fragment frag + + #include "UnityCG.cginc" + #include "UnityUI.cginc" + + #pragma multi_compile __ UNITY_UI_CLIP_RECT + #pragma multi_compile __ UNITY_UI_ALPHACLIP + + #include "Assets/Coffee/UIExtensions/SoftMaskForUGUI/SoftMask.cginc" + #pragma shader_feature __ SOFTMASK_EDITOR + + struct appdata_t + { + float4 vertex : POSITION; + float4 color : COLOR; + float2 texcoord : TEXCOORD0; + }; + + struct v2f + { + float4 vertex : SV_POSITION; + fixed4 color : COLOR; + half2 texcoord : TEXCOORD0; + float4 worldPosition : TEXCOORD1; + }; + + fixed4 _Color; + fixed4 _TextureSampleAdd; + float4 _ClipRect; + + v2f vert(appdata_t IN) + { + v2f 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 + + OUT.color = IN.color * _Color; + return OUT; + } + + sampler2D _MainTex; + + fixed4 frag(v2f IN) : SV_Target + { + half4 color = (tex2D(_MainTex, IN.texcoord) + _TextureSampleAdd) * IN.color; + + #if UNITY_UI_CLIP_RECT + color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect); + #endif + + color.a *= SoftMask(IN.vertex); + + #ifdef UNITY_UI_ALPHACLIP + clip (color.a - 0.001); + #endif + + return color; + } + ENDCG + } + } +} diff --git a/ShadersForTMPro/TMP_Sprite (SoftMaskable).shader.meta b/ShadersForTMPro/TMP_Sprite (SoftMaskable).shader.meta new file mode 100755 index 0000000..73aa212 --- /dev/null +++ b/ShadersForTMPro/TMP_Sprite (SoftMaskable).shader.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 94593ebff37d04a64936ebe46ce7e769 +timeCreated: 1450517184 +licenseType: Pro +ShaderImporter: + defaultTextures: [] + userData: + assetBundleName: + assetBundleVariant: