Die Rolle von Gpahic
Graphic ist die grundlegendste Grafikbasisklasse von Unity. Hauptverantwortlich für den Anzeigeteil von UGUI.
Wie Sie auf dem Bild oben sehen können, werden das Bild und der Text, die wir häufig verwenden, alle von Graphic geerbt.
Grafischer Rendering-Prozess
Der Quellcode von Graphic enthält die folgenden Attribute
[NonSerialized] private CanvasRenderer m_CanvasRenderer;Graphic erfasst die für das Rendering erforderlichen Daten wie Eckpunkte, Materialien und andere Informationen. Legen Sie dann das Material, die Textur und das Raster für den CanvasRenderer fest, um es auf dem Bildschirm zu rendern.
Das Folgende ist der Quellcode von Graphic:
using System;
#if UNITY_EDITOR
using System.Reflection;
#endif
using System.Collections.Generic;
using UnityEngine.Events;
using UnityEngine.EventSystems;
using UnityEngine.Serialization;
using UnityEngine.UI.CoroutineTween;
namespace UnityEngine.UI
{
/// <summary>
/// Base class for all UI components that should be derived from when creating new Graphic types.
/// </summary>
[DisallowMultipleComponent]
[RequireComponent(typeof(RectTransform))]
[ExecuteAlways]
public abstract class Graphic
: UIBehaviour,
ICanvasElement
{
static protected Material s_DefaultUI = null;
static protected Texture2D s_WhiteTexture = null;
/// <summary>
/// Default material used to draw UI elements if no explicit material was specified.
/// </summary>
static public Material defaultGraphicMaterial
{
get
{
if (s_DefaultUI == null)
s_DefaultUI = Canvas.GetDefaultCanvasMaterial();
return s_DefaultUI;
}
}
// Cached and saved values
[FormerlySerializedAs("m_Mat")]
[SerializeField] protected Material m_Material;
[SerializeField] private Color m_Color = Color.white;
[NonSerialized] protected bool m_SkipLayoutUpdate;
[NonSerialized] protected bool m_SkipMaterialUpdate;
/// <summary>
/// Base color of the Graphic.
/// </summary>
/// <remarks>
public virtual Color color { get { return m_Color; } set { if (SetPropertyUtility.SetColor(ref m_Color, value)) SetVerticesDirty(); } }
[SerializeField] private bool m_RaycastTarget = true;
/// <summary>
/// Should this graphic be considered a target for raycasting?
/// </summary>
public virtual bool raycastTarget
{
get
{
return m_RaycastTarget;
}
set
{
if (value != m_RaycastTarget)
{
if (m_RaycastTarget)
GraphicRegistry.UnregisterRaycastGraphicForCanvas(canvas, this);
m_RaycastTarget = value;
if (m_RaycastTarget && isActiveAndEnabled)
GraphicRegistry.RegisterRaycastGraphicForCanvas(canvas, this);
}
}
}
[SerializeField]
private Vector4 m_RaycastPadding = new Vector4();
/// <summary>
/// Padding to be applied to the masking
/// X = Left
/// Y = Bottom
/// Z = Right
/// W = Top
/// </summary>
public Vector4 raycastPadding
{
get { return m_RaycastPadding; }
set
{
m_RaycastPadding = value;
}
}
[NonSerialized] private RectTransform m_RectTransform;
[NonSerialized] private CanvasRenderer m_CanvasRenderer;
[NonSerialized] private Canvas m_Canvas;
[NonSerialized] private bool m_VertsDirty;
[NonSerialized] private bool m_MaterialDirty;
[NonSerialized] protected UnityAction m_OnDirtyLayoutCallback;
[NonSerialized] protected UnityAction m_OnDirtyVertsCallback;
[NonSerialized] protected UnityAction m_OnDirtyMaterialCallback;
[NonSerialized] protected static Mesh s_Mesh;
[NonSerialized] private static readonly VertexHelper s_VertexHelper = new VertexHelper();
[NonSerialized] protected Mesh m_CachedMesh;
[NonSerialized] protected Vector2[] m_CachedUvs;
// Tween controls for the Graphic
[NonSerialized]
private readonly TweenRunner<ColorTween> m_ColorTweenRunner;
protected bool useLegacyMeshGeneration { get; set; }
// Called by Unity prior to deserialization,
// should not be called by users
protected Graphic()
{
if (m_ColorTweenRunner == null)
m_ColorTweenRunner = new TweenRunner<ColorTween>();
m_ColorTweenRunner.Init(this);
useLegacyMeshGeneration = true;
}
/// <summary>
/// Set all properties of the Graphic dirty and needing rebuilt.
/// Dirties Layout, Vertices, and Materials.
/// </summary>
public virtual void SetAllDirty()
{
// Optimization: Graphic layout doesn't need recalculation if
// the underlying Sprite is the same size with the same texture.
// (e.g. Sprite sheet texture animation)
if (m_SkipLayoutUpdate)
{
m_SkipLayoutUpdate = false;
}
else
{
SetLayoutDirty();
}
if (m_SkipMaterialUpdate)
{
m_SkipMaterialUpdate = false;
}
else
{
SetMaterialDirty();
}
SetVerticesDirty();
}
/// <summary>
/// Mark the layout as dirty and needing rebuilt.
/// </summary>
/// <remarks>
/// Send a OnDirtyLayoutCallback notification if any elements are registered. See RegisterDirtyLayoutCallback
/// </remarks>
public virtual void SetLayoutDirty()
{
if (!IsActive())
return;
LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
if (m_OnDirtyLayoutCallback != null)
m_OnDirtyLayoutCallback();
}
/// <summary>
/// Mark the vertices as dirty and needing rebuilt.
/// </summary>
/// <remarks>
/// Send a OnDirtyVertsCallback notification if any elements are registered. See RegisterDirtyVerticesCallback
/// </remarks>
public virtual void SetVerticesDirty()
{
if (!IsActive())
return;
m_VertsDirty = true;
CanvasUpdateRegistry.RegisterCanvasElementForGraphicRebuild(this);
if (m_OnDirtyVertsCallback != null)
m_OnDirtyVertsCallback();
}
/// <summary>
/// Mark the material as dirty and needing rebuilt.
/// </summary>
/// <remarks>
/// Send a OnDirtyMaterialCallback notification if any elements are registered. See RegisterDirtyMaterialCallback
/// </remarks>
public virtual void SetMaterialDirty()
{
if (!IsActive())
return;
m_MaterialDirty = true;
CanvasUpdateRegistry.RegisterCanvasElementForGraphicRebuild(this);
if (m_OnDirtyMaterialCallback != null)
m_OnDirtyMaterialCallback();
}
protected override void OnRectTransformDimensionsChange()
{
if (gameObject.activeInHierarchy)
{
// prevent double dirtying...
if (CanvasUpdateRegistry.IsRebuildingLayout())
SetVerticesDirty();
else
{
SetVerticesDirty();
SetLayoutDirty();
}
}
}
protected override void OnBeforeTransformParentChanged()
{
GraphicRegistry.UnregisterGraphicForCanvas(canvas, this);
LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
}
protected override void OnTransformParentChanged()
{
base.OnTransformParentChanged();
m_Canvas = null;
if (!IsActive())
return;
CacheCanvas();
GraphicRegistry.RegisterGraphicForCanvas(canvas, this);
SetAllDirty();
}
/// <summary>
/// Absolute depth of the graphic, used by rendering and events -- lowest to highest.
/// </summary>
/// <example>
/// The depth is relative to the first root canvas.
///
/// Canvas
/// Graphic - 1
/// Graphic - 2
/// Nested Canvas
/// Graphic - 3
/// Graphic - 4
/// Graphic - 5
///
/// This value is used to determine draw and event ordering.
/// </example>
public int depth { get { return canvasRenderer.absoluteDepth; } }
/// <summary>
/// The RectTransform component used by the Graphic. Cached for speed.
/// </summary>
public RectTransform rectTransform
{
get
{
// The RectTransform is a required component that must not be destroyed. Based on this assumption, a
// null-reference check is sufficient.
if (ReferenceEquals(m_RectTransform, null))
{
m_RectTransform = GetComponent<RectTransform>();
}
return m_RectTransform;
}
}
/// <summary>
/// A reference to the Canvas this Graphic is rendering to.
/// </summary>
/// <remarks>
/// In the situation where the Graphic is used in a hierarchy with multiple Canvases, the Canvas closest to the root will be used.
/// </remarks>
public Canvas canvas
{
get
{
if (m_Canvas == null)
CacheCanvas();
return m_Canvas;
}
}
private void CacheCanvas()
{
var list = ListPool<Canvas>.Get();
gameObject.GetComponentsInParent(false, list);
if (list.Count > 0)
{
// Find the first active and enabled canvas.
for (int i = 0; i < list.Count; ++i)
{
if (list[i].isActiveAndEnabled)
{
m_Canvas = list[i];
break;
}
// if we reached the end and couldn't find an active and enabled canvas, we should return null . case 1171433
if (i == list.Count - 1)
m_Canvas = null;
}
}
else
{
m_Canvas = null;
}
ListPool<Canvas>.Release(list);
}
/// <summary>
/// A reference to the CanvasRenderer populated by this Graphic.
/// </summary>
public CanvasRenderer canvasRenderer
{
get
{
// The CanvasRenderer is a required component that must not be destroyed. Based on this assumption, a
// null-reference check is sufficient.
if (ReferenceEquals(m_CanvasRenderer, null))
{
m_CanvasRenderer = GetComponent<CanvasRenderer>();
if (ReferenceEquals(m_CanvasRenderer, null))
{
m_CanvasRenderer = gameObject.AddComponent<CanvasRenderer>();
}
}
return m_CanvasRenderer;
}
}
/// <summary>
/// Returns the default material for the graphic.
/// </summary>
public virtual Material defaultMaterial
{
get { return defaultGraphicMaterial; }
}
/// <summary>
/// The Material set by the user
/// </summary>
public virtual Material material
{
get
{
return (m_Material != null) ? m_Material : defaultMaterial;
}
set
{
if (m_Material == value)
return;
m_Material = value;
SetMaterialDirty();
}
}
/// <summary>
/// The material that will be sent for Rendering (Read only).
/// </summary>
/// <remarks>
/// This is the material that actually gets sent to the CanvasRenderer. By default it's the same as [[Graphic.material]]. When extending Graphic you can override this to send a different material to the CanvasRenderer than the one set by Graphic.material. This is useful if you want to modify the user set material in a non destructive manner.
/// </remarks>
public virtual Material materialForRendering
{
get
{
var components = ListPool<Component>.Get();
GetComponents(typeof(IMaterialModifier), components);
var currentMat = material;
for (var i = 0; i < components.Count; i++)
currentMat = (components[i] as IMaterialModifier).GetModifiedMaterial(currentMat);
ListPool<Component>.Release(components);
return currentMat;
}
}
/// <summary>
/// The graphic's texture. (Read Only).
/// </summary>
/// <remarks>
/// This is the Texture that gets passed to the CanvasRenderer, Material and then Shader _MainTex.
///
/// When implementing your own Graphic you can override this to control which texture goes through the UI Rendering pipeline.
///
/// Bear in mind that Unity tries to batch UI elements together to improve performance, so its ideal to work with atlas to reduce the number of draw calls.
/// </remarks>
public virtual Texture mainTexture
{
get
{
return s_WhiteTexture;
}
}
/// <summary>
/// Mark the Graphic and the canvas as having been changed.
/// </summary>
protected override void OnEnable()
{
base.OnEnable();
CacheCanvas();
GraphicRegistry.RegisterGraphicForCanvas(canvas, this);
#if UNITY_EDITOR
GraphicRebuildTracker.TrackGraphic(this);
#endif
if (s_WhiteTexture == null)
s_WhiteTexture = Texture2D.whiteTexture;
SetAllDirty();
}
/// <summary>
/// Clear references.
/// </summary>
protected override void OnDisable()
{
#if UNITY_EDITOR
GraphicRebuildTracker.UnTrackGraphic(this);
#endif
GraphicRegistry.UnregisterGraphicForCanvas(canvas, this);
CanvasUpdateRegistry.UnRegisterCanvasElementForRebuild(this);
if (canvasRenderer != null)
canvasRenderer.Clear();
LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
base.OnDisable();
}
protected override void OnDestroy()
{
if (m_CachedMesh)
Destroy(m_CachedMesh);
m_CachedMesh = null;
base.OnDestroy();
}
protected override void OnCanvasHierarchyChanged()
{
// Use m_Cavas so we dont auto call CacheCanvas
Canvas currentCanvas = m_Canvas;
// Clear the cached canvas. Will be fetched below if active.
m_Canvas = null;
if (!IsActive())
return;
CacheCanvas();
if (currentCanvas != m_Canvas)
{
GraphicRegistry.UnregisterGraphicForCanvas(currentCanvas, this);
// Only register if we are active and enabled as OnCanvasHierarchyChanged can get called
// during object destruction and we dont want to register ourself and then become null.
if (IsActive())
GraphicRegistry.RegisterGraphicForCanvas(canvas, this);
}
}
/// <summary>
/// This method must be called when <c>CanvasRenderer.cull</c> is modified.
/// </summary>
/// <remarks>
/// This can be used to perform operations that were previously skipped because the <c>Graphic</c> was culled.
/// </remarks>
public virtual void OnCullingChanged()
{
if (!canvasRenderer.cull && (m_VertsDirty || m_MaterialDirty))
{
/// When we were culled, we potentially skipped calls to <c>Rebuild</c>.
CanvasUpdateRegistry.RegisterCanvasElementForGraphicRebuild(this);
}
}
/// <summary>
/// Rebuilds the graphic geometry and its material on the PreRender cycle.
/// </summary>
/// <param name="update">The current step of the rendering CanvasUpdate cycle.</param>
/// <remarks>
/// See CanvasUpdateRegistry for more details on the canvas update cycle.
/// </remarks>
public virtual void Rebuild(CanvasUpdate update)
{
if (canvasRenderer == null || canvasRenderer.cull)
return;
switch (update)
{
case CanvasUpdate.PreRender:
if (m_VertsDirty)
{
UpdateGeometry();
m_VertsDirty = false;
}
if (m_MaterialDirty)
{
UpdateMaterial();
m_MaterialDirty = false;
}
break;
}
}
public virtual void LayoutComplete()
{}
public virtual void GraphicUpdateComplete()
{}
/// <summary>
/// Call to update the Material of the graphic onto the CanvasRenderer.
/// </summary>
protected virtual void UpdateMaterial()
{
if (!IsActive())
return;
canvasRenderer.materialCount = 1;
canvasRenderer.SetMaterial(materialForRendering, 0);
canvasRenderer.SetTexture(mainTexture);
}
/// <summary>
/// Call to update the geometry of the Graphic onto the CanvasRenderer.
/// </summary>
protected virtual void UpdateGeometry()
{
if (useLegacyMeshGeneration)
{
DoLegacyMeshGeneration();
}
else
{
DoMeshGeneration();
}
}
private void DoMeshGeneration()
{
if (rectTransform != null && rectTransform.rect.width >= 0 && rectTransform.rect.height >= 0)
OnPopulateMesh(s_VertexHelper);
else
s_VertexHelper.Clear(); // clear the vertex helper so invalid graphics dont draw.
var components = ListPool<Component>.Get();
GetComponents(typeof(IMeshModifier), components);
for (var i = 0; i < components.Count; i++)
((IMeshModifier)components[i]).ModifyMesh(s_VertexHelper);
ListPool<Component>.Release(components);
s_VertexHelper.FillMesh(workerMesh);
canvasRenderer.SetMesh(workerMesh);
}
private void DoLegacyMeshGeneration()
{
if (rectTransform != null && rectTransform.rect.width >= 0 && rectTransform.rect.height >= 0)
{
#pragma warning disable 618
OnPopulateMesh(workerMesh);
#pragma warning restore 618
}
else
{
workerMesh.Clear();
}
var components = ListPool<Component>.Get();
GetComponents(typeof(IMeshModifier), components);
for (var i = 0; i < components.Count; i++)
{
#pragma warning disable 618
((IMeshModifier)components[i]).ModifyMesh(workerMesh);
#pragma warning restore 618
}
ListPool<Component>.Release(components);
canvasRenderer.SetMesh(workerMesh);
}
protected static Mesh workerMesh
{
get
{
if (s_Mesh == null)
{
s_Mesh = new Mesh();
s_Mesh.name = "Shared UI Mesh";
s_Mesh.hideFlags = HideFlags.HideAndDontSave;
}
return s_Mesh;
}
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
[Obsolete("Use OnPopulateMesh instead.", true)]
protected virtual void OnFillVBO(System.Collections.Generic.List<UIVertex> vbo) {}
[Obsolete("Use OnPopulateMesh(VertexHelper vh) instead.", false)]
/// <summary>
/// Callback function when a UI element needs to generate vertices. Fills the vertex buffer data.
/// </summary>
/// <param name="m">Mesh to populate with UI data.</param>
/// <remarks>
/// Used by Text, UI.Image, and RawImage for example to generate vertices specific to their use case.
/// </remarks>
protected virtual void OnPopulateMesh(Mesh m)
{
OnPopulateMesh(s_VertexHelper);
s_VertexHelper.FillMesh(m);
}
/// <summary>
/// Callback function when a UI element needs to generate vertices. Fills the vertex buffer data.
/// </summary>
/// <param name="vh">VertexHelper utility.</param>
/// <remarks>
/// Used by Text, UI.Image, and RawImage for example to generate vertices specific to their use case.
/// </remarks>
protected virtual void OnPopulateMesh(VertexHelper vh)
{
var r = GetPixelAdjustedRect();
var v = new Vector4(r.x, r.y, r.x + r.width, r.y + r.height);
Color32 color32 = color;
vh.Clear();
vh.AddVert(new Vector3(v.x, v.y), color32, new Vector2(0f, 0f));
vh.AddVert(new Vector3(v.x, v.w), color32, new Vector2(0f, 1f));
vh.AddVert(new Vector3(v.z, v.w), color32, new Vector2(1f, 1f));
vh.AddVert(new Vector3(v.z, v.y), color32, new Vector2(1f, 0f));
vh.AddTriangle(0, 1, 2);
vh.AddTriangle(2, 3, 0);
}
#if UNITY_EDITOR
/// <summary>
/// Editor-only callback that is issued by Unity if a rebuild of the Graphic is required.
/// Currently sent when an asset is reimported.
/// </summary>
public virtual void OnRebuildRequested()
{
// when rebuild is requested we need to rebuild all the graphics /
// and associated components... The correct way to do this is by
// calling OnValidate... Because MB's don't have a common base class
// we do this via reflection. It's nasty and ugly... Editor only.
m_SkipLayoutUpdate = true;
var mbs = gameObject.GetComponents<MonoBehaviour>();
foreach (var mb in mbs)
{
if (mb == null)
continue;
var methodInfo = mb.GetType().GetMethod("OnValidate", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (methodInfo != null)
methodInfo.Invoke(mb, null);
}
m_SkipLayoutUpdate = false;
}
protected override void Reset()
{
SetAllDirty();
}
#endif
// Call from unity if animation properties have changed
protected override void OnDidApplyAnimationProperties()
{
SetAllDirty();
}
/// <summary>
/// Make the Graphic have the native size of its content.
/// </summary>
public virtual void SetNativeSize() {}
/// <summary>
/// When a GraphicRaycaster is raycasting into the scene it does two things. First it filters the elements using their RectTransform rect. Then it uses this Raycast function to determine the elements hit by the raycast.
/// </summary>
/// <param name="sp">Screen point being tested</param>
/// <param name="eventCamera">Camera that is being used for the testing.</param>
/// <returns>True if the provided point is a valid location for GraphicRaycaster raycasts.</returns>
public virtual bool Raycast(Vector2 sp, Camera eventCamera)
{
if (!isActiveAndEnabled)
return false;
var t = transform;
var components = ListPool<Component>.Get();
bool ignoreParentGroups = false;
bool continueTraversal = true;
while (t != null)
{
t.GetComponents(components);
for (var i = 0; i < components.Count; i++)
{
var canvas = components[i] as Canvas;
if (canvas != null && canvas.overrideSorting)
continueTraversal = false;
var filter = components[i] as ICanvasRaycastFilter;
if (filter == null)
continue;
var raycastValid = true;
var group = components[i] as CanvasGroup;
if (group != null)
{
if (ignoreParentGroups == false && group.ignoreParentGroups)
{
ignoreParentGroups = true;
raycastValid = filter.IsRaycastLocationValid(sp, eventCamera);
}
else if (!ignoreParentGroups)
raycastValid = filter.IsRaycastLocationValid(sp, eventCamera);
}
else
{
raycastValid = filter.IsRaycastLocationValid(sp, eventCamera);
}
if (!raycastValid)
{
ListPool<Component>.Release(components);
return false;
}
}
t = continueTraversal ? t.parent : null;
}
ListPool<Component>.Release(components);
return true;
}
#if UNITY_EDITOR
protected override void OnValidate()
{
base.OnValidate();
SetAllDirty();
}
#endif
///<summary>
///Adjusts the given pixel to be pixel perfect.
///</summary>
///<param name="point">Local space point.</param>
///<returns>Pixel perfect adjusted point.</returns>
///<remarks>
///Note: This is only accurate if the Graphic root Canvas is in Screen Space.
///</remarks>
public Vector2 PixelAdjustPoint(Vector2 point)
{
if (!canvas || canvas.renderMode == RenderMode.WorldSpace || canvas.scaleFactor == 0.0f || !canvas.pixelPerfect)
return point;
else
{
return RectTransformUtility.PixelAdjustPoint(point, transform, canvas);
}
}
/// <summary>
/// Returns a pixel perfect Rect closest to the Graphic RectTransform.
/// </summary>
/// <remarks>
/// Note: This is only accurate if the Graphic root Canvas is in Screen Space.
/// </remarks>
/// <returns>A Pixel perfect Rect.</returns>
public Rect GetPixelAdjustedRect()
{
if (!canvas || canvas.renderMode == RenderMode.WorldSpace || canvas.scaleFactor == 0.0f || !canvas.pixelPerfect)
return rectTransform.rect;
else
return RectTransformUtility.PixelAdjustRect(rectTransform, canvas);
}
///<summary>
///Tweens the CanvasRenderer color associated with this Graphic.
///</summary>
///<param name="targetColor">Target color.</param>
///<param name="duration">Tween duration.</param>
///<param name="ignoreTimeScale">Should ignore Time.scale?</param>
///<param name="useAlpha">Should also Tween the alpha channel?</param>
public virtual void CrossFadeColor(Color targetColor, float duration, bool ignoreTimeScale, bool useAlpha)
{
CrossFadeColor(targetColor, duration, ignoreTimeScale, useAlpha, true);
}
///<summary>
///Tweens the CanvasRenderer color associated with this Graphic.
///</summary>
///<param name="targetColor">Target color.</param>
///<param name="duration">Tween duration.</param>
///<param name="ignoreTimeScale">Should ignore Time.scale?</param>
///<param name="useAlpha">Should also Tween the alpha channel?</param>
/// <param name="useRGB">Should the color or the alpha be used to tween</param>
public virtual void CrossFadeColor(Color targetColor, float duration, bool ignoreTimeScale, bool useAlpha, bool useRGB)
{
if (canvasRenderer == null || (!useRGB && !useAlpha))
return;
Color currentColor = canvasRenderer.GetColor();
if (currentColor.Equals(targetColor))
{
m_ColorTweenRunner.StopTween();
return;
}
ColorTween.ColorTweenMode mode = (useRGB && useAlpha ?
ColorTween.ColorTweenMode.All :
(useRGB ? ColorTween.ColorTweenMode.RGB : ColorTween.ColorTweenMode.Alpha));
var colorTween = new ColorTween {duration = duration, startColor = canvasRenderer.GetColor(), targetColor = targetColor};
colorTween.AddOnChangedCallback(canvasRenderer.SetColor);
colorTween.ignoreTimeScale = ignoreTimeScale;
colorTween.tweenMode = mode;
m_ColorTweenRunner.StartTween(colorTween);
}
static private Color CreateColorFromAlpha(float alpha)
{
var alphaColor = Color.black;
alphaColor.a = alpha;
return alphaColor;
}
///<summary>
///Tweens the alpha of the CanvasRenderer color associated with this Graphic.
///</summary>
///<param name="alpha">Target alpha.</param>
///<param name="duration">Duration of the tween in seconds.</param>
///<param name="ignoreTimeScale">Should ignore [[Time.scale]]?</param>
public virtual void CrossFadeAlpha(float alpha, float duration, bool ignoreTimeScale)
{
CrossFadeColor(CreateColorFromAlpha(alpha), duration, ignoreTimeScale, true, false);
}
/// <summary>
/// Add a listener to receive notification when the graphics layout is dirtied.
/// </summary>
/// <param name="action">The method to call when invoked.</param>
public void RegisterDirtyLayoutCallback(UnityAction action)
{
m_OnDirtyLayoutCallback += action;
}
/// <summary>
/// Remove a listener from receiving notifications when the graphics layout are dirtied
/// </summary>
/// <param name="action">The method to call when invoked.</param>
public void UnregisterDirtyLayoutCallback(UnityAction action)
{
m_OnDirtyLayoutCallback -= action;
}
/// <summary>
/// Add a listener to receive notification when the graphics vertices are dirtied.
/// </summary>
/// <param name="action">The method to call when invoked.</param>
public void RegisterDirtyVerticesCallback(UnityAction action)
{
m_OnDirtyVertsCallback += action;
}
/// <summary>
/// Remove a listener from receiving notifications when the graphics vertices are dirtied
/// </summary>
/// <param name="action">The method to call when invoked.</param>
public void UnregisterDirtyVerticesCallback(UnityAction action)
{
m_OnDirtyVertsCallback -= action;
}
/// <summary>
/// Add a listener to receive notification when the graphics material is dirtied.
/// </summary>
/// <param name="action">The method to call when invoked.</param>
public void RegisterDirtyMaterialCallback(UnityAction action)
{
m_OnDirtyMaterialCallback += action;
}
/// <summary>
/// Remove a listener from receiving notifications when the graphics material are dirtied
/// </summary>
/// <param name="action">The method to call when invoked.</param>
public void UnregisterDirtyMaterialCallback(UnityAction action)
{
m_OnDirtyMaterialCallback -= action;
}
}
}1.SetAllDirty、SetLayoutDirty
Graphic verwendet den Dirty-Mark-Modus (dieses Entwurfsmuster ist im Programmiermodell des Spiels enthalten). Wenn sich einige Eigenschaften ändern, werden die Eigenschaften nicht sofort aktualisiert. Stattdessen werden diese geänderten Eigenschaften markiert und dann die Methode CanvasUpdateRegistry.RegisterCanvasElementForGraphicRebuild hinzugefügt Fügen Sie sie zu einer Warteschlange hinzu. Fügen Sie ein Element hinzu und aktualisieren Sie es gemeinsam zu einem bestimmten Zeitpunkt (in den Ereignissen OnEnable, Reset, OnDidApplyAnimationProperties, OnValidate, OnTransformParentChanged usw., wenn die Leistung aktualisiert werden muss, wird SetAllDirty aufgerufen und das entsprechende Ereignis ausgeführt gesendet. CanvasUpdateRegistry als neu zu erstellen markieren .
2.Neuaufbau
Führen Sie die Rebuild-Funktion aus. Zu diesem Zeitpunkt werden UpdateGeometry und UpdateMaterial basierend auf der Identifizierung von Dirty aufgerufen (die Identifizierung wird in SetAllDirty auf true und hier auf false gesetzt).
3. Aktualisieren Sie das Material UpdateMaterial. (Legen Sie den Wert direkt auf CanvasRenderer fest.)
4. Aktualisieren Sie die Scheitelpunktdaten UpdateGeometry.
- Dem Code zufolge können wir sehen, dass OnPopulateMesh zuerst aufgerufen wird, um Mesh-Daten zu generieren. Image, RawImage und Text überschreiben alle diese Funktion, um bestimmte Scheitelpunktdaten zu generieren.
- Rufen Sie alle Komponenten auf dem aktuellen GameObject ab, die die IMeshModifier-Schnittstelle implementieren, und rufen Sie die ModifyMesh-Methode auf, um die Mesh-Daten zu ändern
- Aktualisierte Daten auf CanvasRenderer setzen
Grafische Ereignisse: GraphicRegistry
GraphicRegistry ist dafür verantwortlich, Canvas darüber zu informieren, ob Graphic ausgeführt wurde und ob Inhalte gerendert werden müssen. Aus dem obigen Quellcode können Sie OnEnable, OnCanvasHierarchyChanged und OnTransformParentChanged sehen.
habe mich angemeldet
GraphicRegistry.RegisterGraphicForCanvas(canvas, this);Melden Sie sich in OnDisable ab
GraphicRegistry.UnregisterGraphicForCanvas(currentCanvas, this);Nach der Registrierung von GraphicRegistry über Graphic wird der Erfassungsvorgang in der Raycast-Funktion in GraphicRaycaster ausgeführt.
- GraphicRaycaster ruft die Grafik in GraphicRegistry ab und ruft die Raycast-Methode in Graphic auf.
- Rufen Sie alle Komponenten der von der Grafik bereitgestellten Transformation ab, prüfen Sie, ob ICanvasRaycastFilter implementiert ist, und rufen Sie IsRaycastLocationValid für alle Implementierungen der ICanvasRaycastFilter-Schnittstelle auf.
- IsRaycastLocationValid wird gemäß der entsprechenden Implementierung erkannt.