You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
CrowdControl/Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/MMTools/Feedbacks/Legacy/MMFeedbackShaderController.cs

220 lines
8.8 KiB
C#

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using MoreMountains.Tools;
namespace MoreMountains.Feedbacks
{
/// <summary>
/// This feedback will let you control values on a target ShaderController, letting you modify the behaviour and aspect of a shader driven material at runtime
/// </summary>
[AddComponentMenu("")]
[FeedbackHelp("This feedback lets you trigger a one time play on a target ShaderController.")]
[FeedbackPath("Renderer/ShaderController")]
public class MMFeedbackShaderController : MMFeedback
{
/// a static bool used to disable all feedbacks of this type at once
public static bool FeedbackTypeAuthorized = true;
/// the different possible modes
public enum Modes { OneTime, ToDestination }
/// sets the inspector color for this feedback
#if UNITY_EDITOR
public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.RendererColor; } }
#endif
[Header("Float Controller")]
/// the mode this controller is in
[Tooltip("the mode this controller is in")]
public Modes Mode = Modes.OneTime;
/// the float controller to trigger a one time play on
[Tooltip("the float controller to trigger a one time play on")]
public ShaderController TargetShaderController;
/// an optional list of float controllers to trigger a one time play on
[Tooltip("an optional list of float controllers to trigger a one time play on")]
public List<ShaderController> TargetShaderControllerList;
/// whether this should revert to original at the end
[Tooltip("whether this should revert to original at the end")]
public bool RevertToInitialValueAfterEnd = false;
/// the duration of the One Time shake
[Tooltip("the duration of the One Time shake")]
[MMFEnumCondition("Mode", (int)Modes.OneTime)]
public float OneTimeDuration = 1f;
/// the amplitude of the One Time shake (this will be multiplied by the curve's height)
[Tooltip("the amplitude of the One Time shake (this will be multiplied by the curve's height)")]
[MMFEnumCondition("Mode", (int)Modes.OneTime)]
public float OneTimeAmplitude = 1f;
/// the low value to remap the normalized curve value to
[Tooltip("the low value to remap the normalized curve value to")]
[MMFEnumCondition("Mode", (int)Modes.OneTime)]
public float OneTimeRemapMin = 0f;
/// the high value to remap the normalized curve value to
[Tooltip("the high value to remap the normalized curve value to")]
[MMFEnumCondition("Mode", (int)Modes.OneTime)]
public float OneTimeRemapMax = 1f;
/// the curve to apply to the one time shake
[Tooltip("the curve to apply to the one time shake")]
[MMFEnumCondition("Mode", (int)Modes.OneTime)]
public AnimationCurve OneTimeCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));
/// the new value towards which to move the current value
[Tooltip("the new value towards which to move the current value")]
[MMFEnumCondition("Mode", (int)Modes.ToDestination)]
public float ToDestinationValue = 1f;
/// the duration over which to interpolate the target value
[Tooltip("the duration over which to interpolate the target value")]
[MMFEnumCondition("Mode", (int)Modes.ToDestination)]
public float ToDestinationDuration = 1f;
/// the color to aim for (when targetting a Color property
[Tooltip("the color to aim for (when targetting a Color property")]
[MMFEnumCondition("Mode", (int)Modes.ToDestination)]
public Color ToDestinationColor = Color.red;
/// the curve over which to interpolate the value
[Tooltip("the curve over which to interpolate the value")]
[MMFEnumCondition("Mode", (int)Modes.ToDestination)]
public AnimationCurve ToDestinationCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));
/// the duration of this feedback is the duration of the one time hit
public override float FeedbackDuration
{
get { return (Mode == Modes.OneTime) ? ApplyTimeMultiplier(OneTimeDuration) : ApplyTimeMultiplier(ToDestinationDuration); }
set { OneTimeDuration = value; ToDestinationDuration = value; }
}
protected float _oneTimeDurationStorage;
protected float _oneTimeAmplitudeStorage;
protected float _oneTimeRemapMinStorage;
protected float _oneTimeRemapMaxStorage;
protected AnimationCurve _oneTimeCurveStorage;
protected float _toDestinationValueStorage;
protected float _toDestinationDurationStorage;
protected AnimationCurve _toDestinationCurveStorage;
protected bool _revertToInitialValueAfterEndStorage;
/// <summary>
/// On init we grab our initial controller values
/// </summary>
/// <param name="owner"></param>
protected override void CustomInitialization(GameObject owner)
{
if (Active && (TargetShaderController != null))
{
_oneTimeDurationStorage = TargetShaderController.OneTimeDuration;
_oneTimeAmplitudeStorage = TargetShaderController.OneTimeAmplitude;
_oneTimeCurveStorage = TargetShaderController.OneTimeCurve;
_oneTimeRemapMinStorage = TargetShaderController.OneTimeRemapMin;
_oneTimeRemapMaxStorage = TargetShaderController.OneTimeRemapMax;
_toDestinationCurveStorage = TargetShaderController.ToDestinationCurve;
_toDestinationDurationStorage = TargetShaderController.ToDestinationDuration;
_toDestinationValueStorage = TargetShaderController.ToDestinationValue;
_revertToInitialValueAfterEndStorage = TargetShaderController.RevertToInitialValueAfterEnd;
}
}
/// <summary>
/// On play we trigger a OneTime or ToDestination play on our shader controller
/// </summary>
/// <param name="position"></param>
/// <param name="feedbacksIntensity"></param>
protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
{
if (!Active || !FeedbackTypeAuthorized || (TargetShaderController == null))
{
return;
}
float intensityMultiplier = Timing.ConstantIntensity ? 1f : feedbacksIntensity;
PerformPlay(TargetShaderController, intensityMultiplier);
foreach (ShaderController shaderController in TargetShaderControllerList)
{
PerformPlay(shaderController, intensityMultiplier);
}
}
protected virtual void PerformPlay(ShaderController shaderController, float intensityMultiplier)
{
shaderController.RevertToInitialValueAfterEnd = RevertToInitialValueAfterEnd;
if (Mode == Modes.OneTime)
{
shaderController.OneTimeDuration = FeedbackDuration;
shaderController.OneTimeAmplitude = OneTimeAmplitude;
shaderController.OneTimeCurve = OneTimeCurve;
if (NormalPlayDirection)
{
shaderController.OneTimeRemapMin = OneTimeRemapMin * intensityMultiplier;
shaderController.OneTimeRemapMax = OneTimeRemapMax * intensityMultiplier;
}
else
{
shaderController.OneTimeRemapMin = OneTimeRemapMax * intensityMultiplier;
shaderController.OneTimeRemapMax = OneTimeRemapMin * intensityMultiplier;
}
shaderController.OneTime();
}
if (Mode == Modes.ToDestination)
{
shaderController.ToColor = ToDestinationColor;
shaderController.ToDestinationCurve = ToDestinationCurve;
shaderController.ToDestinationDuration = FeedbackDuration;
shaderController.ToDestinationValue = ToDestinationValue;
shaderController.ToDestination();
}
}
/// <summary>
/// Stops this feedback
/// </summary>
/// <param name="position"></param>
/// <param name="feedbacksIntensity"></param>
protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
{
if (!Active || !FeedbackTypeAuthorized)
{
return;
}
base.CustomStopFeedback(position, feedbacksIntensity);
if (TargetShaderController != null)
{
TargetShaderController.Stop();
}
foreach (ShaderController shaderController in TargetShaderControllerList)
{
shaderController.Stop();
}
}
/// <summary>
/// On reset we restore our initial values
/// </summary>
protected override void CustomReset()
{
base.CustomReset();
if (Active && FeedbackTypeAuthorized && (TargetShaderController != null))
{
PerformReset(TargetShaderController);
}
foreach (ShaderController shaderController in TargetShaderControllerList)
{
PerformReset(shaderController);
}
}
protected virtual void PerformReset(ShaderController shaderController)
{
shaderController.OneTimeDuration = _oneTimeDurationStorage;
shaderController.OneTimeAmplitude = _oneTimeAmplitudeStorage;
shaderController.OneTimeCurve = _oneTimeCurveStorage;
shaderController.OneTimeRemapMin = _oneTimeRemapMinStorage;
shaderController.OneTimeRemapMax = _oneTimeRemapMaxStorage;
shaderController.ToDestinationCurve = _toDestinationCurveStorage;
shaderController.ToDestinationDuration = _toDestinationDurationStorage;
shaderController.ToDestinationValue = _toDestinationValueStorage;
shaderController.RevertToInitialValueAfterEnd = _revertToInitialValueAfterEndStorage;
}
}
}