Project_WL/Assets/Feel/MMFeedbacks/MMFeedbacks/Feedbacks/MMF_Material.cs

281 lines
9.5 KiB
C#

using System.Collections;
using System.Collections.Generic;
using MoreMountains.Tools;
using UnityEngine;
using UnityEngine.Serialization;
using UnityEngine.Scripting.APIUpdating;
namespace MoreMountains.Feedbacks
{
[AddComponentMenu("")]
[FeedbackHelp("This feedback will let you change the material of the target renderer everytime it's played.")]
[MovedFrom(false, null, "MoreMountains.Feedbacks")]
[System.Serializable]
[FeedbackPath("Renderer/Material")]
public class MMF_Material : MMF_Feedback
{
/// sets the inspector color for this feedback
#if UNITY_EDITOR
public override Color FeedbackColor { get => MMFeedbacksInspectorColors.RendererColor; }
public override bool EvaluateRequiresSetup() => (TargetRenderer == null);
public override string RequiredTargetText => TargetRenderer != null ? TargetRenderer.name : "";
public override string RequiresSetupText => "This feedback requires that a TargetRenderer be set to be able to work properly. You can set one below.";
#endif
public override bool HasAutomatedTargetAcquisition => true;
protected override void AutomateTargetAcquisition() => TargetRenderer = FindAutomatedTarget<Renderer>();
/// a static bool used to disable all feedbacks of this type at once
public static bool FeedbackTypeAuthorized = true;
/// the duration of this feedback is the duration of the shake
public override float FeedbackDuration { get { return (InterpolateTransition) ? TransitionDuration : 0f; } set { if (InterpolateTransition) { TransitionDuration = value; } } }
/// the possible methods to switch materials
public enum Methods { Sequential, Random }
[MMFInspectorGroup("Target Material", true, 61, true)]
/// the renderer to change material on
[Tooltip("the renderer to change material on")]
public Renderer TargetRenderer;
/// the list of material indexes we want to change on the target renderer. If left empty, will only target the material at index 0
[FormerlySerializedAs("MaterialIndexes")] [Tooltip("the list of material indexes we want to change on the target renderer. If left empty, will only target the material at index 0")]
public int[] RendererMaterialIndexes;
[MMFInspectorGroup("Material Change", true, 33)]
/// the selected method
[Tooltip("the selected method")]
public Methods Method;
/// whether or not the sequential order should loop
[MMFEnumCondition("Method", (int)Methods.Sequential)]
[Tooltip("whether or not the sequential order should loop")]
public bool Loop = true;
/// whether or not to always pick a new material in random mode
[MMFEnumCondition("Method", (int)Methods.Random)]
[Tooltip("whether or not to always pick a new material in random mode")]
public bool AlwaysNewMaterial = true;
/// the initial index to start with
[Tooltip("the initial index to start with")]
public int InitialIndex = 0;
/// the list of materials to pick from
[Tooltip("the list of materials to pick from")]
public List<Material> Materials;
[MMFInspectorGroup("Interpolation", true, 35)]
/// whether or not to interpolate between 2 materials
/// IMPORTANT : this will only work for materials that share the same shader and texture (see https://docs.unity3d.com/ScriptReference/Material.Lerp.html)
public bool InterpolateTransition = false;
/// the duration of the interpolation, in seconds
public float TransitionDuration = 1f;
/// the animation curve to interpolate the transition on
public AnimationCurve TransitionCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(1, 1));
public virtual float GetTime() { return (ComputedTimescaleMode == TimescaleModes.Scaled) ? Time.time : Time.unscaledTime; }
public virtual float GetDeltaTime() { return (ComputedTimescaleMode == TimescaleModes.Scaled) ? Time.deltaTime : Time.unscaledDeltaTime; }
protected int _currentIndex;
protected float _startedAt;
protected Coroutine[] _coroutines;
protected Material[] _tempMaterials;
protected Material[] _initialMaterials;
/// <summary>
/// On init, grabs the current index
/// </summary>
/// <param name="owner"></param>
protected override void CustomInitialization(MMF_Player owner)
{
base.CustomInitialization(owner);
InitializeMaterials();
}
protected virtual void InitializeMaterials()
{
if (Materials == null)
{
Materials = new List<Material>();
}
if (TargetRenderer == null)
{
return;
}
_currentIndex = InitialIndex;
_tempMaterials = new Material[TargetRenderer.materials.Length];
_initialMaterials = new Material[TargetRenderer.materials.Length];
for (int i = 0; i < _initialMaterials.Length; i++)
{
_initialMaterials[i] = new Material(TargetRenderer.materials[i]);
}
if (RendererMaterialIndexes == null)
{
RendererMaterialIndexes = new int[1];
}
if (RendererMaterialIndexes.Length == 0)
{
RendererMaterialIndexes = new int[1];
RendererMaterialIndexes[0] = 0;
}
_coroutines = new Coroutine[RendererMaterialIndexes.Length];
}
/// <summary>
/// On play feedback, we change the material if possible
/// </summary>
/// <param name="position"></param>
/// <param name="feedbacksIntensity"></param>
protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
{
if (!Active || !FeedbackTypeAuthorized)
{
return;
}
if (Materials.Count == 0)
{
Debug.LogWarning("[Material Feedback] The material feedback on "+Owner.name+" has an empty Materials array.");
return;
}
int newIndex = DetermineNextIndex();
if (Materials[newIndex] == null)
{
Debug.LogWarning("[Material Feedback] The material feedback on "+Owner.name+" is attempting to switch to a null material.");
return;
}
if (InterpolateTransition)
{
for (int i = 0; i < RendererMaterialIndexes.Length; i++)
{
if (_coroutines[i] != null) { Owner.StopCoroutine(_coroutines[i]); }
_coroutines[i] = Owner.StartCoroutine(TransitionMaterial(TargetRenderer.materials[RendererMaterialIndexes[i]], Materials[newIndex], RendererMaterialIndexes[i]));
}
}
else
{
ApplyMaterial(Materials[newIndex]);
}
}
/// <summary>
/// Applies the new material to all indexes
/// </summary>
/// <param name="material"></param>
protected virtual void ApplyMaterial(Material material)
{
_tempMaterials = TargetRenderer.materials;
for (int i = 0; i < RendererMaterialIndexes.Length; i++)
{
_tempMaterials[RendererMaterialIndexes[i]] = material;
}
TargetRenderer.materials = _tempMaterials;
}
/// <summary>
/// Lerps to destination material for all indexes
/// </summary>
/// <param name="fromMaterial"></param>
/// <param name="toMaterial"></param>
/// <param name="t"></param>
/// <param name="materialIndex"></param>
protected virtual void LerpMaterial(Material fromMaterial, Material toMaterial, float t, int materialIndex)
{
_tempMaterials = TargetRenderer.materials;
for (int i = 0; i < RendererMaterialIndexes.Length; i++)
{
_tempMaterials[materialIndex].Lerp(fromMaterial, toMaterial, t);
}
TargetRenderer.materials = _tempMaterials;
}
/// <summary>
/// A coroutine used to interpolate between materials
/// </summary>
/// <param name="originalMaterial"></param>
/// <param name="newMaterial"></param>
/// <returns></returns>
protected virtual IEnumerator TransitionMaterial(Material originalMaterial, Material newMaterial, int materialIndex)
{
IsPlaying = true;
_startedAt = GetTime();
while (GetTime() - _startedAt < TransitionDuration)
{
float time = MMFeedbacksHelpers.Remap(GetTime() - _startedAt, 0f, TransitionDuration, 0f, 1f);
float t = TransitionCurve.Evaluate(time);
LerpMaterial(originalMaterial, newMaterial, t, materialIndex);
yield return null;
}
float finalt = TransitionCurve.Evaluate(1f);
LerpMaterial(originalMaterial, newMaterial, finalt, materialIndex);
IsPlaying = false;
}
/// <summary>
/// Determines the new material to pick
/// </summary>
/// <returns></returns>
protected virtual int DetermineNextIndex()
{
switch(Method)
{
case Methods.Random:
int random = Random.Range(0, Materials.Count);
if (AlwaysNewMaterial)
{
while (_currentIndex == random)
{
random = Random.Range(0, Materials.Count);
}
}
_currentIndex = random;
return _currentIndex;
case Methods.Sequential:
_currentIndex++;
if (_currentIndex >= Materials.Count)
{
_currentIndex = Loop ? 0 : _currentIndex - 1;
}
return _currentIndex;
}
return 0;
}
/// <summary>
/// Stops the transition on stop if needed
/// </summary>
/// <param name="position"></param>
/// <param name="feedbacksIntensity"></param>
protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
{
base.CustomStopFeedback(position, feedbacksIntensity);
if (Active && FeedbackTypeAuthorized && (_coroutines != null))
{
IsPlaying = false;
for (int i = 0; i < RendererMaterialIndexes.Length; i++)
{
if (_coroutines[i] != null)
{
Owner.StopCoroutine(_coroutines[i]);
}
_coroutines[i] = null;
}
}
}
/// <summary>
/// On restore, we put our object back at its initial position
/// </summary>
protected override void CustomRestoreInitialValues()
{
if (!Active || !FeedbackTypeAuthorized)
{
return;
}
TargetRenderer.materials = _initialMaterials;
InitializeMaterials();
}
}
}