using System.Collections.Generic;
using System.Linq;
namespace UnityEngine.XR.Content.Rendering
{
/// <summary>
/// The HighlightController manages scripts that highlight objects in some way - those that inherit from IMaterialHighlight
/// It is in charge of locating all applicable renderers, and swapping/doing additional drawing passes as needed to represent the highlights
/// </summary>
[System.Serializable]
public class HighlightController
{
// Local method use only -- created here to reduce garbage collection. Collections must be cleared before use
static readonly List<Renderer> k_RendererComponents = new List<Renderer>();
/// <summary>
/// Holds additional data for renderers that need additional drawing passes
/// This is specically MeshRenderers with more than one submesh - we can't just extend the material array
/// to get additional drawing passes, so we use this data to draw them manually.
/// </summary>
class CustomHighlightLayer
{
internal Material[] m_HighlightMaterials;
internal Mesh m_SharedMesh;
internal Transform m_Transform;
}
[SerializeField]
[Tooltip("Used to set the mode of capturing renderers on an object or to use only manually set renderers.")]
RendererCaptureDepth m_RendererCaptureDepth = RendererCaptureDepth.AllChildRenderers;
[SerializeField]
[Tooltip("Manually set renderers to be affected by the highlight")]
protected Renderer[] m_ManuallySetRenderers = new Renderer[0];
// Cached data about any renderers that will be highlighted, and materials that are swapped in and out
int m_MaterialAdditions = 0;
List<IMaterialHighlight> m_CacheUsers = new List<IMaterialHighlight>();
HashSet<Renderer> m_Renderers = new HashSet<Renderer>();
Dictionary<int, Material[]> m_OriginalMaterials = new Dictionary<int, Material[]>();
Dictionary<int, Material[]> m_HighlightMaterials = new Dictionary<int, Material[]>();
Dictionary<int, CustomHighlightLayer> m_CustomLayerMaterials = new Dictionary<int, CustomHighlightLayer>();
bool m_DelayedUnhighlight = false;
bool m_Highlighting = false;
float m_UnhighlightTimer = 0.0f;
/// <summary>
/// The transform that will be highlighted - it is searched for any child renderers
/// </summary>
public Transform rendererSource { get; set; }
/// <summary>
/// Registers a highlight script - this will provide materials to replace or layer when highlighting an object
/// </summary>
/// <param name="cacheUser">The highlight script to apply to the cached child renderers</param>
public void RegisterCacheUser(IMaterialHighlight cacheUser)
{
if (cacheUser.highlightMode == MaterialHighlightMode.Layer)
m_MaterialAdditions++;
// Set cache user to know about this
m_CacheUsers.Add(cacheUser);
}
/// <summary>
/// Unregisters a highlight script so that it will no longer influence the cached renderers
/// </summary>
/// <param name="cacheUser">The highlight script to remove from influencing renderers</param>
public void UnregisterCacheUser(IMaterialHighlight cacheUser)
{
if (cacheUser.highlightMode == MaterialHighlightMode.Layer)
m_MaterialAdditions--;
m_CacheUsers.Remove(cacheUser);
}
/// <summary>
/// Ensures that all renderers, materials, and highlight scripts have their materials ready
/// </summary>
public void Initialize()
{
if (rendererSource == null)
{
Debug.LogError("Trying to use a Highlight Controller before setting the root gameobject!");
return;
}
foreach (var cacheUser in m_CacheUsers)
{
cacheUser.Initialize();
}
// Cache the renderers
UpdateRendererCache();
// Generate the original material list and implement the materials from the included highlights
UpdateMaterialCache();
}
/// <summary>
/// Ensures that any materials or other objects allocated by highlight scripts can be cleaned up
/// </summary>
public void Deinitialize()
{
foreach (var cacheUser in m_CacheUsers)
{
if (cacheUser != null)
cacheUser.Deinitialize();
}
}
/// <summary>
/// Handles fading out materials when highlights are disabled and also manually drawing layered highlights as needed
/// </summary>
public void Update()
{
if (m_DelayedUnhighlight)
{
m_UnhighlightTimer -= Time.deltaTime;
if (m_UnhighlightTimer <= 0.0f)
{
m_DelayedUnhighlight = false;
m_Highlighting = false;
UpdateMaterialCache();
foreach (var renderer in m_Renderers)
{
var rendererID = renderer.GetInstanceID();
renderer.materials = m_OriginalMaterials[rendererID];
}
}
}
if (m_Highlighting && m_CustomLayerMaterials.Count > 0)
{
foreach (var customLayer in m_CustomLayerMaterials.Values)
{
for (var matIndex = 0; matIndex < customLayer.m_HighlightMaterials.Length; ++matIndex)
{
for (var submeshIndex = 0; submeshIndex < customLayer.m_SharedMesh.subMeshCount; ++submeshIndex)
{
Graphics.DrawMesh(
customLayer.m_SharedMesh,
customLayer.m_Transform.localToWorldMatrix,
customLayer.m_HighlightMaterials[matIndex],
customLayer.m_Transform.gameObject.layer,
null,
submeshIndex);
}
}
}
}
}
/// <summary>
/// Applies highlight materials to all the targeted renderers
/// </summary>
public void Highlight()
{
m_DelayedUnhighlight = false;
m_Highlighting = true;
UpdateMaterialCache();
foreach (var renderer in m_Renderers)
{
var rendererID = renderer.GetInstanceID();
renderer.materials = m_HighlightMaterials[rendererID];
}
foreach (var cacheUser in m_CacheUsers)
{
if (cacheUser != null)
cacheUser.OnHighlight();
}
}
/// <summary>
/// Restores the original materials to all the targeted renderers
/// </summary>
/// <param name="force">If true, the original materials are restored instantly. Otherwise, a fade can occur.</param>
public void Unhighlight(bool force = false)
{
UpdateMaterialCache();
var maxDelay = 0.0f;
foreach (var cacheUser in m_CacheUsers)
{
if (cacheUser != null)
maxDelay = Mathf.Max(cacheUser.OnUnhighlight());
}
if (maxDelay <= 0.0f)
{
foreach (var renderer in m_Renderers)
{
var rendererID = renderer.GetInstanceID();
renderer.materials = m_OriginalMaterials[rendererID];
}
m_Highlighting = false;
}
else
{
m_DelayedUnhighlight = true;
m_UnhighlightTimer = maxDelay;
}
}
void UpdateRendererCache()
{
m_Renderers.Clear();
m_Renderers.UnionWith(m_ManuallySetRenderers.Where(r => r != null));
switch (m_RendererCaptureDepth)
{
case RendererCaptureDepth.AllChildRenderers:
rendererSource.GetComponentsInChildren(true, k_RendererComponents);
foreach (var renderer in k_RendererComponents)
{
var textMesh = renderer.GetComponent<TextMesh>();
var meshFilter = renderer.GetComponent<MeshFilter>();
if (textMesh == null)
m_Renderers.Add(renderer);
if (meshFilter != null && meshFilter.mesh.subMeshCount > 1)
m_CustomLayerMaterials.Add(renderer.GetInstanceID(), new CustomHighlightLayer { m_SharedMesh = meshFilter.sharedMesh, m_Transform = renderer.transform });
}
k_RendererComponents.Clear();
break;
case RendererCaptureDepth.CurrentRenderer:
rendererSource.GetComponents(k_RendererComponents);
foreach (var renderer in k_RendererComponents)
{
var textMesh = renderer.GetComponent<TextMesh>();
var meshFilter = renderer.GetComponent<MeshFilter>();
if (textMesh == null)
m_Renderers.Add(renderer);
if (meshFilter != null && meshFilter.mesh.subMeshCount > 1)
m_CustomLayerMaterials.Add(renderer.GetInstanceID(), new CustomHighlightLayer { m_SharedMesh = meshFilter.sharedMesh, m_Transform = renderer.transform });
}
k_RendererComponents.Clear();
break;
case RendererCaptureDepth.ManualOnly:
break;
default:
Debug.LogError($"{rendererSource.name} highlight has an invalid renderer capture mode {m_RendererCaptureDepth}.", rendererSource);
break;
}
if (m_Renderers.Count == 0)
Debug.LogWarning($"{rendererSource.name} highlight has no renderers set.", rendererSource);
}
void UpdateMaterialCache()
{
foreach (var renderer in m_Renderers)
{
var rendererID = renderer.GetInstanceID();
if (m_OriginalMaterials.ContainsKey(rendererID))
continue;
var sharedMaterials = renderer.sharedMaterials;
var sharedLength = sharedMaterials.Length;
m_OriginalMaterials[rendererID] = sharedMaterials;
CustomHighlightLayer highlightLayer = null;
Material[] highlightMaterials;
Material[] layerMaterials;
var addOffset = sharedLength;
if (m_CustomLayerMaterials.TryGetValue(rendererID, out highlightLayer))
{
highlightMaterials = new Material[sharedLength];
highlightLayer.m_HighlightMaterials = new Material[m_MaterialAdditions];
layerMaterials = highlightLayer.m_HighlightMaterials;
addOffset = 0;
}
else
{
highlightMaterials = new Material[sharedLength + m_MaterialAdditions];
layerMaterials = highlightMaterials;
}
for (var matIndex = 0; matIndex < sharedLength; matIndex++)
{
highlightMaterials[matIndex] = sharedMaterials[matIndex];
}
for (var i = 0; i < m_CacheUsers.Count; i++)
{
var cacheUser = m_CacheUsers[i];
if (cacheUser.highlightMode == MaterialHighlightMode.Replace)
{
for (var matIndex = 0; matIndex < sharedLength; matIndex++)
{
highlightMaterials[matIndex] = cacheUser.highlightMaterial;
}
}
else
{
layerMaterials[addOffset] = cacheUser.highlightMaterial;
addOffset++;
}
}
m_HighlightMaterials[rendererID] = highlightMaterials;
}
}
}
}