feat: update the effect architecture

This change adds the following features:
- Effects components can be added at runtime
- Effect mode, color mode, and blur mode can be changed at runtime
- No pre-production of materials required
- Support for non-default UI (TextMeshPro, SVG, Spine, etc.) in the future

Closes #202, #198, #195, #189, #173, #104

BREAKING CHANGE: Scenes, prefabs and scripts using UIEffect v3.x may not work properly.
This commit is contained in:
mob-sakai
2020-04-10 12:18:24 +09:00
parent 24710fc892
commit 4c08c8c162
46 changed files with 4043 additions and 5189 deletions
+1 -2
View File
@@ -1,9 +1,8 @@
fileFormatVersion: 2
guid: b3793e133930146e397ceaa2825b0e59
folderAsset: yes
timeCreated: 1527743850
licenseType: Pro
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -1,9 +1,8 @@
fileFormatVersion: 2
guid: a75d49073646347b1955a9f9df36cc45
folderAsset: yes
timeCreated: 1527743733
licenseType: Pro
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,181 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using UnityEngine;
using UnityEngine.UI;
namespace Coffee.UIExtensions
{
/// <summary>
/// Abstract effect base for UI.
/// </summary>
[DisallowMultipleComponent]
public abstract class BaseMaterialEffect : BaseMeshEffect, IParameterTexture, IMaterialModifier
{
protected static readonly Hash128 k_InvalidHash = new Hash128();
protected static readonly List<UIVertex> s_TempVerts = new List<UIVertex>();
private static readonly StringBuilder s_StringBuilder = new StringBuilder();
Hash128 _effectMaterialHash;
/// <summary>
/// Gets or sets the parameter index.
/// </summary>
public int parameterIndex { get; set; }
/// <summary>
/// Gets the parameter texture.
/// </summary>
public virtual ParameterTexture paramTex
{
get { return null; }
}
/// <summary>
/// Mark the vertices as dirty.
/// </summary>
protected void SetMaterialDirty()
{
connector.SetMaterialDirty(graphic);
}
public virtual Hash128 GetMaterialHash(Material baseMaterial)
{
return k_InvalidHash;
}
public virtual Material GetModifiedMaterial(Material baseMaterial)
{
if (!isActiveAndEnabled) return baseMaterial;
var oldHash = _effectMaterialHash;
_effectMaterialHash = GetMaterialHash(baseMaterial);
var modifiedMaterial = baseMaterial;
if (_effectMaterialHash.isValid)
{
modifiedMaterial = MaterialCache.Register(baseMaterial, _effectMaterialHash, ModifyMaterial);
}
MaterialCache.Unregister(oldHash);
return modifiedMaterial;
}
// protected bool isTMProMobile (Material material)
// {
// return material && material.shader && material.shader.name.StartsWith ("TextMeshPro/Mobile/", StringComparison.Ordinal);
// }
public virtual void ModifyMaterial(Material newMaterial)
{
if (isActiveAndEnabled && paramTex != null)
paramTex.RegisterMaterial(newMaterial);
}
protected void SetShaderVariants(Material newMaterial, params object[] variants)
{
// Set shader keywords as variants
var keywords = variants.Where(x => 0 < (int) x)
.Select(x => x.ToString().ToUpper())
.Concat(newMaterial.shaderKeywords)
.Distinct()
.ToArray();
newMaterial.shaderKeywords = keywords;
// Add variant name
s_StringBuilder.Length = 0;
s_StringBuilder.Append(Path.GetFileName(newMaterial.shader.name));
foreach (var keyword in keywords)
{
s_StringBuilder.Append("-");
s_StringBuilder.Append(keyword);
}
newMaterial.name = s_StringBuilder.ToString();
}
#if UNITY_EDITOR
protected override void Reset()
{
if (!isActiveAndEnabled) return;
SetMaterialDirty();
SetVerticesDirty();
SetEffectParamsDirty();
}
protected override void OnValidate()
{
if (!isActiveAndEnabled) return;
SetVerticesDirty();
SetEffectParamsDirty();
}
#endif
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected override void OnEnable()
{
if (paramTex != null)
{
paramTex.Register(this);
}
SetVerticesDirty();
SetMaterialDirty();
SetEffectParamsDirty();
// foreach (var mr in GetComponentsInChildren<UIEffectMaterialResolver> ())
// {
// mr.GetComponent<Graphic> ().SetMaterialDirty ();
// mr.GetComponent<Graphic> ().SetVerticesDirty ();
// }
}
/// <summary>
/// This function is called when the behaviour becomes disabled () or inactive.
/// </summary>
protected override void OnDisable()
{
SetVerticesDirty();
SetMaterialDirty();
if (paramTex != null)
{
paramTex.Unregister(this);
}
MaterialCache.Unregister(_effectMaterialHash);
_effectMaterialHash = k_InvalidHash;
}
// protected override void OnDidApplyAnimationProperties()
// {
// SetEffectParamsDirty();
// }
// protected override void OnTextChanged (UnityEngine.Object obj)
// {
// base.OnTextChanged (obj);
//
//
// foreach (var sm in GetComponentsInChildren<TMPro.TMP_SubMeshUI> ())
// {
// if(!sm.GetComponent<UIEffectMaterialResolver>())
// {
// var mr = sm.gameObject.AddComponent<UIEffectMaterialResolver> ();
//
// targetGraphic.SetAllDirty ();
// //targetGraphic.SetVerticesDirty ();
//
// //mr.GetComponent<Graphic> ().SetMaterialDirty ();
// //mr.GetComponent<Graphic> ().SetVerticesDirty ();
//
//
// }
// }
// }
}
}
@@ -2,564 +2,224 @@
using UnityEngine.EventSystems;
using UnityEngine.UI;
#if TMP_PRESENT
using System.Collections.Generic;
using TMPro;
#if UNITY_EDITOR
using UnityEditor;
using System.IO;
using System.Linq;
#endif
#endif
namespace Coffee.UIExtensions
{
/// <summary>
/// Base class for effects that modify the generated Mesh.
/// It works well not only for standard Graphic components (Image, RawImage, Text, etc.) but also for TextMeshPro and TextMeshProUGUI.
/// </summary>
[ExecuteInEditMode]
public abstract class BaseMeshEffect : UIBehaviour, IMeshModifier
{
//################################
// Constant or Static Members.
//################################
#if TMP_PRESENT
static readonly List<Vector2> s_Uv0 = new List<Vector2> (4096);
static readonly List<Vector2> s_Uv1 = new List<Vector2> (4096);
#if UNITY_2017_1_OR_NEWER
static readonly List<Vector2> s_Uv2 = new List<Vector2> (4096);
static readonly List<Vector2> s_Uv3 = new List<Vector2> (4096);
#endif
static readonly List<Vector3> s_Vertices = new List<Vector3> (4096);
static readonly List<int> s_Indices = new List<int> (4096);
static readonly List<Vector3> s_Normals = new List<Vector3> (4096);
static readonly List<Vector4> s_Tangents = new List<Vector4> (4096);
static readonly List<Color32> s_Colors = new List<Color32> (4096);
static readonly VertexHelper s_VertexHelper = new VertexHelper ();
static readonly List<TMP_SubMeshUI> s_SubMeshUIs = new List<TMP_SubMeshUI> (4096);
static readonly List<Mesh> s_Meshes = new List<Mesh> (4096);
static readonly List<UIVertex> s_UIVertices = new List<UIVertex> (4096);
static readonly List<BaseMeshEffect> s_TmpEffects = new List<BaseMeshEffect>(4);
#endif
static readonly Material [] s_EmptyMaterials = new Material [0];
/// <summary>
/// Base class for effects that modify the generated Mesh.
/// It works well not only for standard Graphic components (Image, RawImage, Text, etc.) but also for TextMeshPro and TextMeshProUGUI.
/// </summary>
[RequireComponent(typeof(Graphic))]
[RequireComponent(typeof(RectTransform))]
[ExecuteInEditMode]
public abstract class BaseMeshEffect : UIBehaviour, IMeshModifier
{
RectTransform _rectTransform;
Graphic _graphic;
BaseConnector _connector;
/// <summary>
/// The Graphic attached to this GameObject.
/// </summary>
protected BaseConnector connector
{
get { return _connector ?? (_connector = BaseConnector.FindConnector(graphic)); }
}
/// <summary>
/// The Graphic attached to this GameObject.
/// </summary>
public Graphic graphic
{
get { return _graphic ? _graphic : _graphic = GetComponent<Graphic>(); }
}
/// <summary>
/// The RectTransform attached to this GameObject.
/// </summary>
protected RectTransform rectTransform
{
get { return _rectTransform ? _rectTransform : _rectTransform = GetComponent<RectTransform>(); }
}
/// <summary>
/// The material for rendering.
/// </summary>
// public virtual Material material
// {
// get { return connector.GetMaterial(graphic); }
// set { connector.SetMaterial(graphic, value); }
// }
/// <summary>
/// Call used to modify mesh. (legacy)
/// </summary>
/// <param name="mesh">Mesh.</param>
public virtual void ModifyMesh(Mesh mesh)
{
}
/// <summary>
/// Call used to modify mesh.
/// </summary>
/// <param name="vh">VertexHelper.</param>
public virtual void ModifyMesh(VertexHelper vh)
{
}
/// <summary>
/// Mark the vertices as dirty.
/// </summary>
protected virtual void SetVerticesDirty()
{
connector.SetVerticesDirty(graphic);
// #if TMP_PRESENT
// if (textMeshPro)
// {
// foreach (var info in textMeshPro.textInfo.meshInfo)
// {
// var mesh = info.mesh;
// if (mesh)
// {
// mesh.Clear();
// mesh.vertices = info.vertices;
// mesh.uv = info.uvs0;
// mesh.uv2 = info.uvs2;
// mesh.colors32 = info.colors32;
// mesh.normals = info.normals;
// mesh.tangents = info.tangents;
// mesh.triangles = info.triangles;
// }
// }
//
// if (canvasRenderer)
// {
// canvasRenderer.SetMesh(textMeshPro.mesh);
//
// GetComponentsInChildren(false, s_SubMeshUIs);
// foreach (var sm in s_SubMeshUIs)
// {
// sm.canvasRenderer.SetMesh(sm.mesh);
// }
//
// s_SubMeshUIs.Clear();
// }
//
// textMeshPro.havePropertiesChanged = true;
// }
// else
// #endif
// if (graphic)
// {
// graphic.SetVerticesDirty();
// }
}
//################################
// Public Members.
//################################
/// <summary>
/// The Graphic attached to this GameObject.
/// </summary>
public Graphic graphic { get { Initialize (); return _graphic; } }
//################################
// Protected Members.
//################################
/// <summary>
/// Should the effect modify the mesh directly for TMPro?
/// </summary>
// protected virtual bool isLegacyMeshModifier
// {
// get { return false; }
// }
// protected virtual void Initialize()
// {
// if (_initialized) return;
//
// _initialized = true;
// _graphic = _graphic ? _graphic : GetComponent<Graphic>();
//
// _connector = BaseConnector.FindConnector(_graphic);
//
// // _canvasRenderer = _canvasRenderer ?? GetComponent<CanvasRenderer> ();
// _rectTransform = _rectTransform ? _rectTransform : GetComponent<RectTransform>();
// // #if TMP_PRESENT
// // _textMeshPro = _textMeshPro ?? GetComponent<TMP_Text> ();
// // #endif
// }
/// <summary>
/// The CanvasRenderer attached to this GameObject.
/// </summary>
public CanvasRenderer canvasRenderer { get { Initialize (); return _canvasRenderer; } }
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected override void OnEnable()
{
connector.OnEnable(graphic);
SetVerticesDirty();
#if TMP_PRESENT
/// <summary>
/// The TMP_Text attached to this GameObject.
/// </summary>
public TMP_Text textMeshPro { get { Initialize (); return _textMeshPro; } }
#endif
// SetVerticesDirty();
// #if TMP_PRESENT
// if (textMeshPro)
// {
// TMPro_EventManager.TEXT_CHANGED_EVENT.Add (OnTextChanged);
// }
// #endif
//
// #if UNITY_EDITOR && TMP_PRESENT
// if (graphic && textMeshPro)
// {
// GraphicRebuildTracker.TrackGraphic (graphic);
// }
// #endif
//
// #if UNITY_5_6_OR_NEWER
// if (graphic)
// {
// AdditionalCanvasShaderChannels channels = requiredChannels;
// var canvas = graphic.canvas;
// if (canvas && (canvas.additionalShaderChannels & channels) != channels)
// {
// Debug.LogWarningFormat (this, "Enable {1} of Canvas.additionalShaderChannels to use {0}.", GetType ().Name, channels);
// }
// }
// #endif
}
/// <summary>
/// The RectTransform attached to this GameObject.
/// </summary>
public RectTransform rectTransform { get { Initialize (); return _rectTransform; } }
/// <summary>
/// This function is called when the behaviour becomes disabled () or inactive.
/// </summary>
protected override void OnDisable()
{
connector.OnDisable(graphic);
SetVerticesDirty();
}
#if UNITY_5_6_OR_NEWER
/// <summary>
/// Additional canvas shader channels to use this component.
/// </summary>
public virtual AdditionalCanvasShaderChannels requiredChannels { get { return AdditionalCanvasShaderChannels.None; } }
#endif
/// <summary>
/// Mark the effect parameters as dirty.
/// </summary>
protected virtual void SetEffectParamsDirty()
{
if (!isActiveAndEnabled) return;
SetVerticesDirty();
}
/// <summary>
/// Is TextMeshPro or TextMeshProUGUI attached to this GameObject?
/// </summary>
public bool isTMPro
{
get
{
#if TMP_PRESENT
return textMeshPro != null;
#else
return false;
#endif
}
}
/// <summary>
/// The material for rendering.
/// </summary>
public virtual Material material
{
get
{
#if TMP_PRESENT
if (textMeshPro)
{
return textMeshPro.fontSharedMaterial;
}
else
#endif
if (graphic)
{
return graphic.material;
}
else
{
return null;
}
}
set
{
#if TMP_PRESENT
if (textMeshPro)
{
textMeshPro.fontMaterial = value;
}
else
#endif
if (graphic)
{
graphic.material = value;
}
}
}
public virtual Material[] materials
{
get
{
#if TMP_PRESENT
if (textMeshPro)
{
return textMeshPro.fontSharedMaterials ?? s_EmptyMaterials;
}
else
#endif
if (graphic)
{
_materials [0] = graphic.material;
return _materials;
}
else
{
return s_EmptyMaterials;
}
}
}
/// <summary>
/// Call used to modify mesh. (legacy)
/// </summary>
/// <param name="mesh">Mesh.</param>
public virtual void ModifyMesh (Mesh mesh)
{
}
/// <summary>
/// Call used to modify mesh.
/// </summary>
/// <param name="vh">VertexHelper.</param>
public virtual void ModifyMesh (VertexHelper vh)
{
}
/// <summary>
/// Mark the vertices as dirty.
/// </summary>
public virtual void SetVerticesDirty ()
{
#if TMP_PRESENT
if (textMeshPro)
{
foreach (var info in textMeshPro.textInfo.meshInfo)
{
var mesh = info.mesh;
if (mesh)
{
mesh.Clear ();
mesh.vertices = info.vertices;
mesh.uv = info.uvs0;
mesh.uv2 = info.uvs2;
mesh.colors32 = info.colors32;
mesh.normals = info.normals;
mesh.tangents = info.tangents;
mesh.triangles = info.triangles;
}
}
if (canvasRenderer)
{
canvasRenderer.SetMesh (textMeshPro.mesh);
GetComponentsInChildren (false, s_SubMeshUIs);
foreach (var sm in s_SubMeshUIs)
{
sm.canvasRenderer.SetMesh (sm.mesh);
}
s_SubMeshUIs.Clear ();
}
textMeshPro.havePropertiesChanged = true;
}
else
#endif
if (graphic)
{
graphic.SetVerticesDirty ();
}
}
public void ShowTMProWarning (Shader shader, Shader mobileShader, Shader spriteShader, System.Action<Material> onCreatedMaterial)
{
#if UNITY_EDITOR && TMP_PRESENT
if(!textMeshPro || !textMeshPro.fontSharedMaterial)
{
return;
}
// Is the material preset for dissolve?
Material m = textMeshPro.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.", GetType().Name, shader.name, mobileShader.name), MessageType.Warning);
if(GUILayout.Button ("Fix"))
{
var correctShader = m.shader.name.Contains ("Mobile") ? mobileShader : shader;
textMeshPro.fontSharedMaterial = ModifyTMProMaterialPreset (m, correctShader, onCreatedMaterial);
}
EditorGUILayout.EndHorizontal ();
return;
}
// Is the sprite asset for dissolve?
TMP_SpriteAsset spriteAsset = textMeshPro.spriteAsset ?? TMP_Settings.GetSpriteAsset ();
// Sprite asset might not exist at all
if(spriteAsset == null) {
return;
}
m = spriteAsset.material;
if (m && m.shader != spriteShader && textMeshPro.richText && textMeshPro.text.Contains("<sprite="))
{
EditorGUILayout.BeginHorizontal ();
EditorGUILayout.HelpBox (string.Format ("{0} requires '{1}' as a shader for sprite asset.", GetType().Name,spriteShader.name), MessageType.Warning);
if (GUILayout.Button ("Fix"))
{
GetComponentsInChildren<TMP_SubMesh> ().Select (x => x.gameObject).ToList ().ForEach (DestroyImmediate);
GetComponentsInChildren<TMP_SubMeshUI> ().Select (x => x.gameObject).ToList ().ForEach (DestroyImmediate);
textMeshPro.spriteAsset = ModifyTMProSpriteAsset (m, spriteShader, onCreatedMaterial);
}
EditorGUILayout.EndHorizontal ();
return;
}
}
Material ModifyTMProMaterialPreset (Material baseMaterial, Shader shader, System.Action<Material> onCreatedMaterial)
{
string path = AssetDatabase.GetAssetPath (baseMaterial);
string filename = Path.GetFileNameWithoutExtension (path) + " (" + GetType ().Name + ")";
Material mat = Resources.Load<Material> (TMP_Settings.defaultFontAssetPath + 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;
}
TMP_SpriteAsset ModifyTMProSpriteAsset (Material baseMaterial, Shader shader, System.Action<Material> onCreatedMaterial)
{
string path = AssetDatabase.GetAssetPath (baseMaterial);
string filename = Path.GetFileNameWithoutExtension (path) + " (" + this.GetType ().Name + ")";
TMP_SpriteAsset spriteAsset = Resources.Load<TMP_SpriteAsset> (TMP_Settings.defaultSpriteAssetPath + filename);
if (!spriteAsset)
{
AssetDatabase.CopyAsset (path, Path.GetDirectoryName (path) + "/" + filename + ".mat");
spriteAsset = Resources.Load<TMP_SpriteAsset> (TMP_Settings.defaultSpriteAssetPath + filename);
spriteAsset.material.shader = shader;
spriteAsset.material.name = shader.name;
onCreatedMaterial (spriteAsset.material);
EditorUtility.FocusProjectWindow ();
EditorGUIUtility.PingObject (spriteAsset);
}
else
{
spriteAsset.material.shader = shader;
}
EditorUtility.SetDirty (spriteAsset);
return spriteAsset;
#endif
}
//################################
// Protected Members.
//################################
/// <summary>
/// Should the effect modify the mesh directly for TMPro?
/// </summary>
protected virtual bool isLegacyMeshModifier { get { return false; } }
protected virtual void Initialize ()
{
if (!_initialized)
{
_initialized = true;
_graphic = _graphic ?? GetComponent<Graphic> ();
_canvasRenderer = _canvasRenderer ?? GetComponent<CanvasRenderer> ();
_rectTransform = _rectTransform ?? GetComponent<RectTransform> ();
#if TMP_PRESENT
_textMeshPro = _textMeshPro ?? GetComponent<TMP_Text> ();
#endif
}
}
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected override void OnEnable ()
{
_initialized = false;
SetVerticesDirty ();
#if TMP_PRESENT
if (textMeshPro)
{
TMPro_EventManager.TEXT_CHANGED_EVENT.Add (OnTextChanged);
}
#endif
#if UNITY_EDITOR && TMP_PRESENT
if (graphic && textMeshPro)
{
GraphicRebuildTracker.TrackGraphic (graphic);
}
#endif
#if UNITY_5_6_OR_NEWER
if (graphic)
{
AdditionalCanvasShaderChannels channels = requiredChannels;
var canvas = graphic.canvas;
if (canvas && (canvas.additionalShaderChannels & channels) != channels)
{
Debug.LogWarningFormat (this, "Enable {1} of Canvas.additionalShaderChannels to use {0}.", GetType ().Name, channels);
}
}
#endif
}
/// <summary>
/// This function is called when the behaviour becomes disabled () or inactive.
/// </summary>
protected override void OnDisable ()
{
#if TMP_PRESENT
TMPro_EventManager.TEXT_CHANGED_EVENT.Remove (OnTextChanged);
#endif
SetVerticesDirty ();
#if UNITY_EDITOR && TMP_PRESENT
if (graphic && textMeshPro)
{
GraphicRebuildTracker.UnTrackGraphic (graphic);
}
#endif
}
/// <summary>
/// LateUpdate is called every frame, if the Behaviour is enabled.
/// </summary>
protected virtual void LateUpdate ()
{
#if TMP_PRESENT
if (textMeshPro)
{
if (textMeshPro.havePropertiesChanged || _isTextMeshProActive != textMeshPro.isActiveAndEnabled)
{
SetVerticesDirty ();
}
_isTextMeshProActive = textMeshPro.isActiveAndEnabled;
}
#endif
}
/// <summary>
/// Callback for when properties have been changed by animation.
/// </summary>
protected override void OnDidApplyAnimationProperties ()
{
SetVerticesDirty ();
}
/// <summary>
/// Callback for when properties have been changed by animation.
/// </summary>
protected override void OnDidApplyAnimationProperties()
{
if (!isActiveAndEnabled) return;
SetEffectParamsDirty();
}
#if UNITY_EDITOR
/// <summary>
/// This function is called when the script is loaded or a value is changed in the inspector (Called in the editor only).
/// </summary>
protected override void OnValidate ()
{
SetVerticesDirty ();
}
protected override void Reset()
{
if (!isActiveAndEnabled) return;
SetVerticesDirty();
}
/// <summary>
/// This function is called when the script is loaded or a value is changed in the inspector (Called in the editor only).
/// </summary>
protected override void OnValidate()
{
if (!isActiveAndEnabled) return;
SetEffectParamsDirty();
}
#endif
//################################
// Private Members.
//################################
bool _initialized;
CanvasRenderer _canvasRenderer;
RectTransform _rectTransform;
Graphic _graphic;
Material [] _materials = new Material [1];
#if TMP_PRESENT
bool _isTextMeshProActive;
TMP_Text _textMeshPro;
/// <summary>
/// Called when any TextMeshPro generated the mesh.
/// </summary>
/// <param name="obj">TextMeshPro object.</param>
protected virtual void OnTextChanged (Object obj)
{
// Skip if the object is different from the current object or the text is empty.
var textInfo = textMeshPro.textInfo;
if (textMeshPro != obj || textInfo.characterCount - textInfo.spaceCount <= 0)
{
return;
}
GetComponents<BaseMeshEffect>(s_TmpEffects);
for (int i = 0; i < s_TmpEffects.Count; i++)
{
if (s_TmpEffects[i].enabled)
{
if (s_TmpEffects[i] == this)
break;
else
return;
}
}
// Collect the meshes.
s_Meshes.Clear ();
foreach (var info in textInfo.meshInfo)
{
s_Meshes.Add (info.mesh);
}
// Modify the meshes.
foreach (var e in s_TmpEffects)
{
if (!e.enabled)
continue;
if (e.isLegacyMeshModifier)
{
// Legacy mode: Modify the meshes directly.
foreach (var m in s_Meshes)
{
if (m)
{
e.ModifyMesh(m);
}
}
}
else
{
// Convert meshes to VertexHelpers and modify them.
foreach (var m in s_Meshes)
{
if (m)
{
FillVertexHelper(s_VertexHelper, m);
e.ModifyMesh(s_VertexHelper);
s_VertexHelper.FillMesh(m);
}
}
}
}
// Set the modified meshes to the CanvasRenderers (for UI only).
if (canvasRenderer)
{
canvasRenderer.SetMesh (textMeshPro.mesh);
GetComponentsInChildren (false, s_SubMeshUIs);
foreach (var sm in s_SubMeshUIs)
{
sm.canvasRenderer.SetMesh (sm.mesh);
}
s_SubMeshUIs.Clear ();
}
// Clear.
s_Meshes.Clear ();
}
void FillVertexHelper (VertexHelper vh, Mesh mesh)
{
vh.Clear ();
mesh.GetVertices (s_Vertices);
mesh.GetColors (s_Colors);
mesh.GetUVs (0, s_Uv0);
mesh.GetUVs (1, s_Uv1);
mesh.GetNormals (s_Normals);
mesh.GetTangents (s_Tangents);
mesh.GetIndices (s_Indices, 0);
#if UNITY_2017_1_OR_NEWER
mesh.GetUVs (2, s_Uv2);
mesh.GetUVs (3, s_Uv3);
bool useUv2 = 0 < s_Uv2.Count;
bool useUv3 = 0 < s_Uv3.Count;
#endif
s_UIVertices.Clear();
UIVertex v = default(UIVertex);
for (int i = 0; i < s_Vertices.Count; i++)
{
v.position = s_Vertices[i];
v.color = s_Colors[i];
v.uv0 = s_Uv0[i];
v.uv1 = s_Uv1[i];
#if UNITY_2017_1_OR_NEWER
if (useUv2 && i < s_Uv2.Count)
v.uv2 = s_Uv2[i];
if (useUv3 && i < s_Uv3.Count)
v.uv3 = s_Uv3[i];
#endif
v.normal = s_Normals[i];
v.tangent = s_Tangents[i];
s_UIVertices.Add(v);
}
s_VertexHelper.AddUIVertexStream(s_UIVertices, s_Indices);
}
#endif
}
}
}
}
@@ -4,153 +4,151 @@ using System.Collections.Generic;
namespace Coffee.UIExtensions
{
/// <summary>
/// Effect player.
/// </summary>
[Serializable]
public class EffectPlayer
{
//################################
// Public Members.
//################################
/// <summary>
/// Gets or sets a value indicating whether is playing.
/// </summary>
[Header("Effect Player")]
[Tooltip("Playing.")]
public bool play = false;
/// <summary>
/// Effect player.
/// </summary>
[Serializable]
public class EffectPlayer
{
//################################
// Public Members.
//################################
/// <summary>
/// Gets or sets a value indicating whether is playing.
/// </summary>
[Header("Effect Player")] [Tooltip("Playing.")]
public bool play = false;
/// <summary>
/// Gets or sets the delay before looping.
/// </summary>
[Tooltip("Initial play delay.")]
[Range(0f, 10f)]
public float initialPlayDelay = 0;
/// <summary>
/// Gets or sets the delay before looping.
/// </summary>
[Tooltip("Initial play delay.")] [Range(0f, 10f)]
public float initialPlayDelay = 0;
/// <summary>
/// Gets or sets the duration.
/// </summary>
[Tooltip("Duration.")]
[Range(0.01f,10f)]
public float duration = 1;
/// <summary>
/// Gets or sets the duration.
/// </summary>
[Tooltip("Duration.")] [Range(0.01f, 10f)]
public float duration = 1;
/// <summary>
/// Gets or sets a value indicating whether can loop.
/// </summary>
[Tooltip("Loop.")]
public bool loop = false;
/// <summary>
/// Gets or sets a value indicating whether can loop.
/// </summary>
[Tooltip("Loop.")] public bool loop = false;
/// <summary>
/// Gets or sets the delay before looping.
/// </summary>
[Tooltip("Delay before looping.")]
[Range(0f,10f)]
public float loopDelay = 0;
/// <summary>
/// Gets or sets the delay before looping.
/// </summary>
[Tooltip("Delay before looping.")] [Range(0f, 10f)]
public float loopDelay = 0;
/// <summary>
/// Gets or sets the update mode.
/// </summary>
[Tooltip("Update mode")]
public AnimatorUpdateMode updateMode = AnimatorUpdateMode.Normal;
/// <summary>
/// Gets or sets the update mode.
/// </summary>
[Tooltip("Update mode")] public AnimatorUpdateMode updateMode = AnimatorUpdateMode.Normal;
static List<Action> s_UpdateActions;
static List<Action> s_UpdateActions;
/// <summary>
/// Register player.
/// </summary>
public void OnEnable(Action<float> callback = null)
{
/// <summary>
/// Register player.
/// </summary>
public void OnEnable(Action<float> callback = null)
{
if (s_UpdateActions == null)
{
s_UpdateActions = new List<Action>();
Canvas.willRenderCanvases += () =>
{
var count = s_UpdateActions.Count;
for (int i = 0; i < count; i++)
{
s_UpdateActions[i].Invoke();
}
};
}
if (s_UpdateActions == null)
{
s_UpdateActions = new List<Action>();
Canvas.willRenderCanvases += () =>
{
var count = s_UpdateActions.Count;
for (int i = 0; i < count; i++)
{
s_UpdateActions[i].Invoke();
}
};
}
s_UpdateActions.Add(OnWillRenderCanvases);
s_UpdateActions.Add(OnWillRenderCanvases);
if (play)
{
_time = -initialPlayDelay;
}
else
{
_time = 0;
}
_callback = callback;
}
if (play)
{
_time = -initialPlayDelay;
}
else
{
_time = 0;
}
/// <summary>
/// Unregister player.
/// </summary>
public void OnDisable()
{
_callback = null;
s_UpdateActions.Remove(OnWillRenderCanvases);
}
_callback = callback;
}
/// <summary>
/// Start playing.
/// </summary>
public void Play(bool reset, Action<float> callback = null)
{
if (reset)
{
_time = 0;
}
play = true;
if (callback != null)
{
_callback = callback;
}
}
/// <summary>
/// Unregister player.
/// </summary>
public void OnDisable()
{
_callback = null;
s_UpdateActions.Remove(OnWillRenderCanvases);
}
/// <summary>
/// Stop playing.
/// </summary>
public void Stop(bool reset)
{
if (reset)
{
_time = 0;
if (_callback != null)
{
_callback(_time);
}
}
play = false;
}
/// <summary>
/// Start playing.
/// </summary>
public void Play(bool reset, Action<float> callback = null)
{
if (reset)
{
_time = 0;
}
//################################
// Private Members.
//################################
float _time = 0;
Action<float> _callback;
play = true;
if (callback != null)
{
_callback = callback;
}
}
void OnWillRenderCanvases()
{
if (!play || !Application.isPlaying || _callback == null)
{
return;
}
/// <summary>
/// Stop playing.
/// </summary>
public void Stop(bool reset)
{
if (reset)
{
_time = 0;
if (_callback != null)
{
_callback(_time);
}
}
_time += updateMode == AnimatorUpdateMode.UnscaledTime
? Time.unscaledDeltaTime
: Time.deltaTime;
var current = _time / duration;
play = false;
}
if (duration <= _time)
{
play = loop;
_time = loop ? -loopDelay : 0;
}
_callback(current);
}
}
}
//################################
// Private Members.
//################################
float _time = 0;
Action<float> _callback;
void OnWillRenderCanvases()
{
if (!play || !Application.isPlaying || _callback == null)
{
return;
}
_time += updateMode == AnimatorUpdateMode.UnscaledTime
? Time.unscaledDeltaTime
: Time.deltaTime;
var current = _time / duration;
if (duration <= _time)
{
play = loop;
_time = loop ? -loopDelay : 0;
}
_callback(current);
}
}
}
@@ -6,9 +6,11 @@ using System.Text;
namespace Coffee.UIExtensions
{
public class MaterialRepository
public class MaterialCache
{
class MaterialEntry
static Dictionary<Hash128, MaterialEntry> materialMap = new Dictionary<Hash128, MaterialEntry>();
private class MaterialEntry
{
public Material material;
public int referenceCount;
@@ -19,43 +21,41 @@ namespace Coffee.UIExtensions
{
UnityEngine.Object.DestroyImmediate(material, false);
}
material = null;
}
}
#if UNITY_EDITOR
[UnityEditor.InitializeOnLoadMethod]
static void ClearCache()
private static void ClearCache()
{
foreach (var entry in materialMap.Values)
{
entry.Release();
}
materialMap.Clear();
}
#endif
static Dictionary<Hash128, MaterialEntry> materialMap = new Dictionary<Hash128, MaterialEntry>();
public static Material Register(Material material, Hash128 hash, System.Action<Material> onModifyMaterial)
public static Material Register(Material baseMaterial, Hash128 hash, System.Action<Material> onModifyMaterial)
{
if(!hash.isValid)
return null;
if (!hash.isValid) return null;
MaterialEntry entry;
if (!materialMap.TryGetValue(hash, out entry))
{
entry = new MaterialEntry()
{
material = new Material(material)
material = new Material(baseMaterial)
{
// hideFlags = HideFlags.HideAndDontSave,
hideFlags = HideFlags.HideAndDontSave,
},
};
onModifyMaterial(entry.material);
materialMap.Add(hash, entry);
Debug.LogFormat($"Register {hash} {entry.material}");
}
entry.referenceCount++;
@@ -65,110 +65,11 @@ namespace Coffee.UIExtensions
public static void Unregister(Hash128 hash)
{
MaterialEntry entry;
if (hash.isValid && materialMap.TryGetValue(hash, out entry))
{
if (--entry.referenceCount <= 0)
{
entry.Release();
materialMap.Remove(hash);
Debug.LogFormat($"Unregister {hash}");
}
}
if (!hash.isValid || !materialMap.TryGetValue(hash, out entry)) return;
if (--entry.referenceCount > 0) return;
entry.Release();
materialMap.Remove(hash);
}
}
public class MaterialCache
{
public ulong hash { get; private set; }
public int referenceCount { get; private set; }
public Texture texture { get; private set; }
public Material material { get; private set; }
#if UNITY_EDITOR
[UnityEditor.InitializeOnLoadMethod]
static void ClearCache()
{
foreach (var cache in materialCaches)
{
cache.material = null;
}
materialCaches.Clear();
}
#endif
public static List<MaterialCache> materialCaches = new List<MaterialCache>();
public static MaterialCache Register(ulong hash, Texture texture, System.Func<Material> onCreateMaterial)
{
var cache = materialCaches.FirstOrDefault(x => x.hash == hash);
if (cache != null && cache.material)
{
if (cache.material)
{
cache.referenceCount++;
}
else
{
materialCaches.Remove(cache);
cache = null;
}
}
if (cache == null)
{
cache = new MaterialCache()
{
hash = hash,
material = onCreateMaterial(),
referenceCount = 1,
};
materialCaches.Add(cache);
}
return cache;
}
public static MaterialCache Register(ulong hash, System.Func<Material> onCreateMaterial)
{
var cache = materialCaches.FirstOrDefault(x => x.hash == hash);
if (cache != null)
{
cache.referenceCount++;
}
if (cache == null)
{
cache = new MaterialCache()
{
hash = hash,
material = onCreateMaterial(),
referenceCount = 1,
};
materialCaches.Add(cache);
}
return cache;
}
public static void Unregister(MaterialCache cache)
{
if (cache == null)
{
return;
}
cache.referenceCount--;
if (cache.referenceCount <= 0)
{
MaterialCache.materialCaches.Remove(cache);
cache.material = null;
}
}
}
}
}
@@ -1,126 +0,0 @@
#if UNITY_EDITOR
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEditor;
using UnityEngine;
namespace Coffee.UIExtensions
{
public class MaterialResolver
{
static readonly StringBuilder s_StringBuilder = new StringBuilder();
static readonly Dictionary<string, Material> s_MaterialMap = new Dictionary<string, Material>();
public static Material GetOrGenerateMaterialVariant(Shader shader, params object[] append)
{
if (!shader)
{
return null;
}
Material mat = null;
string variantName = GetVariantName(shader, append);
if (s_MaterialMap.TryGetValue(variantName, out mat) && mat)
{
return mat;
}
string[] keywords = append.Where(x => 0 < (int)x)
.Select(x => x.ToString().ToUpper())
.ToArray();
mat = GetMaterial(shader, append);
if (mat)
{
if (!mat.shaderKeywords.OrderBy(x => x).SequenceEqual(keywords.OrderBy(x => x)))
{
mat.shaderKeywords = keywords;
EditorUtility.SetDirty(mat);
if (!Application.isPlaying)
{
EditorApplication.delayCall += AssetDatabase.SaveAssets;
}
}
return mat;
}
if (s_MaterialMap.TryGetValue(variantName, out mat) && mat)
{
return mat;
}
Debug.Log("Generate material : " + variantName);
mat = new Material(shader);
mat.shaderKeywords = keywords;
mat.name = variantName;
mat.hideFlags |= HideFlags.NotEditable;
s_MaterialMap[variantName] = mat;
bool isMainAsset = append.Cast<int>().All(x => x == 0);
EditorApplication.delayCall += () => SaveMaterial(mat, shader, isMainAsset);
return mat;
}
static void SaveMaterial(Material mat, Shader shader, bool isMainAsset)
{
string materialPath = GetDefaultMaterialPath(shader);
#if UIEFFECT_SEPARATE
string dir = Path.GetDirectoryName(materialPath);
materialPath = Path.Combine(Path.Combine(dir, "Separated"), mat.name + ".mat");
isMainAsset = true;
#endif
if (isMainAsset)
{
Directory.CreateDirectory(Path.GetDirectoryName(materialPath));
AssetDatabase.CreateAsset(mat, materialPath);
}
else
{
GetOrGenerateMaterialVariant(shader);
mat.hideFlags |= HideFlags.HideInHierarchy;
AssetDatabase.AddObjectToAsset(mat, materialPath);
}
AssetDatabase.SaveAssets();
}
public static Material GetMaterial(Shader shader, params object[] append)
{
string variantName = GetVariantName(shader, append);
return AssetDatabase.FindAssets("t:Material " + Path.GetFileName(shader.name))
.Select(x => AssetDatabase.GUIDToAssetPath(x))
.SelectMany(x => AssetDatabase.LoadAllAssetsAtPath(x))
.OfType<Material>()
.FirstOrDefault(x => x.name == variantName);
}
public static string GetDefaultMaterialPath(Shader shader)
{
var name = Path.GetFileName(shader.name);
return AssetDatabase.FindAssets("t:Material " + name)
.Select(x => AssetDatabase.GUIDToAssetPath(x))
.FirstOrDefault(x => Path.GetFileNameWithoutExtension(x) == name)
?? ("Assets/" + name + ".mat");
}
public static string GetVariantName(Shader shader, params object[] append)
{
s_StringBuilder.Length = 0;
#if UIEFFECT_SEPARATE
s_StringBuilder.Append("[Separated] ");
#endif
s_StringBuilder.Append(Path.GetFileName(shader.name));
foreach (object mode in append.Where(x=>0<(int)x))
{
s_StringBuilder.Append("-");
s_StringBuilder.Append(mode.ToString());
}
return s_StringBuilder.ToString();
}
}
}
#endif
@@ -2,32 +2,32 @@
namespace Coffee.UIExtensions
{
/// <summary>
/// Matrix2x3.
/// </summary>
public struct Matrix2x3
{
public float m00, m01, m02, m10, m11, m12;
/// <summary>
/// Matrix2x3.
/// </summary>
public struct Matrix2x3
{
public float m00, m01, m02, m10, m11, m12;
public Matrix2x3(Rect rect, float cos, float sin)
{
const float center = 0.5f;
float dx = -rect.xMin / rect.width - center;
float dy = -rect.yMin / rect.height - center;
m00 = cos / rect.width;
m01 = -sin / rect.height;
m02 = dx * cos - dy * sin + center;
m10 = sin / rect.width;
m11 = cos / rect.height;
m12 = dx * sin + dy * cos + center;
}
public Matrix2x3(Rect rect, float cos, float sin)
{
const float center = 0.5f;
float dx = -rect.xMin / rect.width - center;
float dy = -rect.yMin / rect.height - center;
m00 = cos / rect.width;
m01 = -sin / rect.height;
m02 = dx * cos - dy * sin + center;
m10 = sin / rect.width;
m11 = cos / rect.height;
m12 = dx * sin + dy * cos + center;
}
public static Vector2 operator*(Matrix2x3 m, Vector2 v)
{
return new Vector2(
(m.m00 * v.x) + (m.m01 * v.y) + m.m02,
(m.m10 * v.x) + (m.m11 * v.y) + m.m12
);
}
}
}
public static Vector2 operator *(Matrix2x3 m, Vector2 v)
{
return new Vector2(
(m.m00 * v.x) + (m.m01 * v.y) + m.m02,
(m.m10 * v.x) + (m.m11 * v.y) + m.m12
);
}
}
}
@@ -4,57 +4,58 @@ using UnityEngine;
public static class Packer
{
/// <summary>
/// Pack 4 low-precision [0-1] floats values to a float.
/// Each value [0-1] has 64 steps(6 bits).
/// </summary>
public static float ToFloat(float x, float y, float z, float w)
{
x = x < 0 ? 0 : 1 < x ? 1 : x;
y = y < 0 ? 0 : 1 < y ? 1 : y;
z = z < 0 ? 0 : 1 < z ? 1 : z;
w = w < 0 ? 0 : 1 < w ? 1 : w;
const int PRECISION = (1 << 6) - 1;
return (Mathf.FloorToInt(w * PRECISION) << 18)
+ (Mathf.FloorToInt(z * PRECISION) << 12)
+ (Mathf.FloorToInt(y * PRECISION) << 6)
+ Mathf.FloorToInt(x * PRECISION);
}
/// <summary>
/// Pack 4 low-precision [0-1] floats values to a float.
/// Each value [0-1] has 64 steps(6 bits).
/// </summary>
public static float ToFloat(float x, float y, float z, float w)
{
x = x < 0 ? 0 : 1 < x ? 1 : x;
y = y < 0 ? 0 : 1 < y ? 1 : y;
z = z < 0 ? 0 : 1 < z ? 1 : z;
w = w < 0 ? 0 : 1 < w ? 1 : w;
const int PRECISION = (1 << 6) - 1;
return (Mathf.FloorToInt(w * PRECISION) << 18)
+ (Mathf.FloorToInt(z * PRECISION) << 12)
+ (Mathf.FloorToInt(y * PRECISION) << 6)
+ Mathf.FloorToInt(x * PRECISION);
}
/// <summary>
/// Pack 4 low-precision [0-1] floats values to a float.
/// Each value [0-1] has 64 steps(6 bits).
/// </summary>
public static float ToFloat(Vector4 factor)
{
return ToFloat(Mathf.Clamp01(factor.x), Mathf.Clamp01(factor.y), Mathf.Clamp01(factor.z), Mathf.Clamp01(factor.w));
}
/// <summary>
/// Pack 4 low-precision [0-1] floats values to a float.
/// Each value [0-1] has 64 steps(6 bits).
/// </summary>
public static float ToFloat(Vector4 factor)
{
return ToFloat(Mathf.Clamp01(factor.x), Mathf.Clamp01(factor.y), Mathf.Clamp01(factor.z),
Mathf.Clamp01(factor.w));
}
/// <summary>
/// Pack 1 middle-precision & 2 low-precision [0-1] floats values to a float.
/// z value [0-1] has 4096 steps(12 bits) and xy value [0-1] has 64 steps(6 bits).
/// </summary>
public static float ToFloat(float x, float y, float z)
{
x = x < 0 ? 0 : 1 < x ? 1 : x;
y = y < 0 ? 0 : 1 < y ? 1 : y;
z = z < 0 ? 0 : 1 < z ? 1 : z;
const int PRECISION = (1 << 8) - 1;
return (Mathf.FloorToInt(z * PRECISION) << 16)
+ (Mathf.FloorToInt(y * PRECISION) << 8)
+ Mathf.FloorToInt(x * PRECISION);
}
/// <summary>
/// Pack 1 middle-precision & 2 low-precision [0-1] floats values to a float.
/// z value [0-1] has 4096 steps(12 bits) and xy value [0-1] has 64 steps(6 bits).
/// </summary>
public static float ToFloat(float x, float y, float z)
{
x = x < 0 ? 0 : 1 < x ? 1 : x;
y = y < 0 ? 0 : 1 < y ? 1 : y;
z = z < 0 ? 0 : 1 < z ? 1 : z;
const int PRECISION = (1 << 8) - 1;
return (Mathf.FloorToInt(z * PRECISION) << 16)
+ (Mathf.FloorToInt(y * PRECISION) << 8)
+ Mathf.FloorToInt(x * PRECISION);
}
/// <summary>
/// Pack 2 low-precision [0-1] floats values to a float.
/// Each value [0-1] has 4096 steps(12 bits).
/// </summary>
public static float ToFloat(float x, float y)
{
x = x < 0 ? 0 : 1 < x ? 1 : x;
y = y < 0 ? 0 : 1 < y ? 1 : y;
const int PRECISION = (1 << 12) - 1;
return (Mathf.FloorToInt(y * PRECISION) << 12)
+ Mathf.FloorToInt(x * PRECISION);
}
/// <summary>
/// Pack 2 low-precision [0-1] floats values to a float.
/// Each value [0-1] has 4096 steps(12 bits).
/// </summary>
public static float ToFloat(float x, float y)
{
x = x < 0 ? 0 : 1 < x ? 1 : x;
y = y < 0 ? 0 : 1 < y ? 1 : y;
const int PRECISION = (1 << 12) - 1;
return (Mathf.FloorToInt(y * PRECISION) << 12)
+ Mathf.FloorToInt(x * PRECISION);
}
}
@@ -6,185 +6,185 @@ using System;
namespace Coffee.UIExtensions
{
public interface IParameterTexture
{
int parameterIndex { get; set; }
public interface IParameterTexture
{
int parameterIndex { get; set; }
ParameterTexture ptex { get; }
}
ParameterTexture paramTex { get; }
}
/// <summary>
/// Parameter texture.
/// </summary>
[System.Serializable]
public class ParameterTexture
{
/// <summary>
/// Parameter texture.
/// </summary>
[System.Serializable]
public class ParameterTexture
{
//################################
// Public Members.
//################################
//################################
// Public Members.
//################################
/// <summary>
/// Initializes a new instance of the <see cref="Coffee.UIExtensions.ParameterTexture"/> class.
/// </summary>
/// <param name="channels">Channels.</param>
/// <param name="instanceLimit">Instance limit.</param>
/// <param name="propertyName">Property name.</param>
public ParameterTexture(int channels, int instanceLimit, string propertyName)
{
_propertyName = propertyName;
_channels = ((channels - 1) / 4 + 1) * 4;
_instanceLimit = ((instanceLimit - 1) / 2 + 1) * 2;
_data = new byte[_channels * _instanceLimit];
/// <summary>
/// Initializes a new instance of the <see cref="Coffee.UIExtensions.ParameterTexture"/> class.
/// </summary>
/// <param name="channels">Channels.</param>
/// <param name="instanceLimit">Instance limit.</param>
/// <param name="propertyName">Property name.</param>
public ParameterTexture(int channels, int instanceLimit, string propertyName)
{
_propertyName = propertyName;
_channels = ((channels - 1) / 4 + 1) * 4;
_instanceLimit = ((instanceLimit - 1) / 2 + 1) * 2;
_data = new byte[_channels * _instanceLimit];
_stack = new Stack<int>(_instanceLimit);
for (int i = 1; i < _instanceLimit + 1; i++)
{
_stack.Push(i);
}
}
_stack = new Stack<int>(_instanceLimit);
for (int i = 1; i < _instanceLimit + 1; i++)
{
_stack.Push(i);
}
}
/// <summary>
/// Register the specified target.
/// </summary>
/// <param name="target">Target.</param>
public void Register(IParameterTexture target)
{
Initialize();
if (target.parameterIndex <= 0 && 0 < _stack.Count)
{
target.parameterIndex = _stack.Pop();
/// <summary>
/// Register the specified target.
/// </summary>
/// <param name="target">Target.</param>
public void Register(IParameterTexture target)
{
Initialize();
if (target.parameterIndex <= 0 && 0 < _stack.Count)
{
target.parameterIndex = _stack.Pop();
// Debug.LogFormat("<color=green>@@@ Register {0} : {1}</color>", target, target.parameterIndex);
}
}
}
}
/// <summary>
/// Unregister the specified target.
/// </summary>
/// <param name="target">Target.</param>
public void Unregister(IParameterTexture target)
{
if (0 < target.parameterIndex)
{
/// <summary>
/// Unregister the specified target.
/// </summary>
/// <param name="target">Target.</param>
public void Unregister(IParameterTexture target)
{
if (0 < target.parameterIndex)
{
// Debug.LogFormat("<color=red>@@@ Unregister {0} : {1}</color>", target, target.parameterIndex);
_stack.Push(target.parameterIndex);
target.parameterIndex = 0;
}
}
_stack.Push(target.parameterIndex);
target.parameterIndex = 0;
}
}
/// <summary>
/// Sets the data.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="channelId">Channel identifier.</param>
/// <param name="value">Value.</param>
public void SetData(IParameterTexture target, int channelId, byte value)
{
int index = (target.parameterIndex - 1) * _channels + channelId;
if (0 < target.parameterIndex && _data[index] != value)
{
_data[index] = value;
_needUpload = true;
}
}
/// <summary>
/// Sets the data.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="channelId">Channel identifier.</param>
/// <param name="value">Value.</param>
public void SetData(IParameterTexture target, int channelId, byte value)
{
int index = (target.parameterIndex - 1) * _channels + channelId;
if (0 < target.parameterIndex && _data[index] != value)
{
_data[index] = value;
_needUpload = true;
}
}
/// <summary>
/// Sets the data.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="channelId">Channel identifier.</param>
/// <param name="value">Value.</param>
public void SetData(IParameterTexture target, int channelId, float value)
{
SetData(target, channelId, (byte)(Mathf.Clamp01(value) * 255));
}
/// <summary>
/// Sets the data.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="channelId">Channel identifier.</param>
/// <param name="value">Value.</param>
public void SetData(IParameterTexture target, int channelId, float value)
{
SetData(target, channelId, (byte) (Mathf.Clamp01(value) * 255));
}
/// <summary>
/// Registers the material.
/// </summary>
/// <param name="mat">Mat.</param>
public void RegisterMaterial(Material mat)
{
if (_propertyId == 0)
{
_propertyId = Shader.PropertyToID(_propertyName);
}
if (mat)
{
mat.SetTexture(_propertyId, _texture);
}
}
/// <summary>
/// Registers the material.
/// </summary>
/// <param name="mat">Mat.</param>
public void RegisterMaterial(Material mat)
{
if (_propertyId == 0)
{
_propertyId = Shader.PropertyToID(_propertyName);
}
/// <summary>
/// Gets the index of the normalized.
/// </summary>
/// <returns>The normalized index.</returns>
/// <param name="target">Target.</param>
public float GetNormalizedIndex(IParameterTexture target)
{
return ((float)target.parameterIndex - 0.5f) / _instanceLimit;
}
if (mat)
{
mat.SetTexture(_propertyId, _texture);
}
}
/// <summary>
/// Gets the index of the normalized.
/// </summary>
/// <returns>The normalized index.</returns>
/// <param name="target">Target.</param>
public float GetNormalizedIndex(IParameterTexture target)
{
return ((float) target.parameterIndex - 0.5f) / _instanceLimit;
}
//################################
// Private Members.
//################################
//################################
// Private Members.
//################################
Texture2D _texture;
bool _needUpload;
int _propertyId;
readonly string _propertyName;
readonly int _channels;
readonly int _instanceLimit;
readonly byte[] _data;
readonly Stack<int> _stack;
static List<Action> updates;
Texture2D _texture;
bool _needUpload;
int _propertyId;
readonly string _propertyName;
readonly int _channels;
readonly int _instanceLimit;
readonly byte[] _data;
readonly Stack<int> _stack;
static List<Action> updates;
/// <summary>
/// Initialize this instance.
/// </summary>
void Initialize()
{
/// <summary>
/// Initialize this instance.
/// </summary>
void Initialize()
{
#if UNITY_EDITOR
if (!UnityEditor.EditorApplication.isPlaying && UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode)
{
return;
}
if (!UnityEditor.EditorApplication.isPlaying && UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode)
{
return;
}
#endif
if (updates == null)
{
updates = new List<Action>();
Canvas.willRenderCanvases += () =>
{
var count = updates.Count;
for (int i = 0; i < count; i++)
{
updates[i].Invoke();
}
};
}
if (updates == null)
{
updates = new List<Action>();
Canvas.willRenderCanvases += () =>
{
var count = updates.Count;
for (int i = 0; i < count; i++)
{
updates[i].Invoke();
}
};
}
if (!_texture)
{
bool isLinear = QualitySettings.activeColorSpace == ColorSpace.Linear;
_texture = new Texture2D(_channels / 4, _instanceLimit, TextureFormat.RGBA32, false, isLinear);
_texture.filterMode = FilterMode.Point;
_texture.wrapMode = TextureWrapMode.Clamp;
if (!_texture)
{
bool isLinear = QualitySettings.activeColorSpace == ColorSpace.Linear;
_texture = new Texture2D(_channels / 4, _instanceLimit, TextureFormat.RGBA32, false, isLinear);
_texture.filterMode = FilterMode.Point;
_texture.wrapMode = TextureWrapMode.Clamp;
updates.Add(UpdateParameterTexture);
_needUpload = true;
}
}
updates.Add(UpdateParameterTexture);
_needUpload = true;
}
}
void UpdateParameterTexture()
{
if (_needUpload && _texture)
{
_needUpload = false;
_texture.LoadRawTextureData(_data);
_texture.Apply(false, false);
}
}
}
}
void UpdateParameterTexture()
{
if (_needUpload && _texture)
{
_needUpload = false;
_texture.LoadRawTextureData(_data);
_texture.Apply(false, false);
}
}
}
}
@@ -1,268 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using UnityEngine;
using UnityEngine.UI;
namespace Coffee.UIExtensions
{
/// <summary>
/// Abstract effect base for UI.
/// </summary>
[DisallowMultipleComponent]
public abstract class UIEffectBase : BaseMeshEffect, IParameterTexture, IMaterialModifier
#if UNITY_EDITOR
, ISerializationCallbackReceiver
#endif
{
protected static readonly Vector2[] splitedCharacterPosition = { Vector2.up, Vector2.one, Vector2.right, Vector2.zero };
protected static readonly List<UIVertex> tempVerts = new List<UIVertex>();
protected static readonly StringBuilder stringBuilder = new StringBuilder();
[HideInInspector]
[SerializeField] int m_Version;
[SerializeField] protected Material m_EffectMaterial;
/// <summary>
/// Gets or sets the parameter index.
/// </summary>
public int parameterIndex { get; set; }
/// <summary>
/// Gets the parameter texture.
/// </summary>
public virtual ParameterTexture ptex { get { return null; } }
/// <summary>
/// Gets target graphic for effect.
/// </summary>
public Graphic targetGraphic { get { return graphic; } }
/// <summary>
/// Gets material for effect.
/// </summary>
public Material effectMaterial { get { return m_EffectMaterial; } }
public virtual Hash128 GetMaterialHash(Material material)
{
return new Hash128();
}
public virtual Material GetModifiedMaterial(Material baseMaterial)
{
if(!isActiveAndEnabled)
{
return baseMaterial;
}
var oldHash = _effectMaterialHash;
_effectMaterialHash = GetMaterialHash(baseMaterial);
var modifiedMaterial = baseMaterial;
if(_effectMaterialHash.isValid)
{
modifiedMaterial = MaterialRepository.Register(baseMaterial, _effectMaterialHash, ModifyMaterial);
}
MaterialRepository.Unregister(oldHash);
return modifiedMaterial;
}
protected bool isTMProMobile (Material material)
{
return material && material.shader && material.shader.name.StartsWith ("TextMeshPro/Mobile/", StringComparison.Ordinal);
}
public virtual void ModifyMaterial(Material material)
{
Debug.Log("ModifyMaterial PTEX!!! " + ptex);
if(isActiveAndEnabled && ptex != null)
ptex.RegisterMaterial (material);
}
protected void SetShaderVariants(Material material, params object[] variants)
{
// Set shader keywords as variants
var keywords = variants.Where(x => 0 < (int)x)
.Select(x => x.ToString().ToUpper())
.Concat(material.shaderKeywords)
.ToArray();
material.shaderKeywords = keywords;
// Add variant name
stringBuilder.Length = 0;
stringBuilder.Append(Path.GetFileName(material.shader.name) );
foreach(var keyword in keywords)
{
stringBuilder.Append("-");
stringBuilder.Append(keyword);
}
material.name += stringBuilder.ToString();
}
Hash128 _effectMaterialHash;
#if UNITY_EDITOR
protected override void Reset()
{
m_Version = 300;
OnValidate();
}
/// <summary>
/// Raises the validate event.
/// </summary>
protected override void OnValidate()
{
base.OnValidate ();
var mat = GetMaterial();
if (m_EffectMaterial != mat)
{
m_EffectMaterial = mat;
UnityEditor.EditorUtility.SetDirty(this);
}
ModifyMaterial();
SetVerticesDirty ();
SetEffectDirty ();
}
public void OnBeforeSerialize()
{
}
public void OnAfterDeserialize()
{
UnityEditor.EditorApplication.delayCall += UpgradeIfNeeded;
}
protected bool IsShouldUpgrade(int expectedVersion)
{
if (m_Version < expectedVersion)
{
Debug.LogFormat(gameObject, "<b>{0}({1})</b> has been upgraded: <i>version {2} -> {3}</i>", name, GetType().Name, m_Version, expectedVersion);
m_Version = expectedVersion;
//UnityEditor.EditorApplication.delayCall += () =>
{
UnityEditor.EditorUtility.SetDirty(this);
if (!Application.isPlaying && gameObject && gameObject.scene.IsValid())
{
UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(gameObject.scene);
}
}
;
return true;
}
return false;
}
protected virtual void UpgradeIfNeeded()
{
}
/// <summary>
/// Gets the material.
/// </summary>
/// <returns>The material.</returns>
protected virtual Material GetMaterial()
{
return null;
}
#endif
/// <summary>
/// Modifies the material.
/// </summary>
public virtual void ModifyMaterial()
{
targetGraphic.material = isActiveAndEnabled ? m_EffectMaterial : null;
}
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected override void OnEnable()
{
base.OnEnable ();
if (ptex != null)
{
ptex.Register(this);
}
ModifyMaterial();
graphic.SetMaterialDirty();
graphic.SetVerticesDirty();
SetEffectDirty();
foreach (var mr in GetComponentsInChildren<UIEffectMaterialResolver> ())
{
mr.GetComponent<Graphic> ().SetMaterialDirty ();
mr.GetComponent<Graphic> ().SetVerticesDirty ();
}
}
/// <summary>
/// This function is called when the behaviour becomes disabled () or inactive.
/// </summary>
protected override void OnDisable()
{
base.OnDisable ();
graphic.SetMaterialDirty();
graphic.SetVerticesDirty();
if (ptex != null)
{
ptex.Unregister(this);
}
MaterialRepository.Unregister(_effectMaterialHash);
_effectMaterialHash = new Hash128();
foreach (var mr in GetComponentsInChildren<UIEffectMaterialResolver> ())
{
mr.GetComponent<Graphic> ().SetMaterialDirty ();
mr.GetComponent<Graphic> ().SetVerticesDirty ();
}
}
/// <summary>
/// Mark the UIEffect as dirty.
/// </summary>
protected virtual void SetEffectDirty()
{
SetVerticesDirty();
}
protected override void OnDidApplyAnimationProperties()
{
SetEffectDirty();
}
protected override void OnTextChanged (UnityEngine.Object obj)
{
base.OnTextChanged (obj);
foreach (var sm in GetComponentsInChildren<TMPro.TMP_SubMeshUI> ())
{
if(!sm.GetComponent<UIEffectMaterialResolver>())
{
var mr = sm.gameObject.AddComponent<UIEffectMaterialResolver> ();
targetGraphic.SetAllDirty ();
//targetGraphic.SetVerticesDirty ();
//mr.GetComponent<Graphic> ().SetMaterialDirty ();
//mr.GetComponent<Graphic> ().SetVerticesDirty ();
}
}
}
}
}
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 73be53ea7d09c45bc83e7b957a5b99b5
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,168 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;
namespace Coffee.UIExtensions
{
public class BaseConnector
{
private static readonly List<BaseConnector> s_Connectors = new List<BaseConnector>();
private static readonly Dictionary<Type, BaseConnector> s_ConnectorMap = new Dictionary<Type, BaseConnector>();
private static readonly BaseConnector s_EmptyConnector = new BaseConnector();
#if UNITY_EDITOR
[UnityEditor.InitializeOnLoadMethod]
#endif
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
private static void Init()
{
AddConnector(s_EmptyConnector);
}
protected static void AddConnector(BaseConnector connector)
{
s_Connectors.Add(connector);
s_Connectors.Sort((x, y) => y.priority - x.priority);
}
public static BaseConnector FindConnector(Graphic graphic)
{
if (!graphic) return s_EmptyConnector;
var type = graphic.GetType();
BaseConnector connector = null;
if (s_ConnectorMap.TryGetValue(type, out connector)) return connector;
foreach (var c in s_Connectors)
{
if (!c.IsValid(graphic)) continue;
s_ConnectorMap.Add(type, c);
return c;
}
return s_EmptyConnector;
}
/// <summary>
/// The connector is valid for the component.
/// </summary>
protected virtual bool IsValid(Graphic graphic)
{
return true;
}
/// <summary>
/// Find effect shader.
/// </summary>
public virtual Shader FindShader(string shaderName)
{
return null;
}
/// <summary>
/// Priority.
/// </summary>
protected virtual int priority
{
get { return -1; }
}
/// <summary>
/// Extra channel.
/// </summary>
public virtual AdditionalCanvasShaderChannels extraChannel
{
get { return AdditionalCanvasShaderChannels.None; }
}
/// <summary>
/// Set material.
/// </summary>
public virtual void SetMaterial(Graphic graphic, Material material)
{
}
/// <summary>
/// Get material.
/// </summary>
public virtual Material GetMaterial(Graphic graphic)
{
return null;
}
/// <summary>
/// Mark the vertices as dirty.
/// </summary>
public virtual void SetVerticesDirty(Graphic graphic)
{
}
/// <summary>
/// Mark the material as dirty.
/// </summary>
public virtual void SetMaterialDirty(Graphic graphic)
{
}
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
public virtual void OnEnable(Graphic graphic)
{
}
/// <summary>
/// This function is called when the behaviour becomes disabled () or inactive.
/// </summary>
public virtual void OnDisable(Graphic graphic)
{
}
/// <summary>
/// Event that is called just before Canvas rendering happens.
/// This allows you to delay processing / updating of canvas based elements until just before they are rendered.
/// </summary>
protected virtual void OnWillRenderCanvases()
{
}
/// <summary>
/// Gets position factor for area.
/// </summary>
public void GetPositionFactor(EffectArea area, int index, Rect rect, Vector2 position, out float x, out float y)
{
if (area == EffectArea.Fit)
{
x = Mathf.Clamp01((position.x - rect.xMin) / rect.width);
y = Mathf.Clamp01((position.y - rect.yMin) / rect.height);
}
else
{
x = Mathf.Clamp01(position.x / rect.width + 0.5f);
y = Mathf.Clamp01(position.y / rect.height + 0.5f);
}
}
/// <summary>
/// Normalize vertex position by local matrix.
/// </summary>
public void GetNormalizedFactor(EffectArea area, int index, Matrix2x3 matrix, Vector2 position,
out Vector2 normalizedPos)
{
normalizedPos = matrix * position;
}
public virtual bool IsText(Graphic graphic)
{
return false;
}
public virtual void SetExtraChannel(ref UIVertex vertex, Vector2 value)
{
}
}
}
@@ -1,8 +1,7 @@
fileFormatVersion: 2
guid: 70261fa2760d4c040ac28aebb1f155fb
timeCreated: 1528297353
licenseType: Free
guid: 1fa123391c81f40ffbbe761447b7913c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
@@ -0,0 +1,70 @@
using UnityEngine;
using UnityEngine.UI;
namespace Coffee.UIExtensions
{
public class GraphicConnector : BaseConnector
{
#if UNITY_EDITOR
[UnityEditor.InitializeOnLoadMethod]
#endif
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
private static void Init()
{
AddConnector(new GraphicConnector());
}
protected override int priority
{
get { return 0; }
}
public override Material GetMaterial(Graphic graphic)
{
return graphic ? graphic.material : null;
}
public override void SetMaterial(Graphic graphic, Material material)
{
if (graphic)
graphic.material = material;
}
public override AdditionalCanvasShaderChannels extraChannel
{
get { return AdditionalCanvasShaderChannels.TexCoord1; }
}
public override Shader FindShader(string shaderName)
{
return Shader.Find("Hidden/" + shaderName);
}
protected override bool IsValid(Graphic graphic)
{
return graphic;
}
public override void SetVerticesDirty(Graphic graphic)
{
if (graphic)
graphic.SetVerticesDirty();
}
public override void SetMaterialDirty(Graphic graphic)
{
if (graphic)
graphic.SetMaterialDirty();
}
public override bool IsText(Graphic graphic)
{
return graphic && graphic is Text;
}
public override void SetExtraChannel(ref UIVertex vertex, Vector2 value)
{
vertex.uv1 = value;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 66636f82e05e6453781a33c8b7da8b93
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -1,9 +1,8 @@
fileFormatVersion: 2
guid: ee1bfc8c299e6482cb7175ba2f94495a
folderAsset: yes
timeCreated: 1487152270
licenseType: Pro
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,74 @@
#if !UNITY_2019_1_OR_NEWER
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using UnityEditor;
namespace Coffee.UIExtensions
{
public static class ImportSampleMenu_UIEffect
{
[MenuItem("Assets/Samples/Import UIEffect Sample")]
private static void ImportSample()
{
const string jsonGuid = "546af75b6221c4768be79d67c9cea1fb";
ImportSample(jsonGuid, "Demo");
}
private static void ImportSample(string jsonGuid, string sampleName)
{
var jsonPath = AssetDatabase.GUIDToAssetPath(jsonGuid);
var json = File.ReadAllText(jsonPath);
var version = Regex.Match(json, "\"version\"\\s*:\\s*\"([^\"]+)\"").Groups[1].Value;
var displayName = Regex.Match(json, "\"displayName\"\\s*:\\s*\"([^\"]+)\"").Groups[1].Value;
var src = string.Format("{0}/Samples~/{1}", Path.GetDirectoryName(jsonPath), sampleName);
var srcAlt = string.Format("{0}/Samples/{1}", Path.GetDirectoryName(jsonPath), sampleName);
var dst = string.Format("Assets/Samples/{0}/{1}/{2}", displayName, version, sampleName);
var previousPath = GetPreviousSamplePath(displayName, sampleName);
// Remove the previous sample directory.
if (!string.IsNullOrEmpty(previousPath))
{
var msg = "A different version of the sample is already imported at\n\n"
+ previousPath
+ "\n\nIt will be deleted when you update. Are you sure you want to continue?";
if (!EditorUtility.DisplayDialog("Sample Importer", msg, "OK", "Cancel"))
return;
FileUtil.DeleteFileOrDirectory(previousPath);
var metaFile = previousPath + ".meta";
if (File.Exists(metaFile))
FileUtil.DeleteFileOrDirectory(metaFile);
}
if (!Directory.Exists(dst))
FileUtil.DeleteFileOrDirectory(dst);
var dstDir = Path.GetDirectoryName(dst);
if (!Directory.Exists(dstDir))
Directory.CreateDirectory(dstDir);
if (Directory.Exists(src))
FileUtil.CopyFileOrDirectory(src, dst);
else if (Directory.Exists(srcAlt))
FileUtil.CopyFileOrDirectory(srcAlt, dst);
else
throw new DirectoryNotFoundException(src);
AssetDatabase.ImportAsset(dst, ImportAssetOptions.ImportRecursive);
}
private static string GetPreviousSamplePath(string displayName, string sampleName)
{
var sampleRoot = string.Format("Assets/Samples/{0}", displayName);
var sampleRootInfo = new DirectoryInfo(sampleRoot);
if (!sampleRootInfo.Exists) return null;
return sampleRootInfo.GetDirectories()
.Select(versionDir => Path.Combine(versionDir.ToString(), sampleName))
.FirstOrDefault(Directory.Exists);
}
}
}
#endif
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: f1d002a431e7c4b1ca5db78469cb0d1c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -4,33 +4,34 @@ using UnityEngine;
namespace Coffee.UIExtensions.Editors
{
/// <summary>
/// Changes in this scope cause the graphic's material to be dirty.
/// </summary>
internal class MaterialDirtyScope : EditorGUI.ChangeCheckScope
{
readonly Object [] targets;
/// <summary>
/// Changes in this scope cause the graphic's material to be dirty.
/// When you change a property, it marks the material as dirty.
/// </summary>
internal class MaterialDirtyScope : EditorGUI.ChangeCheckScope
{
readonly Object[] targets;
public MaterialDirtyScope (Object [] targets)
{
this.targets = targets;
}
public MaterialDirtyScope(Object[] targets)
{
this.targets = targets;
}
protected override void CloseScope ()
{
if (changed)
{
var graphics = targets.OfType<UIEffectBase> ()
.Select (x => x.targetGraphic)
.Where (x => x);
protected override void CloseScope()
{
if (changed)
{
var graphics = targets.OfType<BaseMaterialEffect>()
.Select(x => x.graphic)
.Where(x => x);
foreach (var g in graphics)
{
g.SetMaterialDirty ();
}
}
foreach (var g in graphics)
{
BaseConnector.FindConnector(g).SetMaterialDirty(g);
}
}
base.CloseScope ();
}
}
}
base.CloseScope();
}
}
}
@@ -7,135 +7,115 @@ using UnityEngine.UI;
namespace Coffee.UIExtensions.Editors
{
/// <summary>
/// UIEffect editor.
/// </summary>
[CustomEditor(typeof(UIDissolve))]
[CanEditMultipleObjects]
public class UIDissolveEditor : BaseMeshEffectEditor
{
static int s_NoiseTexId;
/// <summary>
/// UIEffect editor.
/// </summary>
[CustomEditor(typeof(UIDissolve))]
[CanEditMultipleObjects]
public class UIDissolveEditor : Editor
{
SerializedProperty _spEffectFactor;
SerializedProperty _spWidth;
SerializedProperty _spColor;
SerializedProperty _spSoftness;
SerializedProperty _spColorMode;
SerializedProperty _spTransitionTexture;
SerializedProperty _spEffectArea;
SerializedProperty _spKeepAspectRatio;
SerializedProperty _spReverse;
SerializedProperty _spPlay;
SerializedProperty _spLoop;
SerializedProperty _spLoopDelay;
SerializedProperty _spDuration;
SerializedProperty _spInitialPlayDelay;
SerializedProperty _spUpdateMode;
//################################
// Public/Protected Members.
//################################
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected override void OnEnable()
{
base.OnEnable ();
//################################
// Public/Protected Members.
//################################
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected void OnEnable()
{
_spEffectFactor = serializedObject.FindProperty("m_EffectFactor");
_spEffectArea = serializedObject.FindProperty("m_EffectArea");
_spKeepAspectRatio = serializedObject.FindProperty("m_KeepAspectRatio");
_spWidth = serializedObject.FindProperty("m_Width");
_spColor = serializedObject.FindProperty("m_Color");
_spSoftness = serializedObject.FindProperty("m_Softness");
_spColorMode = serializedObject.FindProperty("m_ColorMode");
_spTransitionTexture = serializedObject.FindProperty("m_TransitionTexture");
_spKeepAspectRatio = serializedObject.FindProperty("m_KeepAspectRatio");
_spReverse = serializedObject.FindProperty("m_Reverse");
var player = serializedObject.FindProperty("m_Player");
_spPlay = player.FindPropertyRelative("play");
_spDuration = player.FindPropertyRelative("duration");
_spInitialPlayDelay = player.FindPropertyRelative("initialPlayDelay");
_spLoop = player.FindPropertyRelative("loop");
_spLoopDelay = player.FindPropertyRelative("loopDelay");
_spUpdateMode = player.FindPropertyRelative("updateMode");
}
_spMaterial = serializedObject.FindProperty("m_EffectMaterial");
_spEffectFactor = serializedObject.FindProperty("m_EffectFactor");
_spEffectArea = serializedObject.FindProperty("m_EffectArea");
_spKeepAspectRatio = serializedObject.FindProperty("m_KeepAspectRatio");
_spWidth = serializedObject.FindProperty("m_Width");
_spColor = serializedObject.FindProperty("m_Color");
_spSoftness = serializedObject.FindProperty("m_Softness");
_spColorMode = serializedObject.FindProperty("m_ColorMode");
_spNoiseTexture = serializedObject.FindProperty("m_NoiseTexture");
_spKeepAspectRatio = serializedObject.FindProperty("m_KeepAspectRatio");
_spReverse = serializedObject.FindProperty("m_Reverse");
var player = serializedObject.FindProperty("m_Player");
_spPlay = player.FindPropertyRelative("play");
_spDuration = player.FindPropertyRelative("duration");
_spInitialPlayDelay = player.FindPropertyRelative("initialPlayDelay");
_spLoop = player.FindPropertyRelative("loop");
_spLoopDelay = player.FindPropertyRelative("loopDelay");
_spUpdateMode = player.FindPropertyRelative("updateMode");
/// <summary>
/// Implement this function to make a custom inspector.
/// </summary>
public override void OnInspectorGUI()
{
serializedObject.Update();
s_NoiseTexId = Shader.PropertyToID ("_NoiseTex");
//================
// Effect setting.
//================
EditorGUILayout.PropertyField(_spEffectFactor);
EditorGUILayout.PropertyField(_spWidth);
EditorGUILayout.PropertyField(_spSoftness);
EditorGUILayout.PropertyField(_spColor);
_shader = Shader.Find ("TextMeshPro/Distance Field (UIDissolve)");
_mobileShader = Shader.Find ("TextMeshPro/Mobile/Distance Field (UIDissolve)");
_spriteShader = Shader.Find ("TextMeshPro/Sprite (UIDissolve)");
}
using (new MaterialDirtyScope(targets))
{
EditorGUILayout.PropertyField(_spColorMode);
EditorGUILayout.PropertyField(_spTransitionTexture);
}
/// <summary>
/// Implement this function to make a custom inspector.
/// </summary>
public override void OnInspectorGUI()
{
serializedObject.Update();
//================
// Advanced option.
//================
EditorGUILayout.PropertyField(_spEffectArea);
EditorGUILayout.PropertyField(_spKeepAspectRatio);
//================
// Effect setting.
//================
EditorGUILayout.PropertyField(_spEffectFactor);
EditorGUILayout.PropertyField(_spWidth);
EditorGUILayout.PropertyField(_spSoftness);
EditorGUILayout.PropertyField(_spColor);
using (new MaterialDirtyScope (targets))
{
EditorGUILayout.PropertyField (_spColorMode);
EditorGUILayout.PropertyField (_spNoiseTexture);
}
//================
// Effect player.
//================
EditorGUILayout.PropertyField(_spPlay);
EditorGUILayout.PropertyField(_spDuration);
EditorGUILayout.PropertyField(_spInitialPlayDelay);
EditorGUILayout.PropertyField(_spLoop);
EditorGUILayout.PropertyField(_spLoopDelay);
EditorGUILayout.PropertyField(_spUpdateMode);
EditorGUILayout.PropertyField(_spReverse);
//================
// Advanced option.
//================
EditorGUILayout.PropertyField(_spEffectArea);
EditorGUILayout.PropertyField(_spKeepAspectRatio);
//================
// Effect player.
//================
EditorGUILayout.PropertyField(_spPlay);
EditorGUILayout.PropertyField(_spDuration);
EditorGUILayout.PropertyField(_spInitialPlayDelay);
EditorGUILayout.PropertyField(_spLoop);
EditorGUILayout.PropertyField(_spLoopDelay);
EditorGUILayout.PropertyField(_spUpdateMode);
EditorGUILayout.PropertyField(_spReverse);
// Debug.
using (new EditorGUI.DisabledGroupScope(!Application.isPlaying))
using (new EditorGUILayout.HorizontalScope(EditorStyles.helpBox))
{
GUILayout.Label("Debug");
// Debug.
using (new EditorGUI.DisabledGroupScope(!Application.isPlaying))
using (new EditorGUILayout.HorizontalScope(EditorStyles.helpBox))
{
GUILayout.Label("Debug");
if (GUILayout.Button("Play", "ButtonLeft"))
{
(target as UIDissolve).Play();
}
if (GUILayout.Button("Play", "ButtonLeft"))
{
(target as UIDissolve).Play();
}
if (GUILayout.Button("Stop", "ButtonRight"))
{
(target as UIDissolve).Stop();
}
}
if (GUILayout.Button("Stop", "ButtonRight"))
{
(target as UIDissolve).Stop();
}
}
ShowCanvasChannelsWarning ();
serializedObject.ApplyModifiedProperties();
}
//################################
// Private Members.
//################################
SerializedProperty _spMaterial;
SerializedProperty _spEffectFactor;
SerializedProperty _spWidth;
SerializedProperty _spColor;
SerializedProperty _spSoftness;
SerializedProperty _spColorMode;
SerializedProperty _spNoiseTexture;
SerializedProperty _spEffectArea;
SerializedProperty _spKeepAspectRatio;
SerializedProperty _spReverse;
SerializedProperty _spPlay;
SerializedProperty _spLoop;
SerializedProperty _spLoopDelay;
SerializedProperty _spDuration;
SerializedProperty _spInitialPlayDelay;
SerializedProperty _spUpdateMode;
Shader _shader;
Shader _mobileShader;
Shader _spriteShader;
}
serializedObject.ApplyModifiedProperties();
}
}
}
@@ -6,147 +6,112 @@ using System;
namespace Coffee.UIExtensions.Editors
{
/// <summary>
/// UIEffect editor.
/// </summary>
[CustomEditor(typeof(UIEffect))]
[CanEditMultipleObjects]
public class UIEffectEditor : BaseMeshEffectEditor
{
static readonly GUIContent contentEffectColor = new GUIContent ("Effect Color");
/// <summary>
/// UIEffect editor.
/// </summary>
[CustomEditor(typeof(UIEffect))]
[CanEditMultipleObjects]
public class UIEffectEditor : Editor
{
SerializedProperty _spEffectMode;
SerializedProperty _spEffectFactor;
SerializedProperty _spColorMode;
SerializedProperty _spEffectColor;
SerializedProperty _spColorFactor;
SerializedProperty _spBlurMode;
SerializedProperty _spBlurFactor;
SerializedProperty _spAdvancedBlur;
//################################
// Public/Protected Members.
//################################
protected void OnEnable()
{
_spEffectMode = serializedObject.FindProperty("m_EffectMode");
_spEffectFactor = serializedObject.FindProperty("m_EffectFactor");
_spColorMode = serializedObject.FindProperty("m_ColorMode");
_spEffectColor = serializedObject.FindProperty("m_EffectColor");
_spColorFactor = serializedObject.FindProperty("m_ColorFactor");
_spBlurMode = serializedObject.FindProperty("m_BlurMode");
_spBlurFactor = serializedObject.FindProperty("m_BlurFactor");
_spAdvancedBlur = serializedObject.FindProperty("m_AdvancedBlur");
}
/// <summary>
/// Draw effect properties.
/// </summary>
public static void DrawEffectProperties(SerializedObject serializedObject, string colorProperty = "m_Color")
{
//================
// Effect setting.
//================
var spToneMode = serializedObject.FindProperty("m_EffectMode");
EditorGUILayout.PropertyField(spToneMode);
public override void OnInspectorGUI()
{
//================
// Effect setting.
//================
using (new MaterialDirtyScope(targets))
EditorGUILayout.PropertyField(_spEffectMode);
// When tone is enable, show parameters.
if (spToneMode.intValue != (int)EffectMode.None)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_EffectFactor"));
EditorGUI.indentLevel--;
}
// When effect is enable, show parameters.
if (_spEffectMode.intValue != (int) EffectMode.None)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(_spEffectFactor);
EditorGUI.indentLevel--;
}
//================
// Color setting.
//================
var spColorMode = serializedObject.FindProperty("m_ColorMode");
EditorGUILayout.PropertyField(spColorMode);
// When color is enable, show parameters.
//if (spColorMode.intValue != (int)ColorMode.Multiply)
{
EditorGUI.indentLevel++;
//================
// Color setting.
//================
using (new MaterialDirtyScope(targets))
EditorGUILayout.PropertyField(_spColorMode);
SerializedProperty spColor = serializedObject.FindProperty(colorProperty);
if (spColor == null && serializedObject.targetObject is UIEffect) {
spColor = new SerializedObject (serializedObject.targetObjects.Select(x=>(x as UIEffect).targetGraphic).ToArray()).FindProperty(colorProperty);
}
// When color is enable, show parameters.
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(_spEffectColor);
EditorGUILayout.PropertyField(_spColorFactor);
EditorGUI.indentLevel--;
}
EditorGUI.BeginChangeCheck ();
EditorGUI.showMixedValue = spColor.hasMultipleDifferentValues;
#if UNITY_2018_1_OR_NEWER
spColor.colorValue = EditorGUILayout.ColorField (contentEffectColor, spColor.colorValue, true, false, false);
#else
spColor.colorValue = EditorGUILayout.ColorField (contentEffectColor, spColor.colorValue, true, false, false, null);
#endif
if (EditorGUI.EndChangeCheck ()) {
spColor.serializedObject.ApplyModifiedProperties ();
}
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_ColorFactor"));
EditorGUI.indentLevel--;
}
//================
// Blur setting.
//================
using (new MaterialDirtyScope(targets))
EditorGUILayout.PropertyField(_spBlurMode);
//================
// Blur setting.
//================
var spBlurMode = serializedObject.FindProperty("m_BlurMode");
EditorGUILayout.PropertyField(spBlurMode);
// When blur is enable, show parameters.
if (_spBlurMode.intValue != (int) BlurMode.None)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(_spBlurFactor);
// When blur is enable, show parameters.
if (spBlurMode.intValue != (int)BlurMode.None)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_BlurFactor"));
// When you change a property, it marks the material as dirty.
using (new MaterialDirtyScope(targets))
EditorGUILayout.PropertyField(_spAdvancedBlur);
EditorGUI.indentLevel--;
var spAdvancedBlur = serializedObject.FindProperty("m_AdvancedBlur");
if (spAdvancedBlur != null)
{
EditorGUILayout.PropertyField(spAdvancedBlur);
}
EditorGUI.indentLevel--;
}
}
// Advanced blur requires uv2 channel.
if (_spAdvancedBlur.boolValue)
{
ShowCanvasChannelsWarning();
}
}
/// <summary>
/// Implement this function to make a custom inspector.
/// </summary>
public override void OnInspectorGUI()
{
//================
// Effect setting.
//================
var spToneMode = serializedObject.FindProperty("m_EffectMode");
using (new MaterialDirtyScope (targets))
EditorGUILayout.PropertyField(spToneMode);
serializedObject.ApplyModifiedProperties();
}
// When tone is enable, show parameters.
if (spToneMode.intValue != (int)EffectMode.None)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_EffectFactor"));
EditorGUI.indentLevel--;
}
void ShowCanvasChannelsWarning()
{
var effect = target as UIEffect;
if (effect == null || !effect.graphic) return;
//================
// Color setting.
//================
var spColorMode = serializedObject.FindProperty("m_ColorMode");
using (new MaterialDirtyScope (targets))
EditorGUILayout.PropertyField(spColorMode);
var channel = effect.uvMaskChannel;
var canvas = effect.graphic.canvas;
if (canvas == null || (canvas.additionalShaderChannels & channel) == channel) return;
// When color is enable, show parameters.
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField (serializedObject.FindProperty ("m_EffectColor"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_ColorFactor"));
EditorGUI.indentLevel--;
}
//================
// Blur setting.
//================
var spBlurMode = serializedObject.FindProperty("m_BlurMode");
using (new MaterialDirtyScope (targets))
EditorGUILayout.PropertyField(spBlurMode);
// When blur is enable, show parameters.
if (spBlurMode.intValue != (int)BlurMode.None)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_BlurFactor"));
var spAdvancedBlur = serializedObject.FindProperty("m_AdvancedBlur");
using (new MaterialDirtyScope (targets))
EditorGUILayout.PropertyField(spAdvancedBlur);
EditorGUI.indentLevel--;
}
ShowCanvasChannelsWarning ();
serializedObject.ApplyModifiedProperties();
}
}
EditorGUILayout.BeginHorizontal();
{
var msg = string.Format("Enable '{0}' of Canvas.additionalShaderChannels to use 'UIEffect'.", channel);
EditorGUILayout.HelpBox(msg, MessageType.Warning);
if (GUILayout.Button("Fix"))
{
canvas.additionalShaderChannels |= channel;
}
}
EditorGUILayout.EndHorizontal();
}
}
}
@@ -4,99 +4,137 @@ using UnityEngine.UI;
namespace Coffee.UIExtensions.Editors
{
/// <summary>
/// UIEffect editor.
/// </summary>
[CustomEditor(typeof(UIGradient))]
[CanEditMultipleObjects]
public class UIGradientEditor : Editor
{
public override void OnInspectorGUI()
{
serializedObject.Update();
/// <summary>
/// UIEffect editor.
/// </summary>
[CustomEditor(typeof(UIGradient))]
[CanEditMultipleObjects]
public class UIGradientEditor : Editor
{
private static readonly GUIContent k_TextVerticalOffset = new GUIContent("Vertical Offset");
private static readonly GUIContent k_TextHorizontalOffset = new GUIContent("Horizontal Offset");
private static readonly GUIContent k_TextOffset = new GUIContent("Offset");
private static readonly GUIContent k_TextLeft = new GUIContent("Left");
private static readonly GUIContent k_TextRight = new GUIContent("Right");
private static readonly GUIContent k_TextTop = new GUIContent("Top");
private static readonly GUIContent k_TextBottom = new GUIContent("Bottom");
private static readonly GUIContent k_TextColor1 = new GUIContent("Color 1");
private static readonly GUIContent k_TextColor2 = new GUIContent("Color 2");
private static readonly GUIContent k_TextDiagonalColor = new GUIContent("Diagonal Color");
//================
// Direction.
//================
var spDirection = serializedObject.FindProperty("m_Direction");
EditorGUILayout.PropertyField(spDirection);
SerializedProperty _spDirection;
SerializedProperty _spColor1;
SerializedProperty _spColor2;
SerializedProperty _spColor3;
SerializedProperty _spColor4;
SerializedProperty _spRotation;
SerializedProperty _spOffset1;
SerializedProperty _spOffset2;
SerializedProperty _spIgnoreAspectRatio;
SerializedProperty _spGradientStyle;
SerializedProperty _spColorSpace;
//################################
// Public/Protected Members.
//################################
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected void OnEnable()
{
_spIgnoreAspectRatio = serializedObject.FindProperty("m_IgnoreAspectRatio");
_spDirection = serializedObject.FindProperty("m_Direction");
_spColor1 = serializedObject.FindProperty("m_Color1");
_spColor2 = serializedObject.FindProperty("m_Color2");
_spColor3 = serializedObject.FindProperty("m_Color3");
_spColor4 = serializedObject.FindProperty("m_Color4");
_spRotation = serializedObject.FindProperty("m_Rotation");
_spOffset1 = serializedObject.FindProperty("m_Offset1");
_spOffset2 = serializedObject.FindProperty("m_Offset2");
_spGradientStyle = serializedObject.FindProperty("m_GradientStyle");
_spColorSpace = serializedObject.FindProperty("m_ColorSpace");
}
public override void OnInspectorGUI()
{
serializedObject.Update();
//================
// Direction.
//================
EditorGUILayout.PropertyField(_spDirection);
//================
// Color.
//================
var spColor1 = serializedObject.FindProperty("m_Color1");
var spColor2 = serializedObject.FindProperty("m_Color2");
var spColor3 = serializedObject.FindProperty("m_Color3");
var spColor4 = serializedObject.FindProperty("m_Color4");
switch ((UIGradient.Direction)spDirection.intValue)
{
case UIGradient.Direction.Horizontal:
EditorGUILayout.PropertyField(spColor1, new GUIContent("Left"));
EditorGUILayout.PropertyField(spColor2, new GUIContent("Right"));
break;
case UIGradient.Direction.Vertical:
EditorGUILayout.PropertyField(spColor1, new GUIContent("Top"));
EditorGUILayout.PropertyField(spColor2, new GUIContent("Bottom"));
break;
case UIGradient.Direction.Angle:
EditorGUILayout.PropertyField(spColor1, new GUIContent("Color 1"));
EditorGUILayout.PropertyField(spColor2, new GUIContent("Color 2"));
break;
case UIGradient.Direction.Diagonal:
Rect r = EditorGUILayout.GetControlRect(false, 34);
//================
// Color.
//================
switch ((UIGradient.Direction) _spDirection.intValue)
{
case UIGradient.Direction.Horizontal:
EditorGUILayout.PropertyField(_spColor1, k_TextLeft);
EditorGUILayout.PropertyField(_spColor2, k_TextRight);
break;
case UIGradient.Direction.Vertical:
EditorGUILayout.PropertyField(_spColor1, k_TextTop);
EditorGUILayout.PropertyField(_spColor2, k_TextBottom);
break;
case UIGradient.Direction.Angle:
EditorGUILayout.PropertyField(_spColor1, k_TextColor1);
EditorGUILayout.PropertyField(_spColor2, k_TextColor2);
break;
case UIGradient.Direction.Diagonal:
Rect r = EditorGUILayout.GetControlRect(false, 34);
r = EditorGUI.PrefixLabel(r, new GUIContent("Diagonal Color"));
float w = r.width / 2;
r = EditorGUI.PrefixLabel(r, k_TextDiagonalColor);
float w = r.width / 2;
EditorGUI.PropertyField(new Rect(r.x, r.y, w, 16), spColor3, GUIContent.none);
EditorGUI.PropertyField(new Rect(r.x + w, r.y, w, 16), spColor4, GUIContent.none);
EditorGUI.PropertyField(new Rect(r.x, r.y + 18, w, 16), spColor1, GUIContent.none);
EditorGUI.PropertyField(new Rect(r.x + w, r.y + 18, w, 16), spColor2, GUIContent.none);
break;
}
EditorGUI.PropertyField(new Rect(r.x, r.y, w, 16), _spColor3, GUIContent.none);
EditorGUI.PropertyField(new Rect(r.x + w, r.y, w, 16), _spColor4, GUIContent.none);
EditorGUI.PropertyField(new Rect(r.x, r.y + 18, w, 16), _spColor1, GUIContent.none);
EditorGUI.PropertyField(new Rect(r.x + w, r.y + 18, w, 16), _spColor2, GUIContent.none);
break;
}
//================
// Angle.
//================
if ((int)UIGradient.Direction.Angle <= spDirection.intValue)
{
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_Rotation"));
}
//================
// Angle.
//================
if ((int) UIGradient.Direction.Angle <= _spDirection.intValue)
{
EditorGUILayout.PropertyField(_spRotation);
}
//================
// Offset.
//================
if ((int)UIGradient.Direction.Diagonal == spDirection.intValue)
{
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_Offset1"), new GUIContent("Vertical Offset"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_Offset2"), new GUIContent("Horizontal Offset"));
}
else
{
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_Offset1"), new GUIContent("Offset"));
}
//================
// Offset.
//================
if ((int) UIGradient.Direction.Diagonal == _spDirection.intValue)
{
EditorGUILayout.PropertyField(_spOffset1, k_TextVerticalOffset);
EditorGUILayout.PropertyField(_spOffset2, k_TextHorizontalOffset);
}
else
{
EditorGUILayout.PropertyField(_spOffset1, k_TextOffset);
}
//================
// Advanced options.
//================
EditorGUILayout.Space();
EditorGUILayout.LabelField("Advanced Options", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
{
//if ((target as UIGradient).targetGraphic is Text)
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_GradientStyle"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_ColorSpace"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_IgnoreAspectRatio"));
}
EditorGUI.indentLevel--;
//================
// Advanced options.
//================
EditorGUILayout.Space();
EditorGUILayout.LabelField("Advanced Options", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
{
//if ((target as UIGradient).targetGraphic is Text)
EditorGUILayout.PropertyField(_spGradientStyle);
serializedObject.ApplyModifiedProperties();
EditorGUILayout.PropertyField(_spColorSpace);
EditorGUILayout.PropertyField(_spIgnoreAspectRatio);
}
EditorGUI.indentLevel--;
}
}
serializedObject.ApplyModifiedProperties();
}
}
}
@@ -5,59 +5,49 @@ using System.Linq;
namespace Coffee.UIExtensions.Editors
{
/// <summary>
/// UIEffect editor.
/// </summary>
[CustomEditor(typeof(UIHsvModifier))]
[CanEditMultipleObjects]
public class UIHsvModifierEditor : BaseMeshEffectEditor
{
//################################
// Public/Protected Members.
//################################
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected override void OnEnable()
{
base.OnEnable ();
/// <summary>
/// UIEffect editor.
/// </summary>
[CustomEditor(typeof(UIHsvModifier))]
[CanEditMultipleObjects]
public class UIHsvModifierEditor : Editor
{
SerializedProperty _spTargetColor;
SerializedProperty _spRange;
SerializedProperty _spHue;
SerializedProperty _spSaturation;
SerializedProperty _spValue;
_spTargetColor = serializedObject.FindProperty("m_TargetColor");
_spRange = serializedObject.FindProperty("m_Range");
_spHue = serializedObject.FindProperty("m_Hue");
_spSaturation = serializedObject.FindProperty("m_Saturation");
_spValue = serializedObject.FindProperty("m_Value");
}
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected void OnEnable()
{
_spTargetColor = serializedObject.FindProperty("m_TargetColor");
_spRange = serializedObject.FindProperty("m_Range");
_spHue = serializedObject.FindProperty("m_Hue");
_spSaturation = serializedObject.FindProperty("m_Saturation");
_spValue = serializedObject.FindProperty("m_Value");
}
/// <summary>
/// Implement this function to make a custom inspector.
/// </summary>
public override void OnInspectorGUI()
{
serializedObject.Update();
/// <summary>
/// Implement this function to make a custom inspector.
/// </summary>
public override void OnInspectorGUI()
{
serializedObject.Update();
//================
// Effect setting.
//================
EditorGUILayout.PropertyField(_spTargetColor);
EditorGUILayout.PropertyField(_spRange);
EditorGUILayout.PropertyField(_spHue);
EditorGUILayout.PropertyField(_spSaturation);
EditorGUILayout.PropertyField(_spValue);
//================
// Effect setting.
//================
EditorGUILayout.PropertyField(_spTargetColor);
EditorGUILayout.PropertyField(_spRange);
EditorGUILayout.PropertyField(_spHue);
EditorGUILayout.PropertyField(_spSaturation);
EditorGUILayout.PropertyField(_spValue);
ShowCanvasChannelsWarning ();
serializedObject.ApplyModifiedProperties();
}
//################################
// Private Members.
//################################
SerializedProperty _spTargetColor;
SerializedProperty _spRange;
SerializedProperty _spHue;
SerializedProperty _spSaturation;
SerializedProperty _spValue;
}
serializedObject.ApplyModifiedProperties();
}
}
}
@@ -4,51 +4,59 @@ using UnityEngine;
namespace Coffee.UIExtensions.Editors
{
/// <summary>
/// UIShadow editor.
/// </summary>
[CustomEditor(typeof(UIShadow))]
[CanEditMultipleObjects]
public class UIShadowEditor : Editor
{
UIEffect uiEffect;
/// <summary>
/// UIShadow editor.
/// </summary>
[CustomEditor(typeof(UIShadow))]
[CanEditMultipleObjects]
public class UIShadowEditor : Editor
{
UIEffect uiEffect;
SerializedProperty _spStyle;
SerializedProperty _spEffectDistance;
SerializedProperty _spEffectColor;
SerializedProperty _spUseGraphicAlpha;
SerializedProperty _spBlurFactor;
void OnEnable()
{
uiEffect = (target as UIShadow).GetComponent<UIEffect>();
void OnEnable()
{
uiEffect = (target as UIShadow).GetComponent<UIEffect>();
_spStyle = serializedObject.FindProperty("m_Style");
_spEffectDistance = serializedObject.FindProperty("m_EffectDistance");
_spEffectColor = serializedObject.FindProperty("m_EffectColor");
_spUseGraphicAlpha = serializedObject.FindProperty("m_UseGraphicAlpha");
_spBlurFactor = serializedObject.FindProperty("m_BlurFactor");
}
}
/// <summary>
/// Implement this function to make a custom inspector.
/// </summary>
public override void OnInspectorGUI()
{
serializedObject.Update();
//================
// Shadow setting.
//================
EditorGUILayout.PropertyField(_spStyle);
/// <summary>
/// Implement this function to make a custom inspector.
/// </summary>
public override void OnInspectorGUI()
{
serializedObject.Update();
// When shadow is enable, show parameters.
if (_spStyle.intValue != (int) ShadowStyle.None)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(_spEffectDistance);
EditorGUILayout.PropertyField(_spEffectColor);
EditorGUILayout.PropertyField(_spUseGraphicAlpha);
//================
// Shadow setting.
//================
var spShadowMode = serializedObject.FindProperty("m_Style");
EditorGUILayout.PropertyField(spShadowMode);
if (uiEffect && uiEffect.blurMode != BlurMode.None)
{
EditorGUILayout.PropertyField(_spBlurFactor);
}
// When shadow is enable, show parameters.
if (spShadowMode.intValue != (int)ShadowStyle.None)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_EffectDistance"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_EffectColor"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_UseGraphicAlpha"));
EditorGUI.indentLevel--;
}
if (uiEffect && uiEffect.blurMode != BlurMode.None)
{
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_BlurFactor"));
}
EditorGUI.indentLevel--;
}
serializedObject.ApplyModifiedProperties();
}
}
}
serializedObject.ApplyModifiedProperties();
}
}
}
@@ -5,109 +5,98 @@ using System.Linq;
namespace Coffee.UIExtensions.Editors
{
/// <summary>
/// UIEffect editor.
/// </summary>
[CustomEditor(typeof(UIShiny))]
[CanEditMultipleObjects]
public class UIShinyEditor : BaseMeshEffectEditor
{
//################################
// Public/Protected Members.
//################################
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected override void OnEnable()
{
base.OnEnable ();
/// <summary>
/// UIEffect editor.
/// </summary>
[CustomEditor(typeof(UIShiny))]
[CanEditMultipleObjects]
public class UIShinyEditor : Editor
{
SerializedProperty _spEffectFactor;
SerializedProperty _spWidth;
SerializedProperty _spRotation;
SerializedProperty _spSoftness;
SerializedProperty _spBrightness;
SerializedProperty _spGloss;
SerializedProperty _spEffectArea;
SerializedProperty _spPlay;
SerializedProperty _spLoop;
SerializedProperty _spLoopDelay;
SerializedProperty _spDuration;
SerializedProperty _spInitialPlayDelay;
SerializedProperty _spUpdateMode;
_spEffectFactor = serializedObject.FindProperty("m_EffectFactor");
_spEffectArea = serializedObject.FindProperty("m_EffectArea");
_spWidth = serializedObject.FindProperty("m_Width");
_spRotation = serializedObject.FindProperty("m_Rotation");
_spSoftness = serializedObject.FindProperty("m_Softness");
_spBrightness = serializedObject.FindProperty("m_Brightness");
_spGloss = serializedObject.FindProperty("m_Gloss");
var player = serializedObject.FindProperty("m_Player");
_spPlay = player.FindPropertyRelative("play");
_spDuration = player.FindPropertyRelative("duration");
_spInitialPlayDelay = player.FindPropertyRelative("initialPlayDelay");
_spLoop = player.FindPropertyRelative("loop");
_spLoopDelay = player.FindPropertyRelative("loopDelay");
_spUpdateMode = player.FindPropertyRelative("updateMode");
}
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected void OnEnable()
{
_spEffectFactor = serializedObject.FindProperty("m_EffectFactor");
_spEffectArea = serializedObject.FindProperty("m_EffectArea");
_spWidth = serializedObject.FindProperty("m_Width");
_spRotation = serializedObject.FindProperty("m_Rotation");
_spSoftness = serializedObject.FindProperty("m_Softness");
_spBrightness = serializedObject.FindProperty("m_Brightness");
_spGloss = serializedObject.FindProperty("m_Gloss");
var player = serializedObject.FindProperty("m_Player");
_spPlay = player.FindPropertyRelative("play");
_spDuration = player.FindPropertyRelative("duration");
_spInitialPlayDelay = player.FindPropertyRelative("initialPlayDelay");
_spLoop = player.FindPropertyRelative("loop");
_spLoopDelay = player.FindPropertyRelative("loopDelay");
_spUpdateMode = player.FindPropertyRelative("updateMode");
}
/// <summary>
/// Implement this function to make a custom inspector.
/// </summary>
public override void OnInspectorGUI()
{
serializedObject.Update();
/// <summary>
/// Implement this function to make a custom inspector.
/// </summary>
public override void OnInspectorGUI()
{
serializedObject.Update();
//================
// Effect setting.
//================
EditorGUILayout.PropertyField(_spEffectFactor);
EditorGUILayout.PropertyField(_spWidth);
EditorGUILayout.PropertyField(_spRotation);
EditorGUILayout.PropertyField(_spSoftness);
EditorGUILayout.PropertyField(_spBrightness);
EditorGUILayout.PropertyField(_spGloss);
//================
// Effect setting.
//================
EditorGUILayout.PropertyField(_spEffectFactor);
EditorGUILayout.PropertyField(_spWidth);
EditorGUILayout.PropertyField(_spRotation);
EditorGUILayout.PropertyField(_spSoftness);
EditorGUILayout.PropertyField(_spBrightness);
EditorGUILayout.PropertyField(_spGloss);
//================
// Advanced option.
//================
EditorGUILayout.PropertyField(_spEffectArea);
//================
// Advanced option.
//================
EditorGUILayout.PropertyField(_spEffectArea);
//================
// Effect player.
//================
EditorGUILayout.PropertyField(_spPlay);
EditorGUILayout.PropertyField(_spDuration);
EditorGUILayout.PropertyField(_spInitialPlayDelay);
EditorGUILayout.PropertyField(_spLoop);
EditorGUILayout.PropertyField(_spLoopDelay);
EditorGUILayout.PropertyField(_spUpdateMode);
//================
// Effect player.
//================
EditorGUILayout.PropertyField(_spPlay);
EditorGUILayout.PropertyField(_spDuration);
EditorGUILayout.PropertyField(_spInitialPlayDelay);
EditorGUILayout.PropertyField(_spLoop);
EditorGUILayout.PropertyField(_spLoopDelay);
EditorGUILayout.PropertyField(_spUpdateMode);
// Debug.
using (new EditorGUI.DisabledGroupScope(!Application.isPlaying))
using (new EditorGUILayout.HorizontalScope(EditorStyles.helpBox))
{
GUILayout.Label("Debug");
// Debug.
using (new EditorGUI.DisabledGroupScope(!Application.isPlaying))
using (new EditorGUILayout.HorizontalScope(EditorStyles.helpBox))
{
GUILayout.Label("Debug");
if (GUILayout.Button("Play", "ButtonLeft"))
{
(target as UIShiny).Play();
}
if (GUILayout.Button("Play", "ButtonLeft"))
{
(target as UIShiny).Play();
}
if (GUILayout.Button("Stop", "ButtonRight"))
{
(target as UIShiny).Stop();
}
}
if (GUILayout.Button("Stop", "ButtonRight"))
{
(target as UIShiny).Stop();
}
}
ShowCanvasChannelsWarning ();
serializedObject.ApplyModifiedProperties();
}
//################################
// Private Members.
//################################
SerializedProperty _spEffectFactor;
SerializedProperty _spWidth;
SerializedProperty _spRotation;
SerializedProperty _spSoftness;
SerializedProperty _spBrightness;
SerializedProperty _spGloss;
SerializedProperty _spEffectArea;
SerializedProperty _spPlay;
SerializedProperty _spLoop;
SerializedProperty _spLoopDelay;
SerializedProperty _spDuration;
SerializedProperty _spInitialPlayDelay;
SerializedProperty _spUpdateMode;
}
serializedObject.ApplyModifiedProperties();
}
}
}
@@ -5,119 +5,111 @@ using System.Linq;
namespace Coffee.UIExtensions.Editors
{
/// <summary>
/// UIEffect editor.
/// </summary>
[CustomEditor(typeof(UITransitionEffect))]
[CanEditMultipleObjects]
public class UITransitionEffectEditor : BaseMeshEffectEditor
{
//################################
// Public/Protected Members.
//################################
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected override void OnEnable()
{
_spEffectMode = serializedObject.FindProperty("m_EffectMode");
_spEffectFactor = serializedObject.FindProperty("m_EffectFactor");
_spEffectArea = serializedObject.FindProperty("m_EffectArea");
_spKeepAspectRatio = serializedObject.FindProperty("m_KeepAspectRatio");
_spDissolveWidth = serializedObject.FindProperty("m_DissolveWidth");
_spDissolveSoftness = serializedObject.FindProperty("m_DissolveSoftness");
_spDissolveColor = serializedObject.FindProperty("m_DissolveColor");
_spTransitionTexture = serializedObject.FindProperty("m_TransitionTexture");
var player = serializedObject.FindProperty("m_Player");
_spPlay = player.FindPropertyRelative("play");
_spDuration = player.FindPropertyRelative("duration");
_spInitialPlayDelay = player.FindPropertyRelative("initialPlayDelay");
_spLoop = player.FindPropertyRelative("loop");
_spLoopDelay = player.FindPropertyRelative("loopDelay");
_spUpdateMode = player.FindPropertyRelative("updateMode");
_spPassRayOnHidden = serializedObject.FindProperty("m_PassRayOnHidden");
}
/// <summary>
/// UIEffect editor.
/// </summary>
[CustomEditor(typeof(UITransitionEffect))]
[CanEditMultipleObjects]
public class UITransitionEffectEditor : Editor
{
SerializedProperty _spEffectMode;
SerializedProperty _spEffectFactor;
SerializedProperty _spEffectArea;
SerializedProperty _spKeepAspectRatio;
SerializedProperty _spDissolveWidth;
SerializedProperty _spDissolveSoftness;
SerializedProperty _spDissolveColor;
SerializedProperty _spTransitionTexture;
SerializedProperty _spPlay;
SerializedProperty _spLoop;
SerializedProperty _spLoopDelay;
SerializedProperty _spDuration;
SerializedProperty _spInitialPlayDelay;
SerializedProperty _spUpdateMode;
SerializedProperty _spPassRayOnHidden;
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected void OnEnable()
{
_spEffectMode = serializedObject.FindProperty("m_EffectMode");
_spEffectFactor = serializedObject.FindProperty("m_EffectFactor");
_spEffectArea = serializedObject.FindProperty("m_EffectArea");
_spKeepAspectRatio = serializedObject.FindProperty("m_KeepAspectRatio");
_spDissolveWidth = serializedObject.FindProperty("m_DissolveWidth");
_spDissolveSoftness = serializedObject.FindProperty("m_DissolveSoftness");
_spDissolveColor = serializedObject.FindProperty("m_DissolveColor");
_spTransitionTexture = serializedObject.FindProperty("m_TransitionTexture");
var player = serializedObject.FindProperty("m_Player");
_spPlay = player.FindPropertyRelative("play");
_spDuration = player.FindPropertyRelative("duration");
_spInitialPlayDelay = player.FindPropertyRelative("initialPlayDelay");
_spLoop = player.FindPropertyRelative("loop");
_spLoopDelay = player.FindPropertyRelative("loopDelay");
_spUpdateMode = player.FindPropertyRelative("updateMode");
_spPassRayOnHidden = serializedObject.FindProperty("m_PassRayOnHidden");
}
/// <summary>
/// Implement this function to make a custom inspector.
/// </summary>
public override void OnInspectorGUI()
{
//================
// Effect setting.
//================
using (new MaterialDirtyScope(targets))
EditorGUILayout.PropertyField(_spEffectMode);
/// <summary>
/// Implement this function to make a custom inspector.
/// </summary>
public override void OnInspectorGUI()
{
//================
// Effect setting.
//================
using (new MaterialDirtyScope(targets))
EditorGUILayout.PropertyField(_spEffectMode);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(_spEffectFactor);
if (_spEffectMode.intValue == (int)UITransitionEffect.EffectMode.Dissolve)
{
EditorGUILayout.PropertyField(_spDissolveWidth);
EditorGUILayout.PropertyField(_spDissolveSoftness);
EditorGUILayout.PropertyField(_spDissolveColor);
}
EditorGUI.indentLevel--;
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(_spEffectFactor);
if (_spEffectMode.intValue == (int) UITransitionEffect.EffectMode.Dissolve)
{
EditorGUILayout.PropertyField(_spDissolveWidth);
EditorGUILayout.PropertyField(_spDissolveSoftness);
EditorGUILayout.PropertyField(_spDissolveColor);
}
//================
// Advanced option.
//================
EditorGUILayout.PropertyField(_spEffectArea);
using (new MaterialDirtyScope(targets))
EditorGUILayout.PropertyField(_spTransitionTexture);
EditorGUILayout.PropertyField(_spKeepAspectRatio);
EditorGUILayout.PropertyField(_spPassRayOnHidden);
EditorGUI.indentLevel--;
//================
// Effect player.
//================
EditorGUILayout.PropertyField(_spPlay);
EditorGUILayout.PropertyField(_spDuration);
EditorGUILayout.PropertyField(_spInitialPlayDelay);
EditorGUILayout.PropertyField(_spLoop);
EditorGUILayout.PropertyField(_spLoopDelay);
EditorGUILayout.PropertyField(_spUpdateMode);
//================
// Advanced option.
//================
EditorGUILayout.PropertyField(_spEffectArea);
using (new MaterialDirtyScope(targets))
EditorGUILayout.PropertyField(_spTransitionTexture);
EditorGUILayout.PropertyField(_spKeepAspectRatio);
EditorGUILayout.PropertyField(_spPassRayOnHidden);
// Debug.
using (new EditorGUI.DisabledGroupScope(!Application.isPlaying))
using (new EditorGUILayout.HorizontalScope(EditorStyles.helpBox))
{
GUILayout.Label("Debug");
//================
// Effect player.
//================
EditorGUILayout.PropertyField(_spPlay);
EditorGUILayout.PropertyField(_spDuration);
EditorGUILayout.PropertyField(_spInitialPlayDelay);
EditorGUILayout.PropertyField(_spLoop);
EditorGUILayout.PropertyField(_spLoopDelay);
EditorGUILayout.PropertyField(_spUpdateMode);
if (GUILayout.Button("Show", "ButtonLeft"))
{
(target as UITransitionEffect).Show();
}
// Debug.
using (new EditorGUI.DisabledGroupScope(!Application.isPlaying))
using (new EditorGUILayout.HorizontalScope(EditorStyles.helpBox))
{
GUILayout.Label("Debug");
if (GUILayout.Button("Hide", "ButtonRight"))
{
(target as UITransitionEffect).Hide();
}
}
if (GUILayout.Button("Show", "ButtonLeft"))
{
(target as UITransitionEffect).Show();
}
ShowCanvasChannelsWarning();
if (GUILayout.Button("Hide", "ButtonRight"))
{
(target as UITransitionEffect).Hide();
}
}
serializedObject.ApplyModifiedProperties();
}
//################################
// Private Members.
//################################
SerializedProperty _spEffectMode;
SerializedProperty _spEffectFactor;
SerializedProperty _spEffectArea;
SerializedProperty _spKeepAspectRatio;
SerializedProperty _spDissolveWidth;
SerializedProperty _spDissolveSoftness;
SerializedProperty _spDissolveColor;
SerializedProperty _spTransitionTexture;
SerializedProperty _spPlay;
SerializedProperty _spLoop;
SerializedProperty _spLoopDelay;
SerializedProperty _spDuration;
SerializedProperty _spInitialPlayDelay;
SerializedProperty _spUpdateMode;
SerializedProperty _spPassRayOnHidden;
}
serializedObject.ApplyModifiedProperties();
}
}
}
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 78cc1478fd16a484ba11857d5c4f4912
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -1,13 +1,13 @@
namespace Coffee.UIExtensions
{
/// <summary>
/// Blur effect mode.
/// </summary>
public enum BlurMode
{
None = 0,
FastBlur = 1,
MediumBlur = 2,
DetailBlur = 3,
}
}
/// <summary>
/// Blur effect mode.
/// </summary>
public enum BlurMode
{
None = 0,
FastBlur = 1,
MediumBlur = 2,
DetailBlur = 3,
}
}
@@ -1,13 +1,13 @@
namespace Coffee.UIExtensions
{
/// <summary>
/// Color effect mode.
/// </summary>
public enum ColorMode
{
Multiply = 0,
Fill = 1,
Add = 2,
Subtract = 3,
}
}
/// <summary>
/// Color effect mode.
/// </summary>
public enum ColorMode
{
Multiply = 0,
Fill = 1,
Add = 2,
Subtract = 3,
}
}
@@ -3,110 +3,114 @@ using UnityEngine.UI;
namespace Coffee.UIExtensions
{
/// <summary>
/// Area for effect.
/// </summary>
public enum EffectArea
{
RectTransform,
Fit,
Character,
}
/// <summary>
/// Area for effect.
/// </summary>
public enum EffectArea
{
RectTransform,
Fit,
Character,
}
public static class EffectAreaExtensions
{
static readonly Rect rectForCharacter = new Rect(0, 0, 1, 1);
static readonly Vector2 [] splitedCharacterPosition = { Vector2.up, Vector2.one, Vector2.right, Vector2.zero };
public static class EffectAreaExtensions
{
static readonly Rect rectForCharacter = new Rect(0, 0, 1, 1);
static readonly Vector2[] splitedCharacterPosition = {Vector2.up, Vector2.one, Vector2.right, Vector2.zero};
/// <summary>
/// Gets effect for area.
/// </summary>
public static Rect GetEffectArea (this EffectArea area, VertexHelper vh, Rect rectangle, float aspectRatio = -1)
{
Rect rect = default(Rect);
switch (area)
{
case EffectArea.RectTransform:
rect = rectangle;
break;
case EffectArea.Character:
rect = rectForCharacter;
break;
case EffectArea.Fit:
// Fit to contents.
UIVertex vertex = default (UIVertex);
float xMin = float.MaxValue;
float yMin = float.MaxValue;
float xMax = float.MinValue;
float yMax = float.MinValue;
for (int i = 0; i < vh.currentVertCount; i++)
{
vh.PopulateUIVertex(ref vertex, i);
float x = vertex.position.x;
float y = vertex.position.y;
xMin = Mathf.Min(xMin, x);
yMin = Mathf.Min(yMin, y);
xMax = Mathf.Max(xMax, x);
yMax = Mathf.Max(yMax, y);
}
rect.Set (xMin, yMin, xMax - xMin, yMax - yMin);
break;
default:
rect = rectangle;
break;
}
/// <summary>
/// Gets effect for area.
/// </summary>
public static Rect GetEffectArea(this EffectArea area, VertexHelper vh, Rect rectangle, float aspectRatio = -1)
{
Rect rect = default(Rect);
switch (area)
{
case EffectArea.RectTransform:
rect = rectangle;
break;
case EffectArea.Character:
rect = rectForCharacter;
break;
case EffectArea.Fit:
// Fit to contents.
UIVertex vertex = default(UIVertex);
float xMin = float.MaxValue;
float yMin = float.MaxValue;
float xMax = float.MinValue;
float yMax = float.MinValue;
for (int i = 0; i < vh.currentVertCount; i++)
{
vh.PopulateUIVertex(ref vertex, i);
float x = vertex.position.x;
float y = vertex.position.y;
xMin = Mathf.Min(xMin, x);
yMin = Mathf.Min(yMin, y);
xMax = Mathf.Max(xMax, x);
yMax = Mathf.Max(yMax, y);
}
rect.Set(xMin, yMin, xMax - xMin, yMax - yMin);
break;
default:
rect = rectangle;
break;
}
if(0 < aspectRatio)
{
if (rect.width < rect.height)
{
rect.width = rect.height * aspectRatio;
}
else
{
rect.height = rect.width / aspectRatio;
}
}
return rect;
}
if (0 < aspectRatio)
{
if (rect.width < rect.height)
{
rect.width = rect.height * aspectRatio;
}
else
{
rect.height = rect.width / aspectRatio;
}
}
/// <summary>
/// Gets position factor for area.
/// </summary>
public static void GetPositionFactor (this EffectArea area, int index, Rect rect, Vector2 position, bool isText, bool isTMPro, out float x, out float y)
{
if (isText && area == EffectArea.Character)
{
index = isTMPro ? (index + 3) % 4 : index % 4;
x = splitedCharacterPosition [index].x;
y = splitedCharacterPosition [index].y;
}
else if (area == EffectArea.Fit)
{
x = Mathf.Clamp01 ((position.x - rect.xMin) / rect.width);
y = Mathf.Clamp01 ((position.y - rect.yMin) / rect.height);
}
else
{
x = Mathf.Clamp01 (position.x / rect.width + 0.5f);
y = Mathf.Clamp01 (position.y / rect.height + 0.5f);
}
}
return rect;
}
/// <summary>
/// Normalize vertex position by local matrix.
/// </summary>
public static void GetNormalizedFactor (this EffectArea area, int index, Matrix2x3 matrix, Vector2 position, bool isText, out Vector2 nomalizedPos)
{
if (isText && area == EffectArea.Character)
{
nomalizedPos = matrix * splitedCharacterPosition [(index + 3) % 4];
}
else
{
nomalizedPos = matrix * position;
}
}
}
/// <summary>
/// Gets position factor for area.
/// </summary>
public static void GetPositionFactor(this EffectArea area, int index, Rect rect, Vector2 position, bool isText,
bool isTMPro, out float x, out float y)
{
if (isText && area == EffectArea.Character)
{
index = isTMPro ? (index + 3) % 4 : index % 4;
x = splitedCharacterPosition[index].x;
y = splitedCharacterPosition[index].y;
}
else if (area == EffectArea.Fit)
{
x = Mathf.Clamp01((position.x - rect.xMin) / rect.width);
y = Mathf.Clamp01((position.y - rect.yMin) / rect.height);
}
else
{
x = Mathf.Clamp01(position.x / rect.width + 0.5f);
y = Mathf.Clamp01(position.y / rect.height + 0.5f);
}
}
/// <summary>
/// Normalize vertex position by local matrix.
/// </summary>
public static void GetNormalizedFactor(this EffectArea area, int index, Matrix2x3 matrix, Vector2 position,
bool isText, out Vector2 nomalizedPos)
{
if (isText && area == EffectArea.Character)
{
nomalizedPos = matrix * splitedCharacterPosition[(index + 3) % 4];
}
else
{
nomalizedPos = matrix * position;
}
}
}
}
@@ -1,14 +1,14 @@
namespace Coffee.UIExtensions
{
/// <summary>
/// Effect mode.
/// </summary>
public enum EffectMode
{
None = 0,
Grayscale = 1,
Sepia = 2,
Nega = 3,
Pixel = 4,
}
}
/// <summary>
/// Effect mode.
/// </summary>
public enum EffectMode
{
None = 0,
Grayscale = 1,
Sepia = 2,
Nega = 3,
Pixel = 4,
}
}
@@ -1,14 +1,14 @@
namespace Coffee.UIExtensions
{
/// <summary>
/// Shadow effect style.
/// </summary>
public enum ShadowStyle
{
None = 0,
Shadow,
Outline,
Outline8,
Shadow3,
}
}
/// <summary>
/// Shadow effect style.
/// </summary>
public enum ShadowStyle
{
None = 0,
Shadow,
Outline,
Outline8,
Shadow3,
}
}
@@ -9,443 +9,311 @@ using System.IO;
namespace Coffee.UIExtensions
{
/// <summary>
/// Dissolve effect for uGUI.
/// </summary>
[AddComponentMenu("UI/UIEffect/UIDissolve", 3)]
public class UIDissolve : UIEffectBase, IMaterialModifier
{
//################################
// Constant or Static Members.
//################################
static readonly ParameterTexture _ptex = new ParameterTexture(8, 128, "_ParamTex");
/// <summary>
/// Dissolve effect for uGUI.
/// </summary>
[AddComponentMenu("UI/UIEffects/UIDissolve", 3)]
public class UIDissolve : BaseMaterialEffect, IMaterialModifier
{
private const uint k_ShaderId = 0 << 3;
private static readonly ParameterTexture s_ParamTex = new ParameterTexture(8, 128, "_ParamTex");
private static readonly int k_TransitionTexId = Shader.PropertyToID("_TransitionTex");
private bool _lastKeepAspectRatio;
private EffectArea _lastEffectArea;
private static Texture _defaultTransitionTexture;
[Tooltip("Current location[0-1] for dissolve effect. 0 is not dissolved, 1 is completely dissolved.")]
[FormerlySerializedAs("m_Location")]
[SerializeField]
[Range(0, 1)]
float m_EffectFactor = 0.5f;
[Tooltip("Edge width.")] [SerializeField] [Range(0, 1)]
float m_Width = 0.5f;
[Tooltip("Edge softness.")] [SerializeField] [Range(0, 1)]
float m_Softness = 0.5f;
[Tooltip("Edge color.")] [SerializeField] [ColorUsage(false)]
Color m_Color = new Color(0.0f, 0.25f, 1.0f);
[Tooltip("Edge color effect mode.")] [SerializeField]
ColorMode m_ColorMode = ColorMode.Add;
[Tooltip("Noise texture for dissolving (single channel texture).")]
[SerializeField]
[FormerlySerializedAs("m_NoiseTexture")]
Texture m_TransitionTexture;
[Header("Advanced Option")] [Tooltip("The area for effect.")] [SerializeField]
protected EffectArea m_EffectArea;
[Tooltip("Keep effect aspect ratio.")] [SerializeField]
bool m_KeepAspectRatio;
[Header("Effect Player")] [SerializeField]
EffectPlayer m_Player;
[Tooltip("Reverse the dissolve effect.")] [FormerlySerializedAs("m_ReverseAnimation")] [SerializeField]
bool m_Reverse = false;
/// <summary>
/// Effect factor between 0(start) and 1(end).
/// </summary>
public float effectFactor
{
get { return m_EffectFactor; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (Mathf.Approximately(m_EffectFactor, value)) return;
m_EffectFactor = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Edge width.
/// </summary>
public float width
{
get { return m_Width; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (Mathf.Approximately(m_Width, value)) return;
m_Width = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Edge softness.
/// </summary>
public float softness
{
get { return m_Softness; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (Mathf.Approximately(m_Softness, value)) return;
m_Softness = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Edge color.
/// </summary>
public Color color
{
get { return m_Color; }
set
{
if (m_Color == value) return;
m_Color = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Noise texture.
/// </summary>
public Texture transitionTexture
{
get
{
return m_TransitionTexture
? m_TransitionTexture
: defaultTransitionTexture;
}
set
{
if (m_TransitionTexture == value) return;
m_TransitionTexture = value;
SetMaterialDirty();
}
}
/// <summary>
/// The area for effect.
/// </summary>
public EffectArea effectArea
{
get { return m_EffectArea; }
set
{
if (m_EffectArea == value) return;
m_EffectArea = value;
SetVerticesDirty();
}
}
/// <summary>
/// Keep aspect ratio.
/// </summary>
public bool keepAspectRatio
{
get { return m_KeepAspectRatio; }
set
{
if (m_KeepAspectRatio == value) return;
m_KeepAspectRatio = value;
SetVerticesDirty();
}
}
/// <summary>
/// Color effect mode.
/// </summary>
public ColorMode colorMode
{
get { return m_ColorMode; }
set
{
if (m_ColorMode == value) return;
m_ColorMode = value;
SetMaterialDirty();
}
}
/// <summary>
/// Gets the parameter texture.
/// </summary>
public override ParameterTexture paramTex
{
get { return s_ParamTex; }
}
public override Hash128 GetMaterialHash(Material material)
{
if (!isActiveAndEnabled || !material || !material.shader)
return k_InvalidHash;
var shaderVariantId = (uint) ((int) m_ColorMode << 6);
var resourceId = (uint) transitionTexture.GetInstanceID();
return new Hash128(
(uint) material.GetInstanceID(),
k_ShaderId + shaderVariantId,
resourceId,
0
);
}
//################################
// Serialize Members.
//################################
[Tooltip("Current location[0-1] for dissolve effect. 0 is not dissolved, 1 is completely dissolved.")]
[FormerlySerializedAs("m_Location")]
[SerializeField] [Range(0, 1)] float m_EffectFactor = 0.5f;
private static Texture defaultTransitionTexture
{
get
{
return _defaultTransitionTexture
? _defaultTransitionTexture
: (_defaultTransitionTexture = Resources.Load<Texture>("Default-Transition"));
}
}
[Tooltip("Edge width.")]
[SerializeField] [Range(0, 1)] float m_Width = 0.5f;
public override void ModifyMaterial(Material newMaterial)
{
newMaterial.shader = connector.FindShader("UIDissolve");
SetShaderVariants(newMaterial, m_ColorMode);
[Tooltip("Edge softness.")]
[SerializeField] [Range(0, 1)] float m_Softness = 0.5f;
newMaterial.SetTexture(k_TransitionTexId, transitionTexture);
paramTex.RegisterMaterial(newMaterial);
}
[Tooltip("Edge color.")]
[SerializeField] [ColorUsage(false)] Color m_Color = new Color(0.0f, 0.25f, 1.0f);
/// <summary>
/// Modifies the mesh.
/// </summary>
public override void ModifyMesh(VertexHelper vh)
{
if (!isActiveAndEnabled)
return;
[Tooltip("Edge color effect mode.")]
[SerializeField] ColorMode m_ColorMode = ColorMode.Add;
// bool isText = isTMPro || graphic is Text;
var normalizedIndex = paramTex.GetNormalizedIndex(this);
[Tooltip("Noise texture for dissolving (single channel texture).")]
[SerializeField] Texture m_NoiseTexture;
// rect.
var tex = transitionTexture;
var aspectRatio = m_KeepAspectRatio && tex ? ((float) tex.width) / tex.height : -1;
var rect = m_EffectArea.GetEffectArea(vh, rectTransform.rect, aspectRatio);
[Header("Advanced Option")]
[Tooltip("The area for effect.")]
[SerializeField] protected EffectArea m_EffectArea;
// Calculate vertex position.
var vertex = default(UIVertex);
var count = vh.currentVertCount;
for (var i = 0; i < count; i++)
{
vh.PopulateUIVertex(ref vertex, i);
float x;
float y;
connector.GetPositionFactor(m_EffectArea, i, rect, vertex.position, out x, out y);
[Tooltip("Keep effect aspect ratio.")]
[SerializeField] bool m_KeepAspectRatio;
vertex.uv0 = new Vector2(
Packer.ToFloat(vertex.uv0.x, vertex.uv0.y),
Packer.ToFloat(x, y, normalizedIndex)
);
[Header("Effect Player")]
[SerializeField] EffectPlayer m_Player;
vh.SetUIVertex(vertex, i);
}
}
[Tooltip("Reverse the dissolve effect.")]
[FormerlySerializedAs("m_ReverseAnimation")]
[SerializeField] bool m_Reverse = false;
protected override void SetEffectParamsDirty()
{
paramTex.SetData(this, 0, m_EffectFactor); // param1.x : location
paramTex.SetData(this, 1, m_Width); // param1.y : width
paramTex.SetData(this, 2, m_Softness); // param1.z : softness
paramTex.SetData(this, 4, m_Color.r); // param2.x : red
paramTex.SetData(this, 5, m_Color.g); // param2.y : green
paramTex.SetData(this, 6, m_Color.b); // param2.z : blue
}
#pragma warning disable 0414
[Obsolete][HideInInspector]
[SerializeField][Range(0.1f, 10)] float m_Duration = 1;
[Obsolete][HideInInspector]
[SerializeField] AnimatorUpdateMode m_UpdateMode = AnimatorUpdateMode.Normal;
#pragma warning restore 0414
protected override void SetVerticesDirty()
{
base.SetVerticesDirty();
_lastKeepAspectRatio = m_KeepAspectRatio;
_lastEffectArea = m_EffectArea;
}
//################################
// Public Members.
//################################
protected override void OnDidApplyAnimationProperties()
{
base.OnDidApplyAnimationProperties();
/// <summary>
/// Effect factor between 0(start) and 1(end).
/// </summary>
[System.Obsolete("Use effectFactor instead (UnityUpgradable) -> effectFactor")]
public float location
{
get { return m_EffectFactor; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_EffectFactor, value))
{
m_EffectFactor = value;
SetEffectDirty();
}
}
}
if (_lastKeepAspectRatio != m_KeepAspectRatio
|| _lastEffectArea != m_EffectArea)
SetVerticesDirty();
}
/// <summary>
/// Effect factor between 0(start) and 1(end).
/// </summary>
public float effectFactor
{
get { return m_EffectFactor; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_EffectFactor, value))
{
m_EffectFactor = value;
SetEffectDirty();
}
}
}
/// <summary>
/// Play effect.
/// </summary>
public void Play(bool reset = true)
{
_player.Play(reset);
}
/// <summary>
/// Edge width.
/// </summary>
public float width
{
get { return m_Width; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_Width, value))
{
m_Width = value;
SetEffectDirty();
}
}
}
/// <summary>
/// Stop effect.
/// </summary>
public void Stop(bool reset = true)
{
_player.Stop(reset);
}
/// <summary>
/// Edge softness.
/// </summary>
public float softness
{
get { return m_Softness; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_Softness, value))
{
m_Softness = value;
SetEffectDirty();
}
}
}
protected override void OnEnable()
{
base.OnEnable();
_player.OnEnable((f) => effectFactor = m_Reverse ? 1f - f : f);
}
/// <summary>
/// Edge color.
/// </summary>
public Color color
{
get { return m_Color; }
set
{
if (m_Color != value)
{
m_Color = value;
SetEffectDirty();
}
}
}
protected override void OnDisable()
{
base.OnDisable();
_player.OnDisable();
}
/// <summary>
/// Noise texture.
/// </summary>
public Texture noiseTexture
{
get { return m_NoiseTexture ?? material.GetTexture("_NoiseTex"); }
set
{
if (m_NoiseTexture != value)
{
m_NoiseTexture = value;
if (graphic)
{
graphic.SetMaterialDirty();
}
}
}
}
/// <summary>
/// The area for effect.
/// </summary>
public EffectArea effectArea
{
get { return m_EffectArea; }
set
{
if (m_EffectArea != value)
{
m_EffectArea = value;
SetVerticesDirty();
}
}
}
/// <summary>
/// Keep aspect ratio.
/// </summary>
public bool keepAspectRatio
{
get { return m_KeepAspectRatio; }
set
{
if (m_KeepAspectRatio != value)
{
m_KeepAspectRatio = value;
SetVerticesDirty ();
}
}
}
/// <summary>
/// Color effect mode.
/// </summary>
public ColorMode colorMode
{
get { return m_ColorMode; }
set
{
if (m_ColorMode != value)
{
m_ColorMode = value;
if (graphic)
{
graphic.SetMaterialDirty();
}
}
}
}
/// <summary>
/// Play effect on enable.
/// </summary>
[System.Obsolete("Use Play/Stop method instead")]
public bool play { get { return _player.play; } set { _player.play = value; } }
/// <summary>
/// Play effect loop.
/// </summary>
[System.Obsolete]
public bool loop { get { return _player.loop; } set { _player.loop = value; } }
/// <summary>
/// The duration for playing effect.
/// </summary>
public float duration { get { return _player.duration; } set { _player.duration = Mathf.Max(value, 0.1f); } }
/// <summary>
/// Delay on loop effect.
/// </summary>
[System.Obsolete]
public float loopDelay { get { return _player.loopDelay; } set { _player.loopDelay = Mathf.Max(value, 0); } }
/// <summary>
/// Update mode for playing effect.
/// </summary>
public AnimatorUpdateMode updateMode { get { return _player.updateMode; } set { _player.updateMode = value; } }
/// <summary>
/// Reverse the dissolve effect.
/// </summary>
public bool reverse { get { return m_Reverse; } set { m_Reverse = value; } }
/// <summary>
/// Gets the parameter texture.
/// </summary>
public override ParameterTexture ptex { get { return _ptex; } }
public override Hash128 GetMaterialHash(Material material)
{
if(!isActiveAndEnabled || !material || !material.shader)
return new Hash128();
uint materialId = (uint)material.GetInstanceID();
uint shaderId = 0 << 3;
string materialShaderName = material.shader.name;
if (materialShaderName.StartsWith ("TextMeshPro/Mobile/", StringComparison.Ordinal))
{
shaderId += 2;
}
else if (materialShaderName.Equals ("TextMeshPro/Sprite", StringComparison.Ordinal))
{
shaderId += 0;
}
else if (materialShaderName.StartsWith ("TextMeshPro/", StringComparison.Ordinal))
{
shaderId += 1;
}
else
{
shaderId += 0;
}
uint shaderVariantId = (uint)((int)m_ColorMode << 6);
uint resourceId = m_NoiseTexture ? (uint)m_NoiseTexture.GetInstanceID() : 0;
return new Hash128(
materialId,
shaderId + shaderVariantId,
resourceId,
0
);
}
public override void ModifyMaterial(Material material)
{
Debug.LogFormat(this, $"ModifyMaterial {material}");
string materialShaderName = material.shader.name;
if(materialShaderName.StartsWith ("TextMeshPro/Mobile/", StringComparison.Ordinal))
{
material.shader = Shader.Find ("TextMeshPro/Mobile/Distance Field (UIDissolve)");
}
else if (materialShaderName.Equals ("TextMeshPro/Sprite", StringComparison.Ordinal))
{
material.shader = Shader.Find ("UI/Hidden/UI-Effect-Dissolve");
}
else if (materialShaderName.StartsWith ("TextMeshPro/", StringComparison.Ordinal))
{
material.shader = Shader.Find ("TextMeshPro/Distance Field (UIDissolve)");
}
else
{
material.shader = Shader.Find ("UI/Hidden/UI-Effect-Dissolve");
}
SetShaderVariants(material, m_ColorMode);
if(m_NoiseTexture)
{
material.SetTexture("_NoiseTex", m_NoiseTexture);
}
ptex.RegisterMaterial (material);
}
/// <summary>
/// Modifies the material.
/// </summary>
[ContextMenu("ModifyMaterial")]
public override void ModifyMaterial()
{
}
/// <summary>
/// Modifies the mesh.
/// </summary>
public override void ModifyMesh(VertexHelper vh)
{
if (!isActiveAndEnabled)
return;
bool isText = isTMPro || graphic is Text;
float normalizedIndex = ptex.GetNormalizedIndex(this);
// rect.
var tex = noiseTexture;
var aspectRatio = m_KeepAspectRatio && tex ? ((float)tex.width) / tex.height : -1;
Rect rect = m_EffectArea.GetEffectArea(vh, rectTransform.rect, aspectRatio);
// Calculate vertex position.
UIVertex vertex = default(UIVertex);
float x, y;
int count = vh.currentVertCount;
for (int i = 0; i < count; i++)
{
vh.PopulateUIVertex(ref vertex, i);
m_EffectArea.GetPositionFactor (i, rect, vertex.position, isText, isTMPro, out x, out y);
vertex.uv0 = new Vector2(
Packer.ToFloat(vertex.uv0.x, vertex.uv0.y),
Packer.ToFloat(x, y, normalizedIndex)
);
vh.SetUIVertex(vertex, i);
}
}
protected override void SetEffectDirty()
{
ptex.SetData(this, 0, m_EffectFactor); // param1.x : location
ptex.SetData(this, 1, m_Width); // param1.y : width
ptex.SetData(this, 2, m_Softness); // param1.z : softness
ptex.SetData(this, 4, m_Color.r); // param2.x : red
ptex.SetData(this, 5, m_Color.g); // param2.y : green
ptex.SetData(this, 6, m_Color.b); // param2.z : blue
}
/// <summary>
/// Play effect.
/// </summary>
public void Play(bool reset = true)
{
_player.Play(reset);
}
/// <summary>
/// Stop effect.
/// </summary>
public void Stop(bool reset = true)
{
_player.Stop(reset);
}
//################################
// Protected Members.
//################################
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected override void OnEnable()
{
base.OnEnable();
_player.OnEnable((f) =>effectFactor = m_Reverse ? 1f - f : f);
}
protected override void OnDisable()
{
base.OnDisable ();
_player.OnDisable();
}
#if UNITY_EDITOR
/// <summary>
/// Gets the material.
/// </summary>
/// <returns>The material.</returns>
protected override Material GetMaterial()
{
return null;
}
#pragma warning disable 0612
protected override void UpgradeIfNeeded()
{
// Upgrade for v3.0.0
if (IsShouldUpgrade(300))
{
_player.play = false;
_player.duration = m_Duration;
_player.loop = false;
_player.loopDelay = 1;
_player.updateMode = m_UpdateMode;
}
}
#pragma warning restore 0612
#endif
//################################
// Private Members.
//################################
EffectPlayer _player{ get { return m_Player ?? (m_Player = new EffectPlayer()); } }
}
EffectPlayer _player
{
get { return m_Player ?? (m_Player = new EffectPlayer()); }
}
}
}
@@ -1,13 +1,11 @@
fileFormatVersion: 2
guid: ce76b7a490bd74f34a2f2752641aea24
timeCreated: 1538866738
licenseType: Pro
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences:
- m_EffectMaterial: {instanceID: 0}
- m_PtexMaterial: {instanceID: 0}
- m_NoiseTexture: {fileID: 2800000, guid: 3e04c247fb2604af186173fce0bc62de, type: 3}
- m_TransitionTexture: {fileID: 2800000, guid: 3e04c247fb2604af186173fce0bc62de,
type: 3}
executionOrder: 0
icon: {instanceID: 0}
userData:
@@ -3,604 +3,381 @@ using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Serialization;
#if UNITY_EDITOR
using System.IO;
using System.Linq;
using UnityEditor;
#endif
namespace Coffee.UIExtensions
{
/// <summary>
/// UIEffect.
/// </summary>
[ExecuteInEditMode]
[RequireComponent(typeof(Graphic))]
[DisallowMultipleComponent]
[AddComponentMenu("UI/UIEffect/UIEffect", 1)]
public class UIEffect : UIEffectBase, IMaterialModifier
{
//################################
// Constant or Static Members.
//################################
public const string shaderName = "UI/Hidden/UI-Effect";
static readonly ParameterTexture _ptex = new ParameterTexture(8, 1024, "_ParamTex");
//################################
// Serialize Members.
//################################
[FormerlySerializedAs("m_ToneLevel")]
[Tooltip("Effect factor between 0(no effect) and 1(complete effect).")]
[SerializeField][Range(0, 1)] float m_EffectFactor = 1;
[Tooltip("Color effect factor between 0(no effect) and 1(complete effect).")]
[SerializeField][Range(0, 1)] float m_ColorFactor = 1;
[FormerlySerializedAs("m_Blur")]
[Tooltip("How far is the blurring from the graphic.")]
[SerializeField][Range(0, 1)] float m_BlurFactor = 1;
[FormerlySerializedAs("m_ToneMode")]
[Tooltip("Effect mode")]
[SerializeField] EffectMode m_EffectMode = EffectMode.None;
[Tooltip("Color effect mode")]
[SerializeField] ColorMode m_ColorMode = ColorMode.Multiply;
[Tooltip ("Color for effect")]
[ColorUsage(false)]
[SerializeField] Color m_EffectColor = Color.white;
[Tooltip ("Blur effect mode")]
[SerializeField] BlurMode m_BlurMode = BlurMode.None;
[Tooltip("Advanced blurring remove common artifacts in the blur effect for uGUI.")]
[SerializeField] bool m_AdvancedBlur = false;
#pragma warning disable 0414
[Obsolete][HideInInspector]
[SerializeField][Range(0, 1)] float m_ShadowBlur = 1;
[Obsolete][HideInInspector]
[SerializeField] ShadowStyle m_ShadowStyle;
[Obsolete][HideInInspector]
[SerializeField] Color m_ShadowColor = Color.black;
[Obsolete][HideInInspector]
[SerializeField] Vector2 m_EffectDistance = new Vector2(1f, -1f);
[Obsolete][HideInInspector]
[SerializeField] bool m_UseGraphicAlpha = true;
[Obsolete][HideInInspector]
[SerializeField] List<UIShadow.AdditionalShadow> m_AdditionalShadows = new List<UIShadow.AdditionalShadow>();
#pragma warning restore 0414
public enum BlurEx
{
None = 0,
Ex = 1,
}
//################################
// Public Members.
//################################
#if UNITY_2017_1_OR_NEWER
public override AdditionalCanvasShaderChannels requiredChannels
{
get
{
if (advancedBlur)
{
return isTMPro
? AdditionalCanvasShaderChannels.TexCoord1 | AdditionalCanvasShaderChannels.TexCoord2
: AdditionalCanvasShaderChannels.TexCoord1;
}
return AdditionalCanvasShaderChannels.None;
}
}
#endif
/// <summary>
/// Effect factor between 0(no effect) and 1(complete effect).
/// </summary>
[System.Obsolete("Use effectFactor instead (UnityUpgradable) -> effectFactor")]
public float toneLevel
{
get { return m_EffectFactor; }
set
{
m_EffectFactor = Mathf.Clamp(value, 0, 1);
SetEffectDirty ();
}
}
/// <summary>
/// Effect factor between 0(no effect) and 1(complete effect).
/// </summary>
public float effectFactor
{
get { return m_EffectFactor; }
set
{
m_EffectFactor = Mathf.Clamp(value, 0, 1);
SetEffectDirty ();
}
}
/// <summary>
/// Color effect factor between 0(no effect) and 1(complete effect).
/// </summary>
public float colorFactor
{
get { return m_ColorFactor; }
set
{
m_ColorFactor = Mathf.Clamp(value, 0, 1);
SetEffectDirty ();
}
}
/// <summary>
/// How far is the blurring from the graphic.
/// </summary>
[System.Obsolete("Use blurFactor instead (UnityUpgradable) -> blurFactor")]
public float blur
{
get { return m_BlurFactor; }
set
{
m_BlurFactor = Mathf.Clamp(value, 0, 1);
SetEffectDirty ();
}
}
/// <summary>
/// How far is the blurring from the graphic.
/// </summary>
[System.Obsolete("Use effectFactor instead (UnityUpgradable) -> effectFactor")]
public float blurFactor
{
get { return m_BlurFactor; }
set
{
m_BlurFactor = Mathf.Clamp(value, 0, 1);
SetEffectDirty ();
}
}
/// <summary>
/// Effect mode(readonly).
/// </summary>
[System.Obsolete("Use effectMode instead (UnityUpgradable) -> effectMode")]
public EffectMode toneMode { get { return m_EffectMode; } }
/// <summary>
/// Effect mode(readonly).
/// </summary>
public EffectMode effectMode
{
get { return m_EffectMode; }
set
{
if (m_EffectMode != value)
{
m_EffectMode = value;
if (graphic)
{
graphic.SetMaterialDirty ();
}
}
}
}
/// <summary>
/// Color effect mode.
/// </summary>
public ColorMode colorMode
{
get { return m_ColorMode; }
set
{
if (m_ColorMode != value)
{
m_ColorMode = value;
if (graphic)
{
graphic.SetMaterialDirty ();
}
}
}
}
/// <summary>
/// Blur effect mode(readonly).
/// </summary>
public BlurMode blurMode
{
get { return m_BlurMode; }
set
{
if (m_BlurMode != value)
{
m_BlurMode = value;
if (graphic)
{
graphic.SetMaterialDirty ();
}
}
}
}
/// <summary>
/// Color for the color effect.
/// </summary>
public Color effectColor
{
get { return m_EffectColor; }
set
{
if (m_EffectColor != value)
{
m_EffectColor = value;
SetEffectDirty ();
}
}
}
/// <summary>
/// Gets the parameter texture.
/// </summary>
public override ParameterTexture ptex { get { return _ptex; } }
/// <summary>
/// Advanced blurring remove common artifacts in the blur effect for uGUI.
/// </summary>
public bool advancedBlur
{
get { return m_AdvancedBlur; }
set
{
if (m_AdvancedBlur != value)
{
m_AdvancedBlur = value;
if (graphic)
{
graphic.SetMaterialDirty ();
}
}
}
}
public override Hash128 GetMaterialHash (Material material)
{
if (!isActiveAndEnabled || !material || !material.shader)
return new Hash128 ();
uint materialId = (uint)material.GetInstanceID ();
uint shaderId = 2 << 3;
string materialShaderName = material.shader.name;
if (materialShaderName.StartsWith ("TextMeshPro/Mobile/", StringComparison.Ordinal))
{
shaderId += 2;
}
else if (materialShaderName.Equals ("TextMeshPro/Sprite", StringComparison.Ordinal))
{
shaderId += 0;
}
else if (materialShaderName.StartsWith ("TextMeshPro/", StringComparison.Ordinal))
{
shaderId += 1;
}
else
{
shaderId += 0;
}
uint shaderVariantId = (uint)(((int)m_EffectMode << 6) + ((int)m_ColorMode << 9) + ((int)m_BlurMode << 11) + ((m_AdvancedBlur ? 1 : 0) << 13));
return new Hash128 (
materialId,
shaderId + shaderVariantId,
0,
0
);
}
public override void ModifyMaterial (Material material)
{
string materialShaderName = material.shader.name;
if (materialShaderName.StartsWith ("TextMeshPro/Mobile/", StringComparison.Ordinal))
{
material.shader = Shader.Find ("TextMeshPro/Mobile/Distance Field (UIEffect)");
}
else if (materialShaderName.Equals ("TextMeshPro/Sprite", StringComparison.Ordinal))
{
material.shader = Shader.Find ("UI/Hidden/UI-Effect");
}
else if (materialShaderName.StartsWith ("TextMeshPro/", StringComparison.Ordinal))
{
material.shader = Shader.Find ("TextMeshPro/Distance Field (UIEffect)");
}
else
{
material.shader = Shader.Find ("UI/Hidden/UI-Effect");
}
SetShaderVariants (material, m_EffectMode, m_ColorMode, m_BlurMode, m_AdvancedBlur ? BlurEx.Ex : BlurEx.None);
ptex.RegisterMaterial (material);
}
/// <summary>
/// Modifies the mesh.
/// </summary>
public override void ModifyMesh(VertexHelper vh)
{
if (!isActiveAndEnabled)
{
return;
}
float normalizedIndex = ptex.GetNormalizedIndex(this);
if (m_BlurMode != BlurMode.None && advancedBlur)
{
vh.GetUIVertexStream(tempVerts);
vh.Clear();
var count = tempVerts.Count;
// Bundle
int bundleSize = (targetGraphic is Text || isTMPro) ? 6 : count;
Rect posBounds = default(Rect);
Rect uvBounds = default(Rect);
Vector3 size = default(Vector3);
Vector3 tPos = default(Vector3);
Vector3 tUV = default(Vector3);
float expand = (float)blurMode * 6 * 2;
for (int i = 0; i < count; i += bundleSize)
{
// min/max for bundled-quad
GetBounds(tempVerts, i, bundleSize, ref posBounds, ref uvBounds, true);
// Pack uv mask.
Vector2 uvMask = new Vector2(Packer.ToFloat(uvBounds.xMin, uvBounds.yMin), Packer.ToFloat(uvBounds.xMax, uvBounds.yMax));
// Quad
for (int j = 0; j < bundleSize; j += 6)
{
Vector3 cornerPos1 = tempVerts[i + j + 1].position;
Vector3 cornerPos2 = tempVerts[i + j + 4].position;
// Is outer quad?
bool hasOuterEdge = (bundleSize == 6)
|| !posBounds.Contains(cornerPos1)
|| !posBounds.Contains(cornerPos2);
if (hasOuterEdge)
{
Vector3 cornerUv1 = tempVerts[i + j + 1].uv0;
Vector3 cornerUv2 = tempVerts[i + j + 4].uv0;
Vector3 centerPos = (cornerPos1 + cornerPos2) / 2;
Vector3 centerUV = (cornerUv1 + cornerUv2) / 2;
size = (cornerPos1 - cornerPos2);
size.x = 1 + expand / Mathf.Abs(size.x);
size.y = 1 + expand / Mathf.Abs(size.y);
size.z = 1 + expand / Mathf.Abs(size.z);
tPos = centerPos - Vector3.Scale(size, centerPos);
tUV = centerUV - Vector3.Scale(size, centerUV);
}
// Vertex
for (int k = 0; k < 6; k++)
{
UIVertex vt = tempVerts[i + j + k];
Vector3 pos = vt.position;
Vector2 uv0 = vt.uv0;
if (hasOuterEdge && (pos.x < posBounds.xMin || posBounds.xMax < pos.x))
{
pos.x = pos.x * size.x + tPos.x;
uv0.x = uv0.x * size.x + tUV.x;
}
if (hasOuterEdge && (pos.y < posBounds.yMin || posBounds.yMax < pos.y))
{
pos.y = pos.y * size.y + tPos.y;
uv0.y = uv0.y * size.y + tUV.y;
}
vt.uv0 = new Vector2(Packer.ToFloat((uv0.x + 0.5f) / 2f, (uv0.y + 0.5f) / 2f), normalizedIndex);
vt.position = pos;
if (isTMPro)
{
#if UNITY_2017_1_OR_NEWER
vt.uv2 = uvMask;
#endif
}
else
{
vt.uv1 = uvMask;
}
tempVerts[i + j + k] = vt;
}
}
}
vh.AddUIVertexTriangleStream(tempVerts);
tempVerts.Clear();
}
else
{
int count = vh.currentVertCount;
UIVertex vt = default(UIVertex);
for (int i = 0; i < count; i++)
{
vh.PopulateUIVertex(ref vt, i);
Vector2 uv0 = vt.uv0;
vt.uv0 = new Vector2(
Packer.ToFloat((uv0.x + 0.5f) / 2f, (uv0.y + 0.5f) / 2f),
normalizedIndex
);
vh.SetUIVertex(vt, i);
}
}
}
protected override void SetEffectDirty ()
{
ptex.SetData(this, 0, m_EffectFactor); // param.x : effect factor
ptex.SetData(this, 1, m_ColorFactor); // param.y : color factor
ptex.SetData(this, 2, m_BlurFactor); // param.z : blur factor
ptex.SetData (this, 4, m_EffectColor.r); // param2.x : red
ptex.SetData (this, 5, m_EffectColor.g); // param2.y : green
ptex.SetData (this, 6, m_EffectColor.b); // param2.z : blue
}
#if UNITY_EDITOR
/// <summary>
/// Gets the material.
/// </summary>
/// <returns>The material.</returns>
protected override Material GetMaterial()
{
return null;
}
#pragma warning disable 0612
protected override void UpgradeIfNeeded()
{
// Upgrade for v3.0.0
if (IsShouldUpgrade(300))
{
if (m_ColorMode != ColorMode.Multiply)
{
Color col = targetGraphic.color;
col.r = m_EffectColor.r;
col.g = m_EffectColor.g;
col.b = m_EffectColor.b;
targetGraphic.color = col;
m_ColorFactor = m_EffectColor.a;
}
if (m_ShadowStyle != ShadowStyle.None || m_AdditionalShadows.Any(x => x.style != ShadowStyle.None))
{
if (m_ShadowStyle != ShadowStyle.None)
{
var shadow = gameObject.GetComponent<UIShadow>() ?? gameObject.AddComponent<UIShadow>();
shadow.style = m_ShadowStyle;
shadow.effectDistance = m_EffectDistance;
shadow.effectColor = m_ShadowColor;
shadow.useGraphicAlpha = m_UseGraphicAlpha;
shadow.blurFactor = m_ShadowBlur;
}
foreach (var s in m_AdditionalShadows)
{
if (s.style == ShadowStyle.None)
{
continue;
}
var shadow = gameObject.AddComponent<UIShadow>();
shadow.style = s.style;
shadow.effectDistance = s.effectDistance;
shadow.effectColor = s.effectColor;
shadow.useGraphicAlpha = s.useGraphicAlpha;
shadow.blurFactor = s.blur;
}
m_ShadowStyle = ShadowStyle.None;
m_AdditionalShadows = null;
if (m_EffectMode == EffectMode.None && m_ColorMode == ColorMode.Multiply && m_BlurMode == BlurMode.None)
{
DestroyImmediate(this, true);
}
}
int tone = (int)m_EffectMode;
const int Mono = 5;
const int Cutoff = 6;
const int Hue = 7;
if (tone == Hue)
{
var go = gameObject;
var hue = m_EffectFactor;
DestroyImmediate(this, true);
var hsv = go.GetComponent<UIHsvModifier>() ?? go.AddComponent<UIHsvModifier>();
hsv.hue = hue;
hsv.range = 1;
}
// Cutoff/Mono
if (tone == Cutoff || tone == Mono)
{
var go = gameObject;
var factor = m_EffectFactor;
var transitionMode = tone == Cutoff
? UITransitionEffect.EffectMode.Cutoff
: UITransitionEffect.EffectMode.Fade;
DestroyImmediate(this, true);
var trans = go.GetComponent<UITransitionEffect>() ?? go.AddComponent<UITransitionEffect>();
trans.effectFactor = factor;
var sp = new SerializedObject(trans).FindProperty("m_EffectMode");
sp.intValue = (int)transitionMode;
sp.serializedObject.ApplyModifiedProperties();
}
}
}
#pragma warning restore 0612
#endif
//################################
// Private Members.
//################################
static void GetBounds(List<UIVertex> verts, int start, int count, ref Rect posBounds, ref Rect uvBounds, bool global)
{
Vector2 minPos = new Vector2(float.MaxValue, float.MaxValue);
Vector2 maxPos = new Vector2(float.MinValue, float.MinValue);
Vector2 minUV = new Vector2(float.MaxValue, float.MaxValue);
Vector2 maxUV = new Vector2(float.MinValue, float.MinValue);
for (int i = start; i < start + count; i++)
{
UIVertex vt = verts[i];
Vector2 uv = vt.uv0;
Vector3 pos = vt.position;
// Left-Bottom
if (minPos.x >= pos.x && minPos.y >= pos.y)
{
minPos = pos;
}
// Right-Top
else if (maxPos.x <= pos.x && maxPos.y <= pos.y)
{
maxPos = pos;
}
// Left-Bottom
if (minUV.x >= uv.x && minUV.y >= uv.y)
{
minUV = uv;
}
// Right-Top
else if (maxUV.x <= uv.x && maxUV.y <= uv.y)
{
maxUV = uv;
}
}
// Shrink coordinate for detect edge
posBounds.Set(minPos.x + 0.001f, minPos.y + 0.001f, maxPos.x - minPos.x - 0.002f, maxPos.y - minPos.y - 0.002f);
uvBounds.Set(minUV.x, minUV.y, maxUV.x - minUV.x, maxUV.y - minUV.y);
}
}
/// <summary>
/// UIEffect.
/// </summary>
[ExecuteInEditMode]
[RequireComponent(typeof(Graphic))]
[DisallowMultipleComponent]
[AddComponentMenu("UI/UIEffects/UIEffect", 1)]
public class UIEffect : BaseMaterialEffect, IMaterialModifier
{
private const uint k_ShaderId = 2 << 3;
private static readonly ParameterTexture s_ParamTex = new ParameterTexture(4, 1024, "_ParamTex");
[FormerlySerializedAs("m_ToneLevel")]
[Tooltip("Effect factor between 0(no effect) and 1(complete effect).")]
[SerializeField]
[Range(0, 1)]
float m_EffectFactor = 1;
[Tooltip("Color effect factor between 0(no effect) and 1(complete effect).")] [SerializeField] [Range(0, 1)]
float m_ColorFactor = 1;
[FormerlySerializedAs("m_Blur")]
[Tooltip("How far is the blurring from the graphic.")]
[SerializeField]
[Range(0, 1)]
float m_BlurFactor = 1;
[FormerlySerializedAs("m_ToneMode")] [Tooltip("Effect mode")] [SerializeField]
EffectMode m_EffectMode = EffectMode.None;
[Tooltip("Color effect mode")] [SerializeField]
ColorMode m_ColorMode = ColorMode.Multiply;
[Tooltip("Color for effect")] [ColorUsage(false)] [SerializeField]
Color m_EffectColor = Color.white;
[Tooltip("Blur effect mode")] [SerializeField]
BlurMode m_BlurMode = BlurMode.None;
[Tooltip("Advanced blurring remove common artifacts in the blur effect for uGUI.")] [SerializeField]
bool m_AdvancedBlur = false;
private enum BlurEx
{
None = 0,
Ex = 1,
}
/// <summary>
/// Additional canvas shader channels to use this component.
/// </summary>
public AdditionalCanvasShaderChannels uvMaskChannel
{
get { return connector.extraChannel; }
}
/// <summary>
/// Effect factor between 0(no effect) and 1(complete effect).
/// </summary>
public float effectFactor
{
get { return m_EffectFactor; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (Mathf.Approximately(m_EffectFactor, value)) return;
m_EffectFactor = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Color effect factor between 0(no effect) and 1(complete effect).
/// </summary>
public float colorFactor
{
get { return m_ColorFactor; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (Mathf.Approximately(m_ColorFactor, value)) return;
m_ColorFactor = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// How far is the blurring from the graphic.
/// </summary>
public float blurFactor
{
get { return m_BlurFactor; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (Mathf.Approximately(m_BlurFactor, value)) return;
m_BlurFactor = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Effect mode.
/// </summary>
public EffectMode effectMode
{
get { return m_EffectMode; }
set
{
if (m_EffectMode == value) return;
m_EffectMode = value;
SetMaterialDirty();
}
}
/// <summary>
/// Color effect mode.
/// </summary>
public ColorMode colorMode
{
get { return m_ColorMode; }
set
{
if (m_ColorMode == value) return;
m_ColorMode = value;
SetMaterialDirty();
}
}
/// <summary>
/// Blur effect mode(readonly).
/// </summary>
public BlurMode blurMode
{
get { return m_BlurMode; }
set
{
if (m_BlurMode == value) return;
m_BlurMode = value;
SetMaterialDirty();
}
}
/// <summary>
/// Color for the color effect.
/// </summary>
public Color effectColor
{
get { return m_EffectColor; }
set
{
if (m_EffectColor == value) return;
m_EffectColor = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Gets the parameter texture.
/// </summary>
public override ParameterTexture paramTex
{
get { return s_ParamTex; }
}
/// <summary>
/// Advanced blurring remove common artifacts in the blur effect for uGUI.
/// </summary>
public bool advancedBlur
{
get { return m_AdvancedBlur; }
set
{
if (m_AdvancedBlur == value) return;
m_AdvancedBlur = value;
SetVerticesDirty();
SetMaterialDirty();
}
}
public override Hash128 GetMaterialHash(Material material)
{
if (!isActiveAndEnabled || !material || !material.shader)
return k_InvalidHash;
var shaderVariantId = (uint) (((int) m_EffectMode << 6) + ((int) m_ColorMode << 9) +
((int) m_BlurMode << 11) + ((m_AdvancedBlur ? 1 : 0) << 13));
return new Hash128(
(uint) material.GetInstanceID(),
k_ShaderId + shaderVariantId,
0,
0
);
}
public override void ModifyMaterial(Material newMaterial)
{
newMaterial.shader = connector.FindShader("UIEffect");
SetShaderVariants(newMaterial, m_EffectMode, m_ColorMode, m_BlurMode,
m_AdvancedBlur ? BlurEx.Ex : BlurEx.None);
paramTex.RegisterMaterial(newMaterial);
}
/// <summary>
/// Modifies the mesh.
/// </summary>
public override void ModifyMesh(VertexHelper vh)
{
if (!isActiveAndEnabled)
{
return;
}
var normalizedIndex = paramTex.GetNormalizedIndex(this);
if (m_BlurMode != BlurMode.None && advancedBlur)
{
vh.GetUIVertexStream(s_TempVerts);
vh.Clear();
var count = s_TempVerts.Count;
// Bundle
int bundleSize = connector.IsText(graphic) ? 6 : count;
Rect posBounds = default(Rect);
Rect uvBounds = default(Rect);
Vector3 size = default(Vector3);
Vector3 tPos = default(Vector3);
Vector3 tUV = default(Vector3);
float expand = (float) blurMode * 6 * 2;
for (int i = 0; i < count; i += bundleSize)
{
// min/max for bundled-quad
GetBounds(s_TempVerts, i, bundleSize, ref posBounds, ref uvBounds, true);
// Pack uv mask.
Vector2 uvMask = new Vector2(Packer.ToFloat(uvBounds.xMin, uvBounds.yMin),
Packer.ToFloat(uvBounds.xMax, uvBounds.yMax));
// Quad
for (int j = 0; j < bundleSize; j += 6)
{
Vector3 cornerPos1 = s_TempVerts[i + j + 1].position;
Vector3 cornerPos2 = s_TempVerts[i + j + 4].position;
// Is outer quad?
bool hasOuterEdge = (bundleSize == 6)
|| !posBounds.Contains(cornerPos1)
|| !posBounds.Contains(cornerPos2);
if (hasOuterEdge)
{
Vector3 cornerUv1 = s_TempVerts[i + j + 1].uv0;
Vector3 cornerUv2 = s_TempVerts[i + j + 4].uv0;
Vector3 centerPos = (cornerPos1 + cornerPos2) / 2;
Vector3 centerUV = (cornerUv1 + cornerUv2) / 2;
size = (cornerPos1 - cornerPos2);
size.x = 1 + expand / Mathf.Abs(size.x);
size.y = 1 + expand / Mathf.Abs(size.y);
size.z = 1 + expand / Mathf.Abs(size.z);
tPos = centerPos - Vector3.Scale(size, centerPos);
tUV = centerUV - Vector3.Scale(size, centerUV);
}
// Vertex
for (int k = 0; k < 6; k++)
{
UIVertex vt = s_TempVerts[i + j + k];
Vector3 pos = vt.position;
Vector2 uv0 = vt.uv0;
if (hasOuterEdge && (pos.x < posBounds.xMin || posBounds.xMax < pos.x))
{
pos.x = pos.x * size.x + tPos.x;
uv0.x = uv0.x * size.x + tUV.x;
}
if (hasOuterEdge && (pos.y < posBounds.yMin || posBounds.yMax < pos.y))
{
pos.y = pos.y * size.y + tPos.y;
uv0.y = uv0.y * size.y + tUV.y;
}
vt.uv0 = new Vector2(Packer.ToFloat((uv0.x + 0.5f) / 2f, (uv0.y + 0.5f) / 2f),
normalizedIndex);
vt.position = pos;
connector.SetExtraChannel(ref vt, uvMask);
s_TempVerts[i + j + k] = vt;
}
}
}
vh.AddUIVertexTriangleStream(s_TempVerts);
s_TempVerts.Clear();
}
else
{
int count = vh.currentVertCount;
UIVertex vt = default(UIVertex);
for (int i = 0; i < count; i++)
{
vh.PopulateUIVertex(ref vt, i);
Vector2 uv0 = vt.uv0;
vt.uv0 = new Vector2(
Packer.ToFloat((uv0.x + 0.5f) / 2f, (uv0.y + 0.5f) / 2f),
normalizedIndex
);
vh.SetUIVertex(vt, i);
}
}
}
protected override void SetEffectParamsDirty()
{
paramTex.SetData(this, 0, m_EffectFactor); // param.x : effect factor
paramTex.SetData(this, 1, m_ColorFactor); // param.y : color factor
paramTex.SetData(this, 2, m_BlurFactor); // param.z : blur factor
}
static void GetBounds(List<UIVertex> verts, int start, int count, ref Rect posBounds, ref Rect uvBounds,
bool global)
{
Vector2 minPos = new Vector2(float.MaxValue, float.MaxValue);
Vector2 maxPos = new Vector2(float.MinValue, float.MinValue);
Vector2 minUV = new Vector2(float.MaxValue, float.MaxValue);
Vector2 maxUV = new Vector2(float.MinValue, float.MinValue);
for (int i = start; i < start + count; i++)
{
UIVertex vt = verts[i];
Vector2 uv = vt.uv0;
Vector3 pos = vt.position;
// Left-Bottom
if (minPos.x >= pos.x && minPos.y >= pos.y)
{
minPos = pos;
}
// Right-Top
else if (maxPos.x <= pos.x && maxPos.y <= pos.y)
{
maxPos = pos;
}
// Left-Bottom
if (minUV.x >= uv.x && minUV.y >= uv.y)
{
minUV = uv;
}
// Right-Top
else if (maxUV.x <= uv.x && maxUV.y <= uv.y)
{
maxUV = uv;
}
}
// Shrink coordinate for detect edge
posBounds.Set(minPos.x + 0.001f, minPos.y + 0.001f, maxPos.x - minPos.x - 0.002f,
maxPos.y - minPos.y - 0.002f);
uvBounds.Set(minUV.x, minUV.y, maxUV.x - minUV.x, maxUV.y - minUV.y);
}
}
}
@@ -0,0 +1,110 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
namespace Coffee.UIExtensions
{
/// <summary>
/// Dissolve effect for uGUI.
/// </summary>
[ExecuteInEditMode]
public class UIEffectMaterialResolver : MonoBehaviour, IMaterialModifier, IMeshModifier
{
[ContextMenu("test")]
void test()
{
GetComponent<Graphic>().SetMaterialDirty();
GetComponent<Graphic>().SetVerticesDirty();
}
Hash128 _effectMaterialHash;
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected void OnEnable()
{
//GetComponent<Graphic> ().SetMaterialDirty ();
//GetComponent<Graphic> ().SetVerticesDirty ();
}
/// <summary>
/// This function is called when the behaviour becomes disabled () or inactive.
/// </summary>
protected void OnDisable()
{
MaterialCache.Unregister(_effectMaterialHash);
_effectMaterialHash = new Hash128();
//GetComponent<Graphic> ().SetMaterialDirty ();
//GetComponent<Graphic> ().SetVerticesDirty ();
}
protected Hash128 GetMaterialHash(Material material)
{
return new Hash128();
}
public Material GetModifiedMaterial(Material baseMaterial)
{
if (!isActiveAndEnabled)
{
return baseMaterial;
}
var modifier = transform.parent.GetComponent<BaseMaterialEffect>();
var oldHash = _effectMaterialHash;
_effectMaterialHash = modifier.GetMaterialHash(baseMaterial);
var modifiedMaterial = baseMaterial;
if (_effectMaterialHash.isValid)
{
modifiedMaterial = MaterialCache.Register(baseMaterial, _effectMaterialHash, modifier.ModifyMaterial);
}
MaterialCache.Unregister(oldHash);
return modifiedMaterial;
}
//public Material GetModifiedMaterial2 (Material baseMaterial)
//{
// Debug.Log ("UIEffectMaterialResolver 0");
// if (!isActiveAndEnabled)
// return baseMaterial;
// var parent = transform.parent;
// if (!parent)
// return baseMaterial;
// var modifier = parent.GetComponent<UIEffectBase> ();
// if (modifier == null)
// {
// Debug.Log ("UIEffectMaterialResolver modifier is null");
// return baseMaterial;
// }
// Debug.Log ("UIEffectMaterialResolver !!! " + modifier);
// return modifier.GetModifiedMaterial (baseMaterial);
//}
public void ModifyMesh(Mesh mesh)
{
}
public void ModifyMesh(VertexHelper verts)
{
if (!isActiveAndEnabled)
{
return;
}
var modifier = transform.parent.GetComponent<BaseMaterialEffect>();
modifier.ModifyMesh(verts);
}
}
}
@@ -1,109 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
namespace Coffee.UIExtensions
{
/// <summary>
/// Dissolve effect for uGUI.
/// </summary>
[ExecuteInEditMode]
public class UIEffectMaterialResolver : MonoBehaviour, IMaterialModifier, IMeshModifier
{
[ContextMenu("test")]
void test()
{
GetComponent<Graphic> ().SetMaterialDirty ();
GetComponent<Graphic> ().SetVerticesDirty ();
}
Hash128 _effectMaterialHash;
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected void OnEnable ()
{
//GetComponent<Graphic> ().SetMaterialDirty ();
//GetComponent<Graphic> ().SetVerticesDirty ();
}
/// <summary>
/// This function is called when the behaviour becomes disabled () or inactive.
/// </summary>
protected void OnDisable ()
{
MaterialRepository.Unregister (_effectMaterialHash);
_effectMaterialHash = new Hash128 ();
//GetComponent<Graphic> ().SetMaterialDirty ();
//GetComponent<Graphic> ().SetVerticesDirty ();
}
protected Hash128 GetMaterialHash (Material material)
{
return new Hash128 ();
}
public Material GetModifiedMaterial (Material baseMaterial)
{
if (!isActiveAndEnabled)
{
return baseMaterial;
}
var modifier = transform.parent.GetComponent<UIEffectBase> ();
var oldHash = _effectMaterialHash;
_effectMaterialHash = modifier.GetMaterialHash (baseMaterial);
var modifiedMaterial = baseMaterial;
if (_effectMaterialHash.isValid)
{
modifiedMaterial = MaterialRepository.Register (baseMaterial, _effectMaterialHash, modifier.ModifyMaterial);
}
MaterialRepository.Unregister (oldHash);
return modifiedMaterial;
}
//public Material GetModifiedMaterial2 (Material baseMaterial)
//{
// Debug.Log ("UIEffectMaterialResolver 0");
// if (!isActiveAndEnabled)
// return baseMaterial;
// var parent = transform.parent;
// if (!parent)
// return baseMaterial;
// var modifier = parent.GetComponent<UIEffectBase> ();
// if (modifier == null)
// {
// Debug.Log ("UIEffectMaterialResolver modifier is null");
// return baseMaterial;
// }
// Debug.Log ("UIEffectMaterialResolver !!! " + modifier);
// return modifier.GetModifiedMaterial (baseMaterial);
//}
public void ModifyMesh (Mesh mesh)
{
}
public void ModifyMesh (VertexHelper verts)
{
if (!isActiveAndEnabled)
{
return;
}
var modifier = transform.parent.GetComponent<UIEffectBase> ();
modifier.ModifyMesh (verts);
}
}
}
@@ -5,57 +5,63 @@ using UnityEngine.UI;
namespace Coffee.UIExtensions
{
[DisallowMultipleComponent]
[AddComponentMenu("UI/UIEffects/UIFlip", 102)]
public class UIFlip : BaseMeshEffect
{
[Tooltip("Flip horizontally.")] [SerializeField]
private bool m_Horizontal = false;
//[RequireComponent(typeof(Graphic))]
[DisallowMultipleComponent]
[AddComponentMenu("UI/MeshEffectForTextMeshPro/UIFlip", 102)]
public class UIFlip : BaseMeshEffect
{
//################################
// Serialize Members.
//################################
[Tooltip("Flip vertically.")] [SerializeField]
private bool m_Veritical = false;
[Tooltip("Flip horizontally.")]
[SerializeField] private bool m_Horizontal = false;
/// <summary>
/// Gets or sets a value indicating whether this <see cref="Coffee.UIExtensions.UIFlip"/> should be flipped horizontally.
/// </summary>
/// <value><c>true</c> if be flipped horizontally; otherwise, <c>false</c>.</value>
public bool horizontal
{
get { return m_Horizontal; }
set
{
if (m_Horizontal == value) return;
m_Horizontal = value;
SetEffectParamsDirty();
}
}
[Tooltip("Flip vertically.")]
[SerializeField] private bool m_Veritical = false;
/// <summary>
/// Gets or sets a value indicating whether this <see cref="Coffee.UIExtensions.UIFlip"/> should be flipped vertically.
/// </summary>
/// <value><c>true</c> if be flipped horizontally; otherwise, <c>false</c>.</value>
public bool vertical
{
get { return m_Veritical; }
set
{
if (m_Veritical == value) return;
m_Veritical = value;
SetEffectParamsDirty();
}
}
//################################
// Public Members.
//################################
/// <summary>
/// Gets or sets a value indicating whether this <see cref="Coffee.UIExtensions.UIFlip"/> should be flipped horizontally.
/// </summary>
/// <value><c>true</c> if be flipped horizontally; otherwise, <c>false</c>.</value>
public bool horizontal { get { return this.m_Horizontal; } set { this.m_Horizontal = value; SetVerticesDirty (); } }
/// <summary>
/// Gets or sets a value indicating whether this <see cref="Coffee.UIExtensions.UIFlip"/> should be flipped vertically.
/// </summary>
/// <value><c>true</c> if be flipped horizontally; otherwise, <c>false</c>.</value>
public bool vertical { get { return this.m_Veritical; } set { this.m_Veritical = value; SetVerticesDirty (); } }
/// <summary>
/// Call used to modify mesh.
/// </summary>
/// <param name="vh">VertexHelper.</param>
public override void ModifyMesh(VertexHelper vh)
{
RectTransform rt = graphic.rectTransform;
UIVertex vt = default(UIVertex);
Vector3 pos;
Vector2 center = rt.rect.center;
for (int i = 0; i < vh.currentVertCount; i++)
{
vh.PopulateUIVertex(ref vt, i);
pos = vt.position;
vt.position = new Vector3(
m_Horizontal ? -pos.x : pos.x,
m_Veritical ? -pos.y : pos.y
);
vh.SetUIVertex(vt, i);
}
}
}
}
/// <summary>
/// Call used to modify mesh.
/// </summary>
/// <param name="vh">VertexHelper.</param>
public override void ModifyMesh(VertexHelper vh)
{
var vt = default(UIVertex);
for (var i = 0; i < vh.currentVertCount; i++)
{
vh.PopulateUIVertex(ref vt, i);
var pos = vt.position;
vt.position = new Vector3(
m_Horizontal ? -pos.x : pos.x,
m_Veritical ? -pos.y : pos.y
);
vh.SetUIVertex(vt, i);
}
}
}
}
@@ -3,384 +3,317 @@ using UnityEngine.UI;
namespace Coffee.UIExtensions
{
/// <summary>
/// UIGradient.
/// </summary>
[DisallowMultipleComponent]
[AddComponentMenu("UI/MeshEffectForTextMeshPro/UIGradient", 101)]
public class UIGradient : BaseMeshEffect
{
//################################
// Constant or Static Members.
//################################
/// <summary>
/// UIGradient.
/// </summary>
[DisallowMultipleComponent]
[AddComponentMenu("UI/UIEffects/UIGradient", 101)]
public class UIGradient : BaseMeshEffect
{
static readonly Vector2[] s_SplitedCharacterPosition = {Vector2.up, Vector2.one, Vector2.right, Vector2.zero};
/// <summary>
/// Gradient direction.
/// </summary>
public enum Direction
{
Horizontal,
Vertical,
Angle,
Diagonal,
}
/// <summary>
/// Gradient direction.
/// </summary>
public enum Direction
{
Horizontal,
Vertical,
Angle,
Diagonal,
}
/// <summary>
/// Gradient space for Text.
/// </summary>
public enum GradientStyle
{
Rect,
Fit,
Split,
}
/// <summary>
/// Gradient space for Text.
/// </summary>
public enum GradientStyle
{
Rect,
Fit,
Split,
}
//################################
// Serialize Members.
//################################
[Tooltip("Gradient Direction.")] [SerializeField]
Direction m_Direction;
[Tooltip("Gradient Direction.")]
[SerializeField] Direction m_Direction;
[Tooltip("Color1: Top or Left.")] [SerializeField]
Color m_Color1 = Color.white;
[Tooltip("Color1: Top or Left.")]
[SerializeField] Color m_Color1 = Color.white;
[Tooltip("Color2: Bottom or Right.")] [SerializeField]
Color m_Color2 = Color.white;
[Tooltip("Color2: Bottom or Right.")]
[SerializeField] Color m_Color2 = Color.white;
[Tooltip("Color3: For diagonal.")] [SerializeField]
Color m_Color3 = Color.white;
[Tooltip("Color3: For diagonal.")]
[SerializeField] Color m_Color3 = Color.white;
[Tooltip("Color4: For diagonal.")] [SerializeField]
Color m_Color4 = Color.white;
[Tooltip("Color4: For diagonal.")]
[SerializeField] Color m_Color4 = Color.white;
[Tooltip("Gradient rotation.")] [SerializeField] [Range(-180, 180)]
float m_Rotation;
[Tooltip("Gradient rotation.")]
[SerializeField][Range(-180, 180)] float m_Rotation;
[Tooltip("Gradient offset for Horizontal, Vertical or Angle.")] [SerializeField] [Range(-1, 1)]
float m_Offset1;
[Tooltip("Gradient offset for Horizontal, Vertical or Angle.")]
[SerializeField][Range(-1, 1)] float m_Offset1;
[Tooltip("Gradient offset for Diagonal.")] [SerializeField] [Range(-1, 1)]
float m_Offset2;
[Tooltip("Gradient offset for Diagonal.")]
[SerializeField][Range(-1, 1)] float m_Offset2;
[Tooltip("Gradient style for Text.")] [SerializeField]
GradientStyle m_GradientStyle;
[Tooltip("Gradient style for Text.")]
[SerializeField] GradientStyle m_GradientStyle;
[Tooltip("Color space to correct color.")] [SerializeField]
ColorSpace m_ColorSpace = ColorSpace.Uninitialized;
[Tooltip("Color space to correct color.")]
[SerializeField] ColorSpace m_ColorSpace = ColorSpace.Uninitialized;
[Tooltip("Ignore aspect ratio.")] [SerializeField]
bool m_IgnoreAspectRatio = true;
[Tooltip("Ignore aspect ratio.")]
[SerializeField] bool m_IgnoreAspectRatio = true;
/// <summary>
/// Gradient Direction.
/// </summary>
public Direction direction
{
get { return m_Direction; }
set
{
if (m_Direction == value) return;
m_Direction = value;
SetVerticesDirty();
}
}
/// <summary>
/// Color1: Top or Left.
/// </summary>
public Color color1
{
get { return m_Color1; }
set
{
if (m_Color1 == value) return;
m_Color1 = value;
SetVerticesDirty();
}
}
//################################
// Public Members.
//################################
public Graphic targetGraphic { get { return base.graphic; } }
/// <summary>
/// Color2: Bottom or Right.
/// </summary>
public Color color2
{
get { return m_Color2; }
set
{
if (m_Color2 == value) return;
m_Color2 = value;
SetVerticesDirty();
}
}
/// <summary>
/// Gradient Direction.
/// </summary>
public Direction direction
{
get { return m_Direction; }
set
{
if (m_Direction != value)
{
m_Direction = value;
SetVerticesDirty();
}
}
}
/// <summary>
/// Color3: For diagonal.
/// </summary>
public Color color3
{
get { return m_Color3; }
set
{
if (m_Color3 == value) return;
m_Color3 = value;
SetVerticesDirty();
}
}
/// <summary>
/// Color1: Top or Left.
/// </summary>
public Color color1
{
get { return m_Color1; }
set
{
if (m_Color1 != value)
{
m_Color1 = value;
SetVerticesDirty();
}
}
}
/// <summary>
/// Color4: For diagonal.
/// </summary>
public Color color4
{
get { return m_Color4; }
set
{
if (m_Color4 == value) return;
m_Color4 = value;
SetVerticesDirty();
}
}
/// <summary>
/// Color2: Bottom or Right.
/// </summary>
public Color color2
{
get { return m_Color2; }
set
{
if (m_Color2 != value)
{
m_Color2 = value;
SetVerticesDirty();
}
}
}
/// <summary>
/// Gradient rotation.
/// </summary>
public float rotation
{
get
{
return m_Direction == Direction.Horizontal ? -90
: m_Direction == Direction.Vertical ? 0
: m_Rotation;
}
set
{
if (Mathf.Approximately(m_Rotation, value)) return;
m_Rotation = value;
SetVerticesDirty();
}
}
/// <summary>
/// Color3: For diagonal.
/// </summary>
public Color color3
{
get { return m_Color3; }
set
{
if (m_Color3 != value)
{
m_Color3 = value;
SetVerticesDirty();
}
}
}
/// <summary>
/// Gradient offset for Horizontal, Vertical or Angle.
/// </summary>
public float offset
{
get { return m_Offset1; }
set
{
if (Mathf.Approximately(m_Offset1, value)) return;
m_Offset1 = value;
SetVerticesDirty();
}
}
/// <summary>
/// Color4: For diagonal.
/// </summary>
public Color color4
{
get { return m_Color4; }
set
{
if (m_Color4 != value)
{
m_Color4 = value;
SetVerticesDirty();
}
}
}
/// <summary>
/// Gradient offset for Diagonal.
/// </summary>
public Vector2 offset2
{
get { return new Vector2(m_Offset2, m_Offset1); }
set
{
if (Mathf.Approximately(m_Offset1, value.y) && Mathf.Approximately(m_Offset2, value.x)) return;
m_Offset1 = value.y;
m_Offset2 = value.x;
SetVerticesDirty();
}
}
/// <summary>
/// Gradient rotation.
/// </summary>
public float rotation
{
get
{
return m_Direction == Direction.Horizontal ? -90
: m_Direction == Direction.Vertical ? 0
: m_Rotation;
}
set
{
if (!Mathf.Approximately(m_Rotation, value))
{
m_Rotation = value;
SetVerticesDirty();
}
}
}
/// <summary>
/// Gradient style for Text.
/// </summary>
public GradientStyle gradientStyle
{
get { return m_GradientStyle; }
set
{
if (m_GradientStyle == value) return;
m_GradientStyle = value;
SetVerticesDirty();
}
}
/// <summary>
/// Gradient offset for Horizontal, Vertical or Angle.
/// </summary>
public float offset
{
get { return m_Offset1; }
set
{
if (m_Offset1 != value)
{
m_Offset1 = value;
SetVerticesDirty();
}
}
}
/// <summary>
/// Color space to correct color.
/// </summary>
public ColorSpace colorSpace
{
get { return m_ColorSpace; }
set
{
if (m_ColorSpace == value) return;
m_ColorSpace = value;
SetVerticesDirty();
}
}
/// <summary>
/// Gradient offset for Diagonal.
/// </summary>
public Vector2 offset2
{
get { return new Vector2(m_Offset2, m_Offset1); }
set
{
if (m_Offset1 != value.y || m_Offset2 != value.x)
{
m_Offset1 = value.y;
m_Offset2 = value.x;
SetVerticesDirty();
}
}
}
/// <summary>
/// Ignore aspect ratio.
/// </summary>
public bool ignoreAspectRatio
{
get { return m_IgnoreAspectRatio; }
set
{
if (m_IgnoreAspectRatio == value) return;
m_IgnoreAspectRatio = value;
SetVerticesDirty();
}
}
/// <summary>
/// Gradient style for Text.
/// </summary>
public GradientStyle gradientStyle
{
get { return m_GradientStyle; }
set
{
if (m_GradientStyle != value)
{
m_GradientStyle = value;
SetVerticesDirty();
}
}
}
/// <summary>
/// Call used to modify mesh.
/// </summary>
public override void ModifyMesh(VertexHelper vh)
{
if (!IsActive())
return;
/// <summary>
/// Color space to correct color.
/// </summary>
public ColorSpace colorSpace
{
get { return m_ColorSpace; }
set
{
if (m_ColorSpace != value)
{
m_ColorSpace = value;
SetVerticesDirty();
}
}
}
// Gradient space.
var rect = default(Rect);
var vertex = default(UIVertex);
switch (m_GradientStyle)
{
case GradientStyle.Rect:
// RectTransform.
rect = graphic.rectTransform.rect;
break;
case GradientStyle.Split:
// Each characters.
rect.Set(0, 0, 1, 1);
break;
case GradientStyle.Fit:
{
// Fit to contents.
rect.xMin = rect.yMin = float.MaxValue;
rect.xMax = rect.yMax = float.MinValue;
for (var i = 0; i < vh.currentVertCount; i++)
{
vh.PopulateUIVertex(ref vertex, i);
rect.xMin = Mathf.Min(rect.xMin, vertex.position.x);
rect.yMin = Mathf.Min(rect.yMin, vertex.position.y);
rect.xMax = Mathf.Max(rect.xMax, vertex.position.x);
rect.yMax = Mathf.Max(rect.yMax, vertex.position.y);
}
/// <summary>
/// Ignore aspect ratio.
/// </summary>
public bool ignoreAspectRatio
{
get { return m_IgnoreAspectRatio; }
set
{
if (m_IgnoreAspectRatio != value)
{
m_IgnoreAspectRatio = value;
SetVerticesDirty();
}
}
}
break;
}
}
// Gradient rotation.
var rad = rotation * Mathf.Deg2Rad;
var dir = new Vector2(Mathf.Cos(rad), Mathf.Sin(rad));
if (!m_IgnoreAspectRatio && Direction.Angle <= m_Direction)
{
dir.x *= rect.height / rect.width;
dir = dir.normalized;
}
/// <summary>
/// Call used to modify mesh.
/// </summary>
public override void ModifyMesh(VertexHelper vh)
{
if (!IsActive())
return;
// Calculate vertex color.
var localMatrix = new Matrix2x3(rect, dir.x, dir.y); // Get local matrix.
for (var i = 0; i < vh.currentVertCount; i++)
{
vh.PopulateUIVertex(ref vertex, i);
// Gradient space.
Rect rect = default(Rect);
UIVertex vertex = default(UIVertex);
if (m_GradientStyle == GradientStyle.Rect)
{
// RectTransform.
rect = graphic.rectTransform.rect;
}
else if (m_GradientStyle == GradientStyle.Split)
{
// Each characters.
rect.Set(0, 0, 1, 1);
}
else if (m_GradientStyle == GradientStyle.Fit)
{
// Fit to contents.
rect.xMin = rect.yMin = float.MaxValue;
rect.xMax = rect.yMax = float.MinValue;
for (int i = 0; i < vh.currentVertCount; i++)
{
vh.PopulateUIVertex(ref vertex, i);
rect.xMin = Mathf.Min(rect.xMin, vertex.position.x);
rect.yMin = Mathf.Min(rect.yMin, vertex.position.y);
rect.xMax = Mathf.Max(rect.xMax, vertex.position.x);
rect.yMax = Mathf.Max(rect.yMax, vertex.position.y);
}
}
// Normalize vertex position by local matrix.
Vector2 normalizedPos;
if (m_GradientStyle == GradientStyle.Split)
{
// Each characters.
normalizedPos = localMatrix * s_SplitedCharacterPosition[i % 4] + offset2;
}
else
{
normalizedPos = localMatrix * vertex.position + offset2;
}
// Gradient rotation.
float rad = rotation * Mathf.Deg2Rad;
Vector2 dir = new Vector2(Mathf.Cos(rad), Mathf.Sin(rad));
if (!m_IgnoreAspectRatio && Direction.Angle <= m_Direction)
{
dir.x *= rect.height / rect.width;
dir = dir.normalized;
}
// Interpolate vertex color.
Color color;
if (direction == Direction.Diagonal)
{
color = Color.LerpUnclamped(
Color.LerpUnclamped(m_Color1, m_Color2, normalizedPos.x),
Color.LerpUnclamped(m_Color3, m_Color4, normalizedPos.x),
normalizedPos.y);
}
else
{
color = Color.LerpUnclamped(m_Color2, m_Color1, normalizedPos.y);
}
// Calculate vertex color.
Color color;
Vector2 nomalizedPos;
Matrix2x3 localMatrix = new Matrix2x3(rect, dir.x, dir.y); // Get local matrix.
for (int i = 0; i < vh.currentVertCount; i++)
{
vh.PopulateUIVertex(ref vertex, i);
// Correct color.
vertex.color *= (m_ColorSpace == ColorSpace.Gamma) ? color.gamma
: (m_ColorSpace == ColorSpace.Linear) ? color.linear
: color;
// Normalize vertex position by local matrix.
if (m_GradientStyle == GradientStyle.Split)
{
// Each characters.
nomalizedPos = localMatrix * s_SplitedCharacterPosition[i % 4] + offset2;
}
else
{
nomalizedPos = localMatrix * vertex.position + offset2;
}
// Interpolate vertex color.
if (direction == Direction.Diagonal)
{
color = Color.LerpUnclamped(
Color.LerpUnclamped(m_Color1, m_Color2, nomalizedPos.x),
Color.LerpUnclamped(m_Color3, m_Color4, nomalizedPos.x),
nomalizedPos.y);
}
else
{
color = Color.LerpUnclamped(m_Color2, m_Color1, nomalizedPos.y);
}
// Correct color.
vertex.color *= (m_ColorSpace == ColorSpace.Gamma) ? color.gamma
: (m_ColorSpace == ColorSpace.Linear) ? color.linear
: color;
vh.SetUIVertex(vertex, i);
}
}
//################################
// Private Members.
//################################
static readonly Vector2[] s_SplitedCharacterPosition = { Vector2.up, Vector2.one, Vector2.right, Vector2.zero };
/// <summary>
/// Matrix2x3.
/// </summary>
struct Matrix2x3
{
public float m00, m01, m02, m10, m11, m12;
public Matrix2x3(Rect rect, float cos, float sin)
{
const float center = 0.5f;
float dx = -rect.xMin / rect.width - center;
float dy = -rect.yMin / rect.height - center;
m00 = cos / rect.width;
m01 = -sin / rect.height;
m02 = dx * cos - dy * sin + center;
m10 = sin / rect.width;
m11 = cos / rect.height;
m12 = dx * sin + dy * cos + center;
}
public static Vector2 operator*(Matrix2x3 m, Vector2 v)
{
return new Vector2(
(m.m00 * v.x) + (m.m01 * v.y) + m.m02,
(m.m10 * v.x) + (m.m11 * v.y) + m.m12
);
}
}
}
vh.SetUIVertex(vertex, i);
}
}
}
}
@@ -1,4 +1,4 @@
using System;
using System;
using UnityEngine;
using UnityEngine.Serialization;
using UnityEngine.UI;
@@ -6,238 +6,163 @@ using UnityEngine.UI;
namespace Coffee.UIExtensions
{
/// <summary>
/// HSV Modifier.
/// </summary>
[AddComponentMenu("UI/UIEffect/UIHsvModifier", 4)]
public class UIHsvModifier : UIEffectBase
{
//################################
// Constant or Static Members.
//################################
public const string shaderName = "UI/Hidden/UI-Effect-HSV";
static readonly ParameterTexture _ptex = new ParameterTexture(7, 128, "_ParamTex");
/// <summary>
/// HSV Modifier.
/// </summary>
[AddComponentMenu("UI/UIEffects/UIHsvModifier", 4)]
public class UIHsvModifier : BaseMaterialEffect
{
private const uint k_ShaderId = 6 << 3;
private static readonly ParameterTexture s_ParamTex = new ParameterTexture(7, 128, "_ParamTex");
[Header("Target")] [Tooltip("Target color to affect hsv shift.")] [SerializeField] [ColorUsage(false)]
Color m_TargetColor = Color.red;
//################################
// Serialize Members.
//################################
[Header("Target")]
[Tooltip("Color range to affect hsv shift [0 ~ 1].")] [SerializeField] [Range(0, 1)]
float m_Range = 0.1f;
[Tooltip("Target color to affect hsv shift.")]
[SerializeField] [ColorUsage(false)] Color m_TargetColor = Color.red;
[Header("Adjustment")] [Tooltip("Hue shift [-0.5 ~ 0.5].")] [SerializeField] [Range(-0.5f, 0.5f)]
float m_Hue;
[Tooltip("Color range to affect hsv shift [0 ~ 1].")]
[SerializeField] [Range(0, 1)] float m_Range = 0.1f;
[Tooltip("Saturation shift [-0.5 ~ 0.5].")] [SerializeField] [Range(-0.5f, 0.5f)]
float m_Saturation;
[Header("Adjustment")]
[Tooltip("Value shift [-0.5 ~ 0.5].")] [SerializeField] [Range(-0.5f, 0.5f)]
float m_Value;
[Tooltip("Hue shift [-0.5 ~ 0.5].")]
[SerializeField] [Range(-0.5f, 0.5f)] float m_Hue;
/// <summary>
/// Target color to affect hsv shift.
/// </summary>
public Color targetColor
{
get { return m_TargetColor; }
set
{
if (m_TargetColor == value) return;
m_TargetColor = value;
SetEffectParamsDirty();
}
}
[Tooltip("Saturation shift [-0.5 ~ 0.5].")]
[SerializeField] [Range(-0.5f, 0.5f)] float m_Saturation;
/// <summary>
/// Color range to affect hsv shift [0 ~ 1].
/// </summary>
public float range
{
get { return m_Range; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (Mathf.Approximately(m_Range, value)) return;
m_Range = value;
SetEffectParamsDirty();
}
}
[Tooltip("Value shift [-0.5 ~ 0.5].")]
[SerializeField] [Range(-0.5f, 0.5f)] float m_Value;
/// <summary>
/// Saturation shift [-0.5 ~ 0.5].
/// </summary>
public float saturation
{
get { return m_Saturation; }
set
{
value = Mathf.Clamp(value, -0.5f, 0.5f);
if (Mathf.Approximately(m_Saturation, value)) return;
m_Saturation = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Value shift [-0.5 ~ 0.5].
/// </summary>
public float value
{
get { return m_Value; }
set
{
value = Mathf.Clamp(value, -0.5f, 0.5f);
if (Mathf.Approximately(m_Value, value)) return;
m_Value = value;
SetEffectParamsDirty();
}
}
//################################
// Public Members.
//################################
/// <summary>
/// Hue shift [-0.5 ~ 0.5].
/// </summary>
public float hue
{
get { return m_Hue; }
set
{
value = Mathf.Clamp(value, -0.5f, 0.5f);
if (Mathf.Approximately(m_Hue, value)) return;
m_Hue = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Target color to affect hsv shift.
/// </summary>
public Color targetColor
{
get { return m_TargetColor; }
set
{
if (m_TargetColor != value)
{
m_TargetColor = value;
SetEffectDirty ();
}
}
}
/// <summary>
/// Gets the parameter texture.
/// </summary>
public override ParameterTexture paramTex
{
get { return s_ParamTex; }
}
/// <summary>
/// Color range to affect hsv shift [0 ~ 1].
/// </summary>
public float range
{
get { return m_Range; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_Range, value))
{
m_Range = value;
SetEffectDirty ();
}
}
}
public override Hash128 GetMaterialHash(Material material)
{
if (!isActiveAndEnabled || !material || !material.shader)
return k_InvalidHash;
/// <summary>
/// Saturation shift [-0.5 ~ 0.5].
/// </summary>
public float saturation
{
get { return m_Saturation; }
set
{
value = Mathf.Clamp(value, -0.5f, 0.5f);
if (!Mathf.Approximately(m_Saturation, value))
{
m_Saturation = value;
SetEffectDirty ();
}
}
}
return new Hash128(
(uint) material.GetInstanceID(),
k_ShaderId,
0,
0
);
}
/// <summary>
/// Value shift [-0.5 ~ 0.5].
/// </summary>
public float value
{
get { return m_Value; }
set
{
value = Mathf.Clamp(value, -0.5f, 0.5f);
if (!Mathf.Approximately(m_Value, value))
{
m_Value = value;
SetEffectDirty ();
}
}
}
public override void ModifyMaterial(Material newMaterial)
{
newMaterial.shader = connector.FindShader("UIHsvModifier");
paramTex.RegisterMaterial(newMaterial);
}
/// <summary>
/// Hue shift [-0.5 ~ 0.5].
/// </summary>
public float hue
{
get { return m_Hue; }
set
{
value = Mathf.Clamp(value, -0.5f, 0.5f);
if (!Mathf.Approximately(m_Hue, value))
{
m_Hue = value;
SetEffectDirty ();
}
}
}
public override void ModifyMesh(VertexHelper vh)
{
if (!isActiveAndEnabled)
return;
/// <summary>
/// Gets the parameter texture.
/// </summary>
public override ParameterTexture ptex { get { return _ptex; } }
var normalizedIndex = paramTex.GetNormalizedIndex(this);
var vertex = default(UIVertex);
var count = vh.currentVertCount;
for (var i = 0; i < count; i++)
{
vh.PopulateUIVertex(ref vertex, i);
public override Hash128 GetMaterialHash (Material material)
{
if (!isActiveAndEnabled || !material || !material.shader)
return new Hash128 ();
vertex.uv0 = new Vector2(
Packer.ToFloat(vertex.uv0.x, vertex.uv0.y),
normalizedIndex
);
vh.SetUIVertex(vertex, i);
}
}
uint materialId = (uint)material.GetInstanceID ();
uint shaderId = 6 << 3;
protected override void SetEffectParamsDirty()
{
float h, s, v;
Color.RGBToHSV(m_TargetColor, out h, out s, out v);
string materialShaderName = material.shader.name;
if (materialShaderName.StartsWith ("TextMeshPro/Mobile/", StringComparison.Ordinal))
{
shaderId += 2;
}
else if (materialShaderName.Equals ("TextMeshPro/Sprite", StringComparison.Ordinal))
{
shaderId += 0;
}
else if (materialShaderName.StartsWith ("TextMeshPro/", StringComparison.Ordinal))
{
shaderId += 1;
}
else
{
shaderId += 0;
}
return new Hash128 (
materialId,
shaderId,
0,
0
);
}
public override void ModifyMaterial (Material material)
{
string materialShaderName = material.shader.name;
if (materialShaderName.StartsWith ("TextMeshPro/Mobile/", StringComparison.Ordinal))
{
material.shader = Shader.Find ("TextMeshPro/Mobile/Distance Field (UIHsvModifier)");
}
else if (materialShaderName.Equals ("TextMeshPro/Sprite", StringComparison.Ordinal))
{
material.shader = Shader.Find ("UI/Hidden/UI-Effect-HSV");
}
else if (materialShaderName.StartsWith ("TextMeshPro/", StringComparison.Ordinal))
{
material.shader = Shader.Find ("TextMeshPro/Distance Field (UIHsvModifier)");
}
else
{
material.shader = Shader.Find ("UI/Hidden/UI-Effect-HSV");
}
ptex.RegisterMaterial (material);
}
#if UNITY_EDITOR
protected override Material GetMaterial()
{
return null;
}
#endif
/// <summary>
/// Modifies the mesh.
/// </summary>
public override void ModifyMesh(VertexHelper vh)
{
if (!isActiveAndEnabled)
return;
float normalizedIndex = ptex.GetNormalizedIndex(this);
UIVertex vertex = default(UIVertex);
int count = vh.currentVertCount;
for (int i = 0; i < count; i++)
{
vh.PopulateUIVertex(ref vertex, i);
vertex.uv0 = new Vector2(
Packer.ToFloat(vertex.uv0.x, vertex.uv0.y),
normalizedIndex
);
vh.SetUIVertex(vertex, i);
}
}
protected override void SetEffectDirty ()
{
float h, s, v;
Color.RGBToHSV(m_TargetColor, out h, out s, out v);
ptex.SetData(this, 0, h); // param1.x : target hue
ptex.SetData(this, 1, s); // param1.y : target saturation
ptex.SetData(this, 2, v); // param1.z : target value
ptex.SetData(this, 3, m_Range); // param1.w : target range
ptex.SetData(this, 4, m_Hue + 0.5f); // param2.x : hue shift
ptex.SetData(this, 5, m_Saturation + 0.5f); // param2.y : saturation shift
ptex.SetData(this, 6, m_Value + 0.5f); // param2.z : value shift
}
//################################
// Private Members.
//################################
}
paramTex.SetData(this, 0, h); // param1.x : target hue
paramTex.SetData(this, 1, s); // param1.y : target saturation
paramTex.SetData(this, 2, v); // param1.z : target value
paramTex.SetData(this, 3, m_Range); // param1.w : target range
paramTex.SetData(this, 4, m_Hue + 0.5f); // param2.x : hue shift
paramTex.SetData(this, 5, m_Saturation + 0.5f); // param2.y : saturation shift
paramTex.SetData(this, 6, m_Value + 0.5f); // param2.z : value shift
}
}
}
@@ -3,459 +3,381 @@ using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Serialization;
using UnityEngine.UI;
#if UNITY_EDITOR
using System.IO;
using System.Linq;
using UnityEditor;
#endif
namespace Coffee.UIExtensions
{
/// <summary>
/// UIEffect.
/// </summary>
[RequireComponent(typeof(Graphic))]
[AddComponentMenu("UI/UIEffect/UIShadow", 100)]
public class UIShadow : BaseMeshEffect, IParameterTexture
#if UNITY_EDITOR
, ISerializationCallbackReceiver
#endif
{
/// <summary>
/// Additional shadow.
/// </summary>
[System.Obsolete]
[System.Serializable]
public class AdditionalShadow
{
/// <summary>
/// How far is the blurring shadow from the graphic.
/// </summary>
[FormerlySerializedAs("shadowBlur")]
[Range(0, 1)] public float blur = 0.25f;
/// <summary>
/// Shadow effect mode.
/// </summary>
[FormerlySerializedAs("shadowMode")]
public ShadowStyle style = ShadowStyle.Shadow;
/// <summary>
/// Color for the shadow effect.
/// </summary>
[FormerlySerializedAs("shadowColor")]
public Color effectColor = Color.black;
/// <summary>
/// How far is the shadow from the graphic.
/// </summary>
public Vector2 effectDistance = new Vector2(1f, -1f);
/// <summary>
/// Should the shadow inherit the alpha from the graphic?
/// </summary>
public bool useGraphicAlpha = true;
}
//################################
// Serialize Members.
//################################
[Tooltip("How far is the blurring shadow from the graphic.")]
[FormerlySerializedAs("m_Blur")]
[SerializeField][Range(0, 1)] float m_BlurFactor = 1;
[Tooltip("Shadow effect style.")]
[SerializeField] ShadowStyle m_Style = ShadowStyle.Shadow;
#pragma warning disable 0414
[HideInInspector][System.Obsolete]
[SerializeField] List<AdditionalShadow> m_AdditionalShadows = new List<AdditionalShadow>();
#pragma warning restore 0414
[SerializeField]
private Color m_EffectColor = new Color (0f, 0f, 0f, 0.5f);
[SerializeField]
private Vector2 m_EffectDistance = new Vector2 (1f, -1f);
[SerializeField]
private bool m_UseGraphicAlpha = true;
private const float kMaxEffectDistance = 600f;
public Color effectColor
{
get { return m_EffectColor; }
set
{
m_EffectColor = value;
if (graphic != null)
graphic.SetVerticesDirty ();
}
}
public Vector2 effectDistance
{
get { return m_EffectDistance; }
set
{
if (value.x > kMaxEffectDistance)
value.x = kMaxEffectDistance;
if (value.x < -kMaxEffectDistance)
value.x = -kMaxEffectDistance;
if (value.y > kMaxEffectDistance)
value.y = kMaxEffectDistance;
if (value.y < -kMaxEffectDistance)
value.y = -kMaxEffectDistance;
if (m_EffectDistance == value)
return;
m_EffectDistance = value;
if (graphic != null)
graphic.SetVerticesDirty ();
}
}
public bool useGraphicAlpha
{
get { return m_UseGraphicAlpha; }
set
{
m_UseGraphicAlpha = value;
if (graphic != null)
graphic.SetVerticesDirty ();
}
}
//################################
// Public Members.
//################################
/// <summary>
/// How far is the blurring shadow from the graphic.
/// </summary>
[System.Obsolete("Use blurFactor instead (UnityUpgradable) -> blurFactor")]
public float blur
{
get { return m_BlurFactor; }
set
{
m_BlurFactor = Mathf.Clamp(value, 0, 2);
_SetDirty();
}
}
/// <summary>
/// How far is the blurring shadow from the graphic.
/// </summary>
public float blurFactor
{
get { return m_BlurFactor; }
set
{
m_BlurFactor = Mathf.Clamp(value, 0, 2);
_SetDirty();
}
}
/// <summary>
/// Shadow effect style.
/// </summary>
public ShadowStyle style
{
get { return m_Style; }
set
{
m_Style = value;
_SetDirty();
}
}
/// <summary>
/// Gets or sets the parameter index.
/// </summary>
public int parameterIndex { get; set; }
/// <summary>
/// Gets the parameter texture.
/// </summary>
public ParameterTexture ptex{ get; private set; }
int _graphicVertexCount;
static readonly List<UIShadow> tmpShadows = new List<UIShadow>();
protected override void OnEnable()
{
base.OnEnable();
_uiEffect = GetComponent<UIEffect>();
if (_uiEffect)
{
ptex = _uiEffect.ptex;
ptex.Register(this);
}
#if TMP_PRESENT
if (isTMPro)
{
textMeshPro.onCullStateChanged.AddListener (OnCullStateChanged);
}
#endif
}
protected override void OnDisable()
{
base.OnDisable();
_uiEffect = null;
if (ptex != null)
{
ptex.Unregister(this);
ptex = null;
}
}
#if UNITY_EDITOR
protected override void OnValidate ()
{
effectDistance = m_EffectDistance;
base.OnValidate ();
}
#endif
#if TMP_PRESENT
protected void OnCullStateChanged (bool state)
{
SetVerticesDirty ();
}
Vector2 res;
protected override void LateUpdate ()
{
if (res.x != Screen.width || res.y != Screen.height)
{
res.x = Screen.width;
res.y = Screen.height;
SetVerticesDirty ();
}
if (textMeshPro && transform.hasChanged)
{
transform.hasChanged = false;
}
base.LateUpdate ();
}
#endif
/// <summary>
/// Modifies the mesh.
/// </summary>
public override void ModifyMesh(VertexHelper vh)
{
if (!isActiveAndEnabled || vh.currentVertCount <= 0 || m_Style == ShadowStyle.None)
{
return;
}
vh.GetUIVertexStream(s_Verts);
GetComponents<UIShadow>(tmpShadows);
foreach (var s in tmpShadows)
{
if (s.isActiveAndEnabled)
{
if (s == this)
{
foreach (var s2 in tmpShadows)
{
s2._graphicVertexCount = s_Verts.Count;
}
}
break;
}
}
tmpShadows.Clear();
//================================
// Append shadow vertices.
//================================
{
_uiEffect = _uiEffect ?? GetComponent<UIEffect>();
var start = s_Verts.Count - _graphicVertexCount;
var end = s_Verts.Count;
if (ptex != null && _uiEffect && _uiEffect.isActiveAndEnabled)
{
ptex.SetData(this, 0, _uiEffect.effectFactor); // param.x : effect factor
ptex.SetData(this, 1, 255); // param.y : color factor
ptex.SetData(this, 2, m_BlurFactor); // param.z : blur factor
}
_ApplyShadow(s_Verts, effectColor, ref start, ref end, effectDistance, style, useGraphicAlpha);
}
vh.Clear();
vh.AddUIVertexTriangleStream(s_Verts);
s_Verts.Clear();
}
UIEffect _uiEffect;
//################################
// Private Members.
//################################
static readonly List<UIVertex> s_Verts = new List<UIVertex>(4096);
/// <summary>
/// Append shadow vertices.
/// * It is similar to Shadow component implementation.
/// </summary>
void _ApplyShadow(List<UIVertex> verts, Color color, ref int start, ref int end, Vector2 effectDistance, ShadowStyle style, bool useGraphicAlpha)
{
if (style == ShadowStyle.None || color.a <= 0)
return;
// Append Shadow.
_ApplyShadowZeroAlloc(s_Verts, color, ref start, ref end, effectDistance.x, effectDistance.y, useGraphicAlpha);
// Append Shadow3.
if (ShadowStyle.Shadow3 == style)
{
_ApplyShadowZeroAlloc(s_Verts, color, ref start, ref end, effectDistance.x, 0, useGraphicAlpha);
_ApplyShadowZeroAlloc(s_Verts, color, ref start, ref end, 0, effectDistance.y, useGraphicAlpha);
}
// Append Outline.
else if (ShadowStyle.Outline == style)
{
_ApplyShadowZeroAlloc(s_Verts, color, ref start, ref end, effectDistance.x, -effectDistance.y, useGraphicAlpha);
_ApplyShadowZeroAlloc(s_Verts, color, ref start, ref end, -effectDistance.x, effectDistance.y, useGraphicAlpha);
_ApplyShadowZeroAlloc(s_Verts, color, ref start, ref end, -effectDistance.x, -effectDistance.y, useGraphicAlpha);
}
// Append Outline8.
else if (ShadowStyle.Outline8 == style)
{
_ApplyShadowZeroAlloc(s_Verts, color, ref start, ref end, effectDistance.x, -effectDistance.y, useGraphicAlpha);
_ApplyShadowZeroAlloc(s_Verts, color, ref start, ref end, -effectDistance.x, effectDistance.y, useGraphicAlpha);
_ApplyShadowZeroAlloc(s_Verts, color, ref start, ref end, -effectDistance.x, -effectDistance.y, useGraphicAlpha);
_ApplyShadowZeroAlloc(s_Verts, color, ref start, ref end, -effectDistance.x, 0, useGraphicAlpha);
_ApplyShadowZeroAlloc(s_Verts, color, ref start, ref end, 0, -effectDistance.y, useGraphicAlpha);
_ApplyShadowZeroAlloc(s_Verts, color, ref start, ref end, effectDistance.x, 0, useGraphicAlpha);
_ApplyShadowZeroAlloc(s_Verts, color, ref start, ref end, 0, effectDistance.y, useGraphicAlpha);
}
}
/// <summary>
/// Append shadow vertices.
/// * It is similar to Shadow component implementation.
/// </summary>
void _ApplyShadowZeroAlloc(List<UIVertex> verts, Color color, ref int start, ref int end, float x, float y, bool useGraphicAlpha)
{
// Check list capacity.
int count = end - start;
var neededCapacity = verts.Count + count;
if (verts.Capacity < neededCapacity)
verts.Capacity *= 2;
float normalizedIndex = ptex != null && _uiEffect && _uiEffect.isActiveAndEnabled
? ptex.GetNormalizedIndex(this)
: -1;
// Add
UIVertex vt = default(UIVertex);
for (int i = 0; i < count; i++)
{
verts.Add(vt);
}
// Move
for (int i = verts.Count - 1; count <= i; i--)
{
verts[i] = verts[i - count];
}
// Append shadow vertices to the front of list.
// * The original vertex is pushed backward.
for (int i = 0; i < count; ++i)
{
vt = verts[i + start + count];
Vector3 v = vt.position;
vt.position.Set(v.x + x, v.y + y, v.z);
Color vertColor = effectColor;
vertColor.a = useGraphicAlpha ? color.a * vt.color.a / 255 : color.a;
vt.color = vertColor;
// Set UIEffect prameters
if (0 <= normalizedIndex)
{
vt.uv0 = new Vector2(
vt.uv0.x,
normalizedIndex
);
}
verts[i] = vt;
}
// Update next shadow offset.
start = end;
end = verts.Count;
}
/// <summary>
/// Mark the UIEffect as dirty.
/// </summary>
void _SetDirty()
{
if (graphic)
graphic.SetVerticesDirty();
}
#if UNITY_EDITOR
public void OnBeforeSerialize()
{
}
public void OnAfterDeserialize()
{
EditorApplication.delayCall += UpgradeIfNeeded;
}
#pragma warning disable 0612
void UpgradeIfNeeded()
{
if (0 < m_AdditionalShadows.Count)
{
foreach (var s in m_AdditionalShadows)
{
if (s.style == ShadowStyle.None)
{
continue;
}
var shadow = gameObject.AddComponent<UIShadow>();
shadow.style = s.style;
shadow.effectDistance = s.effectDistance;
shadow.effectColor = s.effectColor;
shadow.useGraphicAlpha = s.useGraphicAlpha;
shadow.blurFactor = s.blur;
}
m_AdditionalShadows = null;
}
}
#pragma warning restore 0612
#endif
}
/// <summary>
/// UIEffect.
/// </summary>
[RequireComponent(typeof(Graphic))]
[AddComponentMenu("UI/UIEffects/UIShadow", 100)]
public class UIShadow : BaseMeshEffect, IParameterTexture
{
static readonly List<UIShadow> tmpShadows = new List<UIShadow>();
static readonly List<UIVertex> s_Verts = new List<UIVertex>(4096);
int _graphicVertexCount;
UIEffect _uiEffect;
[Tooltip("How far is the blurring shadow from the graphic.")]
[FormerlySerializedAs("m_Blur")]
[SerializeField]
[Range(0, 1)]
float m_BlurFactor = 1;
[Tooltip("Shadow effect style.")] [SerializeField]
ShadowStyle m_Style = ShadowStyle.Shadow;
[SerializeField] private Color m_EffectColor = new Color(0f, 0f, 0f, 0.5f);
[SerializeField] private Vector2 m_EffectDistance = new Vector2(1f, -1f);
[SerializeField] private bool m_UseGraphicAlpha = true;
private const float kMaxEffectDistance = 600f;
public Color effectColor
{
get { return m_EffectColor; }
set
{
if (m_EffectColor == value) return;
m_EffectColor = value;
SetVerticesDirty();
}
}
public Vector2 effectDistance
{
get { return m_EffectDistance; }
set
{
if (value.x > kMaxEffectDistance)
value.x = kMaxEffectDistance;
if (value.x < -kMaxEffectDistance)
value.x = -kMaxEffectDistance;
if (value.y > kMaxEffectDistance)
value.y = kMaxEffectDistance;
if (value.y < -kMaxEffectDistance)
value.y = -kMaxEffectDistance;
if (m_EffectDistance == value) return;
m_EffectDistance = value;
SetEffectParamsDirty();
}
}
public bool useGraphicAlpha
{
get { return m_UseGraphicAlpha; }
set
{
if (m_UseGraphicAlpha == value) return;
m_UseGraphicAlpha = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// How far is the blurring shadow from the graphic.
/// </summary>
public float blurFactor
{
get { return m_BlurFactor; }
set
{
value = Mathf.Clamp(value, 0, 2);
if (Mathf.Approximately(m_BlurFactor, value)) return;
m_BlurFactor = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Shadow effect style.
/// </summary>
public ShadowStyle style
{
get { return m_Style; }
set
{
if (m_Style == value) return;
m_Style = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Gets or sets the parameter index.
/// </summary>
public int parameterIndex { get; set; }
/// <summary>
/// Gets the parameter texture.
/// </summary>
public ParameterTexture paramTex { get; private set; }
protected override void OnEnable()
{
base.OnEnable();
_uiEffect = GetComponent<UIEffect>();
if (!_uiEffect) return;
paramTex = _uiEffect.paramTex;
paramTex.Register(this);
}
protected override void OnDisable()
{
base.OnDisable();
_uiEffect = null;
if (paramTex == null) return;
paramTex.Unregister(this);
paramTex = null;
}
// #if UNITY_EDITOR
// protected override void OnValidate()
// {
// effectDistance = m_EffectDistance;
// base.OnValidate();
// }
// #endif
// #if TMP_PRESENT
// protected void OnCullStateChanged (bool state)
// {
// SetVerticesDirty ();
// }
//
// Vector2 res;
// protected override void LateUpdate ()
// {
// if (res.x != Screen.width || res.y != Screen.height)
// {
// res.x = Screen.width;
// res.y = Screen.height;
// SetVerticesDirty ();
// }
// if (textMeshPro && transform.hasChanged)
// {
// transform.hasChanged = false;
// }
// base.LateUpdate ();
// }
// #endif
/// <summary>
/// Modifies the mesh.
/// </summary>
public override void ModifyMesh(VertexHelper vh)
{
if (!isActiveAndEnabled || vh.currentVertCount <= 0 || m_Style == ShadowStyle.None)
{
return;
}
vh.GetUIVertexStream(s_Verts);
GetComponents<UIShadow>(tmpShadows);
foreach (var s in tmpShadows)
{
if (!s.isActiveAndEnabled) continue;
if (s == this)
{
foreach (var s2 in tmpShadows)
{
s2._graphicVertexCount = s_Verts.Count;
}
}
break;
}
tmpShadows.Clear();
//================================
// Append shadow vertices.
//================================
{
_uiEffect = _uiEffect ? _uiEffect : GetComponent<UIEffect>();
var start = s_Verts.Count - _graphicVertexCount;
var end = s_Verts.Count;
if (paramTex != null && _uiEffect && _uiEffect.isActiveAndEnabled)
{
paramTex.SetData(this, 0, _uiEffect.effectFactor); // param.x : effect factor
paramTex.SetData(this, 1, 255); // param.y : color factor
paramTex.SetData(this, 2, m_BlurFactor); // param.z : blur factor
}
ApplyShadow(s_Verts, effectColor, ref start, ref end, effectDistance, style, useGraphicAlpha);
}
vh.Clear();
vh.AddUIVertexTriangleStream(s_Verts);
s_Verts.Clear();
}
/// <summary>
/// Append shadow vertices.
/// * It is similar to Shadow component implementation.
/// </summary>
private void ApplyShadow(List<UIVertex> verts, Color color, ref int start, ref int end, Vector2 distance,
ShadowStyle style, bool alpha)
{
if (style == ShadowStyle.None || color.a <= 0)
return;
var x = distance.x;
var y = distance.y;
// Append Shadow.
ApplyShadowZeroAlloc(verts, color, ref start, ref end, x, y, alpha);
switch (style)
{
// Append Shadow3.
case ShadowStyle.Shadow3:
ApplyShadowZeroAlloc(verts, color, ref start, ref end, x, 0, alpha);
ApplyShadowZeroAlloc(verts, color, ref start, ref end, 0, y, alpha);
break;
// Append Outline.
case ShadowStyle.Outline:
ApplyShadowZeroAlloc(verts, color, ref start, ref end, x, -y, alpha);
ApplyShadowZeroAlloc(verts, color, ref start, ref end, -x, y, alpha);
ApplyShadowZeroAlloc(verts, color, ref start, ref end, -x, -y, alpha);
break;
// Append Outline8.
case ShadowStyle.Outline8:
ApplyShadowZeroAlloc(verts, color, ref start, ref end, x, -y, alpha);
ApplyShadowZeroAlloc(verts, color, ref start, ref end, -x, y, alpha);
ApplyShadowZeroAlloc(verts, color, ref start, ref end, -x, -y, alpha);
ApplyShadowZeroAlloc(verts, color, ref start, ref end, -x, 0, alpha);
ApplyShadowZeroAlloc(verts, color, ref start, ref end, 0, -y, alpha);
ApplyShadowZeroAlloc(verts, color, ref start, ref end, x, 0, alpha);
ApplyShadowZeroAlloc(verts, color, ref start, ref end, 0, y, alpha);
break;
}
}
/// <summary>
/// Append shadow vertices.
/// * It is similar to Shadow component implementation.
/// </summary>
private void ApplyShadowZeroAlloc(List<UIVertex> verts, Color color, ref int start, ref int end, float x,
float y, bool alpha)
{
// Check list capacity.
var count = end - start;
var neededCapacity = verts.Count + count;
if (verts.Capacity < neededCapacity)
verts.Capacity *= 2;
var normalizedIndex = paramTex != null && _uiEffect && _uiEffect.isActiveAndEnabled
? paramTex.GetNormalizedIndex(this)
: -1;
// Add
var vt = default(UIVertex);
for (var i = 0; i < count; i++)
{
verts.Add(vt);
}
// Move
for (var i = verts.Count - 1; count <= i; i--)
{
verts[i] = verts[i - count];
}
// Append shadow vertices to the front of list.
// * The original vertex is pushed backward.
for (var i = 0; i < count; ++i)
{
vt = verts[i + start + count];
var v = vt.position;
vt.position.Set(v.x + x, v.y + y, v.z);
var vertColor = effectColor;
vertColor.a = alpha ? color.a * vt.color.a / 255 : color.a;
vt.color = vertColor;
// Set UIEffect parameters
if (0 <= normalizedIndex)
{
vt.uv0 = new Vector2(
vt.uv0.x,
normalizedIndex
);
}
verts[i] = vt;
}
// Update next shadow offset.
start = end;
end = verts.Count;
}
/// <summary>
/// Mark the UIEffect as dirty.
/// </summary>
// void _SetDirty()
// {
// if (graphic)
// graphic.SetVerticesDirty();
// }
// #if UNITY_EDITOR
// public void OnBeforeSerialize()
// {
// }
//
// public void OnAfterDeserialize()
// {
// EditorApplication.delayCall += UpgradeIfNeeded;
// }
//
//
// #pragma warning disable 0612
// void UpgradeIfNeeded()
// {
// if (0 < m_AdditionalShadows.Count)
// {
// foreach (var s in m_AdditionalShadows)
// {
// if (s.style == ShadowStyle.None)
// {
// continue;
// }
//
// var shadow = gameObject.AddComponent<UIShadow>();
// shadow.style = s.style;
// shadow.effectDistance = s.effectDistance;
// shadow.effectColor = s.effectColor;
// shadow.useGraphicAlpha = s.useGraphicAlpha;
// shadow.blurFactor = s.blur;
// }
//
// m_AdditionalShadows = null;
// }
// }
// #pragma warning restore 0612
// #endif
}
}
@@ -5,452 +5,272 @@ using UnityEngine.Serialization;
using UnityEngine.UI;
using System.Collections;
#if UNITY_EDITOR
using System.IO;
using System.Linq;
using UnityEditor;
#endif
namespace Coffee.UIExtensions
{
/// <summary>
/// UIEffect.
/// </summary>
[AddComponentMenu("UI/UIEffect/UIShiny", 2)]
public class UIShiny : UIEffectBase
{
//################################
// Constant or Static Members.
//################################
//public const string shaderName = "UI/Hidden/UI-Effect-Shiny";
static readonly ParameterTexture _ptex = new ParameterTexture(8, 128, "_ParamTex");
/// <summary>
/// UIEffect.
/// </summary>
[AddComponentMenu("UI/UIEffects/UIShiny", 2)]
public class UIShiny : BaseMaterialEffect
{
private const uint k_ShaderId = 1 << 3;
private static readonly ParameterTexture s_ParamTex = new ParameterTexture(8, 128, "_ParamTex");
float _lastRotation;
EffectArea _lastEffectArea;
[Tooltip("Location for shiny effect.")] [FormerlySerializedAs("m_Location")] [SerializeField] [Range(0, 1)]
float m_EffectFactor = 0.5f;
[Tooltip("Width for shiny effect.")] [SerializeField] [Range(0, 1)]
float m_Width = 0.25f;
[Tooltip("Rotation for shiny effect.")] [SerializeField] [Range(-180, 180)]
float m_Rotation = 135;
[Tooltip("Softness for shiny effect.")] [SerializeField] [Range(0.01f, 1)]
float m_Softness = 1f;
[Tooltip("Brightness for shiny effect.")] [FormerlySerializedAs("m_Alpha")] [SerializeField] [Range(0, 1)]
float m_Brightness = 1f;
[Tooltip("Gloss factor for shiny effect.")] [FormerlySerializedAs("m_Highlight")] [SerializeField] [Range(0, 1)]
float m_Gloss = 1;
[Header("Advanced Option")] [Tooltip("The area for effect.")] [SerializeField]
protected EffectArea m_EffectArea;
[SerializeField] EffectPlayer m_Player;
/// <summary>
/// Effect factor between 0(start) and 1(end).
/// </summary>
public float effectFactor
{
get { return m_EffectFactor; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (Mathf.Approximately(m_EffectFactor, value)) return;
m_EffectFactor = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Width for shiny effect.
/// </summary>
public float width
{
get { return m_Width; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (Mathf.Approximately(m_Width, value)) return;
m_Width = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Softness for shiny effect.
/// </summary>
public float softness
{
get { return m_Softness; }
set
{
value = Mathf.Clamp(value, 0.01f, 1);
if (Mathf.Approximately(m_Softness, value)) return;
m_Softness = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Brightness for shiny effect.
/// </summary>
public float brightness
{
get { return m_Brightness; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (Mathf.Approximately(m_Brightness, value)) return;
m_Brightness = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Gloss factor for shiny effect.
/// </summary>
public float gloss
{
get { return m_Gloss; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (Mathf.Approximately(m_Gloss, value)) return;
m_Gloss = value;
SetEffectParamsDirty();
}
}
/// <summary>
/// Rotation for shiny effect.
/// </summary>
public float rotation
{
get { return m_Rotation; }
set
{
if (Mathf.Approximately(m_Rotation, value)) return;
m_Rotation = value;
SetVerticesDirty();
}
}
/// <summary>
/// The area for effect.
/// </summary>
public EffectArea effectArea
{
get { return m_EffectArea; }
set
{
if (m_EffectArea == value) return;
m_EffectArea = value;
SetVerticesDirty();
}
}
/// <summary>
/// Gets the parameter texture.
/// </summary>
public override ParameterTexture paramTex
{
get { return s_ParamTex; }
}
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected override void OnEnable()
{
base.OnEnable();
_player.OnEnable(f => effectFactor = f);
}
/// <summary>
/// This function is called when the behaviour becomes disabled () or inactive.
/// </summary>
protected override void OnDisable()
{
base.OnDisable();
_player.OnDisable();
}
//################################
// Serialize Members.
//################################
[Tooltip("Location for shiny effect.")]
[FormerlySerializedAs("m_Location")]
[SerializeField] [Range(0, 1)] float m_EffectFactor = 0;
public override Hash128 GetMaterialHash(Material material)
{
if (!isActiveAndEnabled || !material || !material.shader)
return k_InvalidHash;
[Tooltip("Width for shiny effect.")]
[SerializeField] [Range(0, 1)] float m_Width = 0.25f;
return new Hash128(
(uint) material.GetInstanceID(),
k_ShaderId,
0,
0
);
}
[Tooltip("Rotation for shiny effect.")]
[SerializeField] [Range(-180, 180)] float m_Rotation;
public override void ModifyMaterial(Material newMaterial)
{
newMaterial.shader = connector.FindShader("UIShiny");
paramTex.RegisterMaterial(newMaterial);
}
[Tooltip("Softness for shiny effect.")]
[SerializeField][Range(0.01f, 1)] float m_Softness = 1f;
/// <summary>
/// Modifies the mesh.
/// </summary>
public override void ModifyMesh(VertexHelper vh)
{
if (!isActiveAndEnabled)
return;
[Tooltip("Brightness for shiny effect.")]
[FormerlySerializedAs("m_Alpha")]
[SerializeField][Range(0, 1)] float m_Brightness = 1f;
var normalizedIndex = paramTex.GetNormalizedIndex(this);
var rect = m_EffectArea.GetEffectArea(vh, rectTransform.rect);
[Tooltip("Gloss factor for shiny effect.")]
[FormerlySerializedAs("m_Highlight")]
[SerializeField][Range(0, 1)] float m_Gloss = 1;
// rotation.
var rad = m_Rotation * Mathf.Deg2Rad;
var dir = new Vector2(Mathf.Cos(rad), Mathf.Sin(rad));
dir.x *= rect.height / rect.width;
dir = dir.normalized;
[Header("Advanced Option")]
[Tooltip("The area for effect.")]
[SerializeField] protected EffectArea m_EffectArea;
// Calculate vertex position.
var vertex = default(UIVertex);
var localMatrix = new Matrix2x3(rect, dir.x, dir.y); // Get local matrix.
for (int i = 0; i < vh.currentVertCount; i++)
{
vh.PopulateUIVertex(ref vertex, i);
Vector2 normalizedPos;
connector.GetNormalizedFactor(m_EffectArea, i, localMatrix, vertex.position, out normalizedPos);
[SerializeField] EffectPlayer m_Player;
vertex.uv0 = new Vector2(
Packer.ToFloat(vertex.uv0.x, vertex.uv0.y),
Packer.ToFloat(normalizedPos.y, normalizedIndex)
);
#pragma warning disable 0414
[Obsolete][HideInInspector]
[SerializeField] bool m_Play = false;
[Obsolete][HideInInspector]
[SerializeField] bool m_Loop = false;
[Obsolete][HideInInspector]
[SerializeField][Range(0.1f, 10)] float m_Duration = 1;
[Obsolete][HideInInspector]
[SerializeField][Range(0, 10)] float m_LoopDelay = 1;
[Obsolete][HideInInspector]
[SerializeField] AnimatorUpdateMode m_UpdateMode = AnimatorUpdateMode.Normal;
#pragma warning restore 0414
vh.SetUIVertex(vertex, i);
}
}
/// <summary>
/// Play effect.
/// </summary>
public void Play(bool reset = true)
{
_player.Play(reset);
}
//################################
// Public Members.
//################################
/// <summary>
/// Stop effect.
/// </summary>
public void Stop(bool reset = true)
{
_player.Stop(reset);
}
/// <summary>
/// Effect factor between 0(start) and 1(end).
/// </summary>
[System.Obsolete("Use effectFactor instead (UnityUpgradable) -> effectFactor")]
public float location
{
get { return m_EffectFactor; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_EffectFactor, value))
{
m_EffectFactor = value;
SetEffectDirty();
}
}
}
protected override void SetEffectParamsDirty()
{
paramTex.SetData(this, 0, m_EffectFactor); // param1.x : location
paramTex.SetData(this, 1, m_Width); // param1.y : width
paramTex.SetData(this, 2, m_Softness); // param1.z : softness
paramTex.SetData(this, 3, m_Brightness); // param1.w : blightness
paramTex.SetData(this, 4, m_Gloss); // param2.x : gloss
}
/// <summary>
/// Effect factor between 0(start) and 1(end).
/// </summary>
public float effectFactor
{
get { return m_EffectFactor; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_EffectFactor, value))
{
m_EffectFactor = value;
SetEffectDirty();
}
}
}
protected override void SetVerticesDirty()
{
base.SetVerticesDirty();
/// <summary>
/// Width for shiny effect.
/// </summary>
public float width
{
get { return m_Width; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_Width, value))
{
m_Width = value;
SetEffectDirty();
}
}
}
_lastRotation = m_Rotation;
_lastEffectArea = m_EffectArea;
}
/// <summary>
/// Softness for shiny effect.
/// </summary>
public float softness
{
get { return m_Softness; }
set
{
value = Mathf.Clamp(value, 0.01f, 1);
if (!Mathf.Approximately(m_Softness, value))
{
m_Softness = value;
SetEffectDirty();
}
}
}
protected override void OnDidApplyAnimationProperties()
{
base.OnDidApplyAnimationProperties();
/// <summary>
/// Brightness for shiny effect.
/// </summary>
[System.Obsolete("Use brightness instead (UnityUpgradable) -> brightness")]
public float alpha
{
get { return m_Brightness; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_Brightness, value))
{
m_Brightness = value;
SetEffectDirty();
}
}
}
if (!Mathf.Approximately(_lastRotation, m_Rotation)
|| _lastEffectArea != m_EffectArea)
SetVerticesDirty();
}
/// <summary>
/// Brightness for shiny effect.
/// </summary>
public float brightness
{
get { return m_Brightness; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_Brightness, value))
{
m_Brightness = value;
SetEffectDirty();
}
}
}
/// <summary>
/// Gloss factor for shiny effect.
/// </summary>
[System.Obsolete("Use gloss instead (UnityUpgradable) -> gloss")]
public float highlight
{
get { return m_Gloss; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_Gloss, value))
{
m_Gloss = value;
SetEffectDirty();
}
}
}
/// <summary>
/// Gloss factor for shiny effect.
/// </summary>
public float gloss
{
get { return m_Gloss; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_Gloss, value))
{
m_Gloss = value;
SetEffectDirty();
}
}
}
/// <summary>
/// Rotation for shiny effect.
/// </summary>
public float rotation
{
get { return m_Rotation; }
set
{
if (!Mathf.Approximately(m_Rotation, value))
{
m_Rotation = _lastRotation = value;
SetVerticesDirty ();
}
}
}
/// <summary>
/// The area for effect.
/// </summary>
public EffectArea effectArea
{
get { return m_EffectArea; }
set
{
if (m_EffectArea != value)
{
m_EffectArea = value;
SetVerticesDirty ();
}
}
}
/// <summary>
/// Play shinning on enable.
/// </summary>
[System.Obsolete ("Use Play/Stop method instead")]
public bool play { get { return _player.play; } set { _player.play = value; } }
/// <summary>
/// Play shinning loop.
/// </summary>
[System.Obsolete]
public bool loop { get { return _player.loop; } set { _player.loop = value; } }
/// <summary>
/// Shinning duration.
/// </summary>
public float duration { get { return _player.duration; } set { _player.duration = Mathf.Max(value, 0.1f); } }
/// <summary>
/// Delay on loop.
/// </summary>
[System.Obsolete]
public float loopDelay { get { return _player.loopDelay; } set { _player.loopDelay = Mathf.Max(value, 0); } }
/// <summary>
/// Shinning update mode.
/// </summary>
public AnimatorUpdateMode updateMode { get { return _player.updateMode; } set { _player.updateMode = value; } }
/// <summary>
/// Gets the parameter texture.
/// </summary>
public override ParameterTexture ptex { get { return _ptex; } }
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected override void OnEnable()
{
base.OnEnable();
_player.OnEnable(f => effectFactor = f);
}
/// <summary>
/// This function is called when the behaviour becomes disabled () or inactive.
/// </summary>
protected override void OnDisable()
{
base.OnDisable();
_player.OnDisable();
}
public override Hash128 GetMaterialHash (Material material)
{
if (!isActiveAndEnabled || !material || !material.shader)
return new Hash128 ();
uint materialId = (uint)material.GetInstanceID ();
uint shaderId = 1 << 3;
string materialShaderName = material.shader.name;
if (materialShaderName.StartsWith ("TextMeshPro/Mobile/", StringComparison.Ordinal))
{
shaderId += 2;
}
else if (materialShaderName.Equals ("TextMeshPro/Sprite", StringComparison.Ordinal))
{
shaderId += 0;
}
else if (materialShaderName.StartsWith ("TextMeshPro/", StringComparison.Ordinal))
{
shaderId += 1;
}
else
{
shaderId += 0;
}
return new Hash128 (
materialId,
shaderId,
0,
0
);
}
public override void ModifyMaterial (Material material)
{
string materialShaderName = material.shader.name;
if (materialShaderName.StartsWith ("TextMeshPro/Mobile/", StringComparison.Ordinal))
{
material.shader = Shader.Find ("TextMeshPro/Mobile/Distance Field (UIShiny)");
}
else if (materialShaderName.Equals ("TextMeshPro/Sprite", StringComparison.Ordinal))
{
material.shader = Shader.Find ("UI/Hidden/UI-Effect-Shiny");
}
else if (materialShaderName.StartsWith ("TextMeshPro/", StringComparison.Ordinal))
{
material.shader = Shader.Find ("TextMeshPro/Distance Field (UIShiny)");
}
else
{
material.shader = Shader.Find ("UI/Hidden/UI-Effect-Shiny");
}
ptex.RegisterMaterial (material);
}
#if UNITY_EDITOR
protected override Material GetMaterial()
{
return null;
}
#pragma warning disable 0612
protected override void UpgradeIfNeeded()
{
// Upgrade for v3.0.0
if (IsShouldUpgrade(300))
{
_player.play = m_Play;
_player.duration = m_Duration;
_player.loop = m_Loop;
_player.loopDelay = m_LoopDelay;
_player.updateMode = m_UpdateMode;
}
}
#pragma warning restore 0612
#endif
/// <summary>
/// Modifies the mesh.
/// </summary>
public override void ModifyMesh(VertexHelper vh)
{
if (!isActiveAndEnabled)
return;
bool isText = isTMPro || graphic is Text;
float normalizedIndex = ptex.GetNormalizedIndex(this);
// rect.
Rect rect = m_EffectArea.GetEffectArea (vh, rectTransform.rect);
// rotation.
float rad = m_Rotation * Mathf.Deg2Rad;
Vector2 dir = new Vector2(Mathf.Cos(rad), Mathf.Sin(rad));
dir.x *= rect.height / rect.width;
dir = dir.normalized;
// Calculate vertex position.
UIVertex vertex = default(UIVertex);
Vector2 nomalizedPos;
Matrix2x3 localMatrix = new Matrix2x3(rect, dir.x, dir.y); // Get local matrix.
for (int i = 0; i < vh.currentVertCount; i++)
{
vh.PopulateUIVertex(ref vertex, i);
m_EffectArea.GetNormalizedFactor (i, localMatrix, vertex.position, isText, out nomalizedPos);
vertex.uv0 = new Vector2 (
Packer.ToFloat (vertex.uv0.x, vertex.uv0.y),
Packer.ToFloat (nomalizedPos.y, normalizedIndex)
);
vh.SetUIVertex(vertex, i);
}
}
/// <summary>
/// Play effect.
/// </summary>
public void Play(bool reset = true)
{
_player.Play(reset);
}
/// <summary>
/// Stop effect.
/// </summary>
public void Stop(bool reset = true)
{
_player.Stop(reset);
}
protected override void SetEffectDirty()
{
ptex.SetData(this, 0, m_EffectFactor); // param1.x : location
ptex.SetData(this, 1, m_Width); // param1.y : width
ptex.SetData(this, 2, m_Softness); // param1.z : softness
ptex.SetData(this, 3, m_Brightness);// param1.w : blightness
ptex.SetData(this, 4, m_Gloss); // param2.x : gloss
if (!Mathf.Approximately(_lastRotation, m_Rotation) && targetGraphic)
{
_lastRotation = m_Rotation;
SetVerticesDirty();
}
}
//################################
// Private Members.
//################################
float _lastRotation;
EffectPlayer _player{ get { return m_Player ?? (m_Player = new EffectPlayer()); } }
}
EffectPlayer _player
{
get { return m_Player ?? (m_Player = new EffectPlayer()); }
}
}
}
@@ -5,383 +5,327 @@ using System;
namespace Coffee.UIExtensions
{
/// <summary>
/// Transition effect.
/// </summary>
[AddComponentMenu("UI/UIEffect/UITransitionEffect", 5)]
public class UITransitionEffect : UIEffectBase
{
//################################
// Constant or Static Members.
//################################
public const string shaderName = "UI/Hidden/UI-Effect-Transition";
static readonly ParameterTexture _ptex = new ParameterTexture(8, 128, "_ParamTex");
/// <summary>
/// Transition effect.
/// </summary>
[AddComponentMenu("UI/UIEffects/UITransitionEffect", 5)]
public class UITransitionEffect : BaseMaterialEffect
{
/// <summary>
/// Effect mode.
/// </summary>
public enum EffectMode
{
Fade = 1,
Cutoff = 2,
Dissolve = 3,
}
/// <summary>
/// Effect mode.
/// </summary>
public enum EffectMode
{
Fade = 1,
Cutoff = 2,
Dissolve = 3,
}
private const uint k_ShaderId = 5 << 3;
private static readonly int k_TransitionTexId = Shader.PropertyToID("_TransitionTex");
private static readonly ParameterTexture s_ParamTex = new ParameterTexture(8, 128, "_ParamTex");
private bool _lastKeepAspectRatio;
private static Texture _defaultTransitionTexture;
[Tooltip("Effect mode.")] [SerializeField]
EffectMode m_EffectMode = EffectMode.Cutoff;
[Tooltip("Effect factor between 0(hidden) and 1(shown).")] [SerializeField] [Range(0, 1)]
float m_EffectFactor = 0.5f;
[Tooltip("Transition texture (single channel texture).")] [SerializeField]
Texture m_TransitionTexture;
[Header("Advanced Option")] [Tooltip("The area for effect.")] [SerializeField]
EffectArea m_EffectArea = EffectArea.RectTransform;
[Tooltip("Keep effect aspect ratio.")] [SerializeField]
bool m_KeepAspectRatio;
[Tooltip("Dissolve edge width.")] [SerializeField] [Range(0, 1)]
float m_DissolveWidth = 0.5f;
[Tooltip("Dissolve edge softness.")] [SerializeField] [Range(0, 1)]
float m_DissolveSoftness = 0.5f;
[Tooltip("Dissolve edge color.")] [SerializeField] [ColorUsage(false)]
Color m_DissolveColor = new Color(0.0f, 0.25f, 1.0f);
[Tooltip("Disable the graphic's raycast target on hidden.")] [SerializeField]
bool m_PassRayOnHidden;
[Header("Effect Player")] [SerializeField]
EffectPlayer m_Player;
//################################
// Serialize Members.
//################################
[Tooltip("Effect mode.")]
[SerializeField] EffectMode m_EffectMode = EffectMode.Cutoff;
/// <summary>
/// Effect factor between 0(no effect) and 1(complete effect).
/// </summary>
public float effectFactor
{
get { return m_EffectFactor; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (Mathf.Approximately(m_EffectFactor, value)) return;
m_EffectFactor = value;
SetEffectParamsDirty();
}
}
[Tooltip("Effect factor between 0(hidden) and 1(shown).")]
[SerializeField][Range(0, 1)] float m_EffectFactor = 0.5f;
/// <summary>
/// Transition texture.
/// </summary>
public Texture transitionTexture
{
get
{
return m_TransitionTexture
? m_TransitionTexture
: defaultTransitionTexture;
}
set
{
if (m_TransitionTexture == value) return;
m_TransitionTexture = value;
SetMaterialDirty();
}
}
[Tooltip("Transition texture (single channel texture).")]
[SerializeField] Texture m_TransitionTexture;
private static Texture defaultTransitionTexture
{
get
{
return _defaultTransitionTexture
? _defaultTransitionTexture
: (_defaultTransitionTexture = Resources.Load<Texture>("Default-Transition"));
}
}
[Header("Advanced Option")]
[Tooltip("The area for effect.")]
[SerializeField] EffectArea m_EffectArea = EffectArea.RectTransform;
/// <summary>
/// Effect mode.
/// </summary>
public EffectMode effectMode
{
get { return m_EffectMode; }
set
{
if (m_EffectMode == value) return;
m_EffectMode = value;
SetMaterialDirty();
}
}
[Tooltip("Keep effect aspect ratio.")]
[SerializeField] bool m_KeepAspectRatio;
/// <summary>
/// Keep aspect ratio.
/// </summary>
public bool keepAspectRatio
{
get { return m_KeepAspectRatio; }
set
{
if (m_KeepAspectRatio == value) return;
m_KeepAspectRatio = value;
SetVerticesDirty();
}
}
[Tooltip("Dissolve edge width.")]
[SerializeField] [Range(0, 1)] float m_DissolveWidth = 0.5f;
/// <summary>
/// Gets the parameter texture.
/// </summary>
public override ParameterTexture paramTex
{
get { return s_ParamTex; }
}
[Tooltip("Dissolve edge softness.")]
[SerializeField] [Range(0, 1)] float m_DissolveSoftness = 0.5f;
/// <summary>
/// Dissolve edge width.
/// </summary>
public float dissolveWidth
{
get { return m_DissolveWidth; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (Mathf.Approximately(m_DissolveWidth, value)) return;
m_DissolveWidth = value;
SetEffectParamsDirty();
}
}
[Tooltip("Dissolve edge color.")]
[SerializeField] [ColorUsage(false)] Color m_DissolveColor = new Color(0.0f, 0.25f, 1.0f);
/// <summary>
/// Dissolve edge softness.
/// </summary>
public float dissolveSoftness
{
get { return m_DissolveSoftness; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (Mathf.Approximately(m_DissolveSoftness, value)) return;
m_DissolveSoftness = value;
SetEffectParamsDirty();
}
}
[Tooltip("Disable graphic's raycast target on hidden.")]
[SerializeField] bool m_PassRayOnHidden;
/// <summary>
/// Dissolve edge color.
/// </summary>
public Color dissolveColor
{
get { return m_DissolveColor; }
set
{
if (m_DissolveColor == value) return;
m_DissolveColor = value;
SetEffectParamsDirty();
}
}
[Header("Effect Player")]
[SerializeField] EffectPlayer m_Player;
/// <summary>
/// Disable graphic's raycast target on hidden.
/// </summary>
public bool passRayOnHidden
{
get { return m_PassRayOnHidden; }
set { m_PassRayOnHidden = value; }
}
//################################
// Public Members.
//################################
/// <summary>
/// Show transition.
/// </summary>
public void Show(bool reset = true)
{
_player.loop = false;
_player.Play(reset, f => effectFactor = f);
}
/// <summary>
/// Effect factor between 0(no effect) and 1(complete effect).
/// </summary>
public float effectFactor
{
get { return m_EffectFactor; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_EffectFactor, value))
{
m_EffectFactor = value;
SetEffectDirty ();
}
}
}
/// <summary>
/// Transition texture.
/// </summary>
public Texture transitionTexture
{
get { return m_TransitionTexture; }
set
{
if (m_TransitionTexture != value)
{
m_TransitionTexture = value;
if (graphic)
{
ModifyMaterial();
}
}
}
}
/// <summary>
/// Effect mode.
/// </summary>
public EffectMode effectMode { get { return m_EffectMode; } }
/// <summary>
/// Keep aspect ratio.
/// </summary>
public bool keepAspectRatio
{
get { return m_KeepAspectRatio; }
set
{
if (m_KeepAspectRatio != value)
{
m_KeepAspectRatio = value;
targetGraphic.SetVerticesDirty();
}
}
}
/// <summary>
/// Gets the parameter texture.
/// </summary>
public override ParameterTexture ptex { get { return _ptex; } }
/// <summary>
/// Dissolve edge width.
/// </summary>
public float dissolveWidth
{
get { return m_DissolveWidth; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_DissolveWidth, value))
{
m_DissolveWidth = value;
SetEffectDirty ();
}
}
}
/// <summary>
/// Dissolve edge softness.
/// </summary>
public float dissolveSoftness
{
get { return m_DissolveSoftness; }
set
{
value = Mathf.Clamp(value, 0, 1);
if (!Mathf.Approximately(m_DissolveSoftness, value))
{
m_DissolveSoftness = value;
SetEffectDirty ();
}
}
}
/// <summary>
/// Dissolve edge color.
/// </summary>
public Color dissolveColor
{
get { return m_DissolveColor; }
set
{
if (m_DissolveColor != value)
{
m_DissolveColor = value;
SetEffectDirty ();
}
}
}
/// <summary>
/// Duration for showing/hiding.
/// </summary>
public float duration { get { return _player.duration; } set { _player.duration = Mathf.Max(value, 0.1f); } }
/// <summary>
/// Disable graphic's raycast target on hidden.
/// </summary>
public bool passRayOnHidden { get { return m_PassRayOnHidden; } set { m_PassRayOnHidden = value; } }
/// <summary>
/// Update mode for showing/hiding.
/// </summary>
public AnimatorUpdateMode updateMode { get { return _player.updateMode; } set { _player.updateMode = value; } }
/// <summary>
/// Show transition.
/// </summary>
public void Show(bool reset = true)
{
_player.loop = false;
_player.Play(reset, f => effectFactor = f);
}
/// <summary>
/// Hide transition.
/// </summary>
public void Hide(bool reset = true)
{
_player.loop = false;
_player.Play(reset, f => effectFactor = 1 - f);
}
/// <summary>
/// Hide transition.
/// </summary>
public void Hide(bool reset = true)
{
_player.loop = false;
_player.Play(reset, f => effectFactor = 1 - f);
}
public override Hash128 GetMaterialHash (Material material)
{
if (!isActiveAndEnabled || !material || !material.shader)
return new Hash128 ();
public override Hash128 GetMaterialHash(Material material)
{
if (!isActiveAndEnabled || !material || !material.shader)
return k_InvalidHash;
uint materialId = (uint)material.GetInstanceID ();
uint shaderId = 5 << 3;
var shaderVariantId = (uint) ((int) m_EffectMode << 6);
var resourceId = (uint) transitionTexture.GetInstanceID();
return new Hash128(
(uint) material.GetInstanceID(),
k_ShaderId + shaderVariantId,
resourceId,
0
);
}
string materialShaderName = material.shader.name;
if (materialShaderName.StartsWith ("TextMeshPro/Mobile/", StringComparison.Ordinal))
{
shaderId += 2;
}
else if (materialShaderName.Equals ("TextMeshPro/Sprite", StringComparison.Ordinal))
{
shaderId += 0;
}
else if (materialShaderName.StartsWith ("TextMeshPro/", StringComparison.Ordinal))
{
shaderId += 1;
}
else
{
shaderId += 0;
}
public override void ModifyMaterial(Material newMaterial)
{
newMaterial.shader = connector.FindShader("UITransition");
SetShaderVariants(newMaterial, m_EffectMode);
newMaterial.SetTexture(k_TransitionTexId, transitionTexture);
paramTex.RegisterMaterial(newMaterial);
}
uint shaderVariantId = (uint)((int)m_EffectMode << 6);
uint resourceId = m_TransitionTexture ? (uint)m_TransitionTexture.GetInstanceID () : 0;
return new Hash128 (
materialId,
shaderId + shaderVariantId,
resourceId,
0
);
}
/// <summary>
/// Modifies the mesh.
/// </summary>
public override void ModifyMesh(VertexHelper vh)
{
if (!isActiveAndEnabled)
{
return;
}
public override void ModifyMaterial (Material material)
{
Debug.LogFormat (this, $"ModifyMaterial {material}");
var normalizedIndex = paramTex.GetNormalizedIndex(this);
string materialShaderName = material.shader.name;
if (materialShaderName.StartsWith ("TextMeshPro/Mobile/", StringComparison.Ordinal))
{
material.shader = Shader.Find ("TextMeshPro/Mobile/Distance Field (UITransition)");
}
else if (materialShaderName.Equals ("TextMeshPro/Sprite", StringComparison.Ordinal))
{
material.shader = Shader.Find ("UI/Hidden/UI-Effect-Transition");
}
else if (materialShaderName.StartsWith ("TextMeshPro/", StringComparison.Ordinal))
{
material.shader = Shader.Find ("TextMeshPro/Distance Field (UITransition)");
}
else
{
material.shader = Shader.Find ("UI/Hidden/UI-Effect-Transition");
}
// rect.
var tex = transitionTexture;
var aspectRatio = m_KeepAspectRatio && tex ? ((float) tex.width) / tex.height : -1;
var rect = m_EffectArea.GetEffectArea(vh, rectTransform.rect, aspectRatio);
SetShaderVariants (material, m_EffectMode);
// Set parameters to vertex.
var vertex = default(UIVertex);
var count = vh.currentVertCount;
for (var i = 0; i < count; i++)
{
vh.PopulateUIVertex(ref vertex, i);
float x;
float y;
connector.GetPositionFactor(m_EffectArea, i, rect, vertex.position, out x, out y);
if (m_TransitionTexture)
{
material.SetTexture ("_NoiseTex", m_TransitionTexture);
}
ptex.RegisterMaterial (material);
}
vertex.uv0 = new Vector2(
Packer.ToFloat(vertex.uv0.x, vertex.uv0.y),
Packer.ToFloat(x, y, normalizedIndex)
);
vh.SetUIVertex(vertex, i);
}
}
/// <summary>
/// Modifies the material.
/// </summary>
public override void ModifyMaterial()
{
}
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected override void OnEnable()
{
base.OnEnable();
_player.OnEnable(null);
_player.loop = false;
}
/// <summary>
/// Modifies the mesh.
/// </summary>
public override void ModifyMesh(VertexHelper vh)
{
if (!isActiveAndEnabled)
{
return;
}
/// <summary>
/// This function is called when the behaviour becomes disabled () or inactive.
/// </summary>
protected override void OnDisable()
{
base.OnDisable();
_player.OnDisable();
}
bool isText = isTMPro || graphic is Text;
float normalizedIndex = ptex.GetNormalizedIndex (this);
protected override void SetEffectParamsDirty()
{
paramTex.SetData(this, 0, m_EffectFactor); // param1.x : effect factor
if (m_EffectMode == EffectMode.Dissolve)
{
paramTex.SetData(this, 1, m_DissolveWidth); // param1.y : width
paramTex.SetData(this, 2, m_DissolveSoftness); // param1.z : softness
paramTex.SetData(this, 4, m_DissolveColor.r); // param2.x : red
paramTex.SetData(this, 5, m_DissolveColor.g); // param2.y : green
paramTex.SetData(this, 6, m_DissolveColor.b); // param2.z : blue
}
// rect.
var tex = transitionTexture;
var aspectRatio = m_KeepAspectRatio && tex ? ((float)tex.width) / tex.height : -1;
Rect rect = m_EffectArea.GetEffectArea (vh, rectTransform.rect, aspectRatio);
// Disable graphic's raycastTarget on hidden.
if (m_PassRayOnHidden)
{
graphic.raycastTarget = 0 < m_EffectFactor;
}
}
// Set prameters to vertex.
UIVertex vertex = default(UIVertex);
float x, y;
int count = vh.currentVertCount;
for (int i = 0; i < count; i++)
{
vh.PopulateUIVertex(ref vertex, i);
m_EffectArea.GetPositionFactor (i, rect, vertex.position, isText, isTMPro, out x, out y);
protected override void SetVerticesDirty()
{
base.SetVerticesDirty();
vertex.uv0 = new Vector2 (
Packer.ToFloat (vertex.uv0.x, vertex.uv0.y),
Packer.ToFloat (x, y, normalizedIndex)
);
vh.SetUIVertex(vertex, i);
}
}
_lastKeepAspectRatio = m_KeepAspectRatio;
}
//################################
// Protected Members.
//################################
protected override void OnDidApplyAnimationProperties()
{
base.OnDidApplyAnimationProperties();
/// <summary>
/// This function is called when the object becomes enabled and active.
/// </summary>
protected override void OnEnable()
{
base.OnEnable();
_player.OnEnable(null);
_player.loop = false;
}
if (_lastKeepAspectRatio != m_KeepAspectRatio)
SetVerticesDirty();
}
/// <summary>
/// This function is called when the behaviour becomes disabled () or inactive.
/// </summary>
protected override void OnDisable()
{
base.OnDisable ();
MaterialCache.Unregister(_materialCache);
_materialCache = null;
_player.OnDisable();
}
protected override void SetEffectDirty ()
{
ptex.SetData(this, 0, m_EffectFactor); // param1.x : effect factor
if (m_EffectMode == EffectMode.Dissolve)
{
ptex.SetData(this, 1, m_DissolveWidth); // param1.y : width
ptex.SetData(this, 2, m_DissolveSoftness); // param1.z : softness
ptex.SetData(this, 4, m_DissolveColor.r); // param2.x : red
ptex.SetData(this, 5, m_DissolveColor.g); // param2.y : green
ptex.SetData(this, 6, m_DissolveColor.b); // param2.z : blue
}
// Disable graphic's raycastTarget on hidden.
if (m_PassRayOnHidden)
{
targetGraphic.raycastTarget = 0 < m_EffectFactor;
}
}
#if UNITY_EDITOR
/// <summary>
/// Gets the material.
/// </summary>
/// <returns>The material.</returns>
protected override Material GetMaterial()
{
return MaterialResolver.GetOrGenerateMaterialVariant(Shader.Find(shaderName), m_EffectMode);
}
#endif
//################################
// Private Members.
//################################
MaterialCache _materialCache = null;
EffectPlayer _player{ get { return m_Player ?? (m_Player = new EffectPlayer()); } }
}
EffectPlayer _player
{
get { return m_Player ?? (m_Player = new EffectPlayer()); }
}
}
}