784 lines
30 KiB
C#
784 lines
30 KiB
C#
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using System.Reflection;
|
|
using UnityEngine.UI;
|
|
|
|
namespace MoreMountains.Tools
|
|
{
|
|
|
|
/// <summary>
|
|
/// A class used to control a float in any other class, over time
|
|
/// To use it, simply drag a monobehaviour in its target field, pick a control mode (ping pong or random), and tweak the settings
|
|
/// </summary>
|
|
[MMRequiresConstantRepaint]
|
|
[AddComponentMenu("More Mountains/Tools/Property Controllers/ShaderController")]
|
|
public class ShaderController : MMMonoBehaviour
|
|
{
|
|
/// the possible types of targets
|
|
public enum TargetTypes { Renderer, Image, RawImage, Text }
|
|
/// the possible types of properties
|
|
public enum PropertyTypes { Bool, Float, Int, Vector, Keyword, Color }
|
|
/// the possible control modes
|
|
public enum ControlModes { PingPong, Random, OneTime, AudioAnalyzer, ToDestination, Driven }
|
|
|
|
[Header("Target")]
|
|
/// the type of renderer to pilot
|
|
public TargetTypes TargetType = TargetTypes.Renderer;
|
|
/// the renderer with the shader you want to control
|
|
[MMEnumCondition("TargetType",(int)TargetTypes.Renderer)]
|
|
public Renderer TargetRenderer;
|
|
/// the ID of the material in the Materials array on the target renderer (usually 0)
|
|
[MMEnumCondition("TargetType", (int)TargetTypes.Renderer)]
|
|
public int TargetMaterialID = 0;
|
|
/// the Image with the shader you want to control
|
|
[MMEnumCondition("TargetType", (int)TargetTypes.Image)]
|
|
public Image TargetImage;
|
|
/// if this is true, the 'materialForRendering' for this Image will be used, instead of the regular material
|
|
[MMEnumCondition("TargetType", (int)TargetTypes.Image)]
|
|
public bool UseMaterialForRendering = false;
|
|
/// the RawImage with the shader you want to control
|
|
[MMEnumCondition("TargetType", (int)TargetTypes.RawImage)]
|
|
public RawImage TargetRawImage;
|
|
/// the Text with the shader you want to control
|
|
[MMEnumCondition("TargetType", (int)TargetTypes.Text)]
|
|
public Text TargetText;
|
|
/// if this is true, material will be cached on Start
|
|
public bool CacheMaterial = true;
|
|
/// if this is true, an instance of the material will be created on start so that this controller only affects its target
|
|
public bool CreateMaterialInstance = false;
|
|
/// the EXACT name of the property to affect
|
|
public string TargetPropertyName;
|
|
/// the type of the property to affect
|
|
public PropertyTypes PropertyType = PropertyTypes.Float;
|
|
/// whether or not to affect its x component
|
|
[MMEnumCondition("PropertyType", (int)PropertyTypes.Vector)]
|
|
public bool X;
|
|
/// whether or not to affect its y component
|
|
[MMEnumCondition("PropertyType", (int)PropertyTypes.Vector)]
|
|
public bool Y;
|
|
/// whether or not to affect its z component
|
|
[MMEnumCondition("PropertyType", (int)PropertyTypes.Vector)]
|
|
public bool Z;
|
|
/// whether or not to affect its w component
|
|
[MMEnumCondition("PropertyType", (int)PropertyTypes.Vector)]
|
|
public bool W;
|
|
|
|
[Header("Color")]
|
|
/// the color to lerp from
|
|
[ColorUsage(true, true)]
|
|
public Color FromColor = Color.black;
|
|
/// the color to lerp to
|
|
[ColorUsage(true, true)]
|
|
public Color ToColor = Color.white;
|
|
|
|
[Header("Global Settings")]
|
|
/// the control mode (ping pong or random)
|
|
public ControlModes ControlMode;
|
|
/// whether or not the updated value should be added to the initial one
|
|
public bool AddToInitialValue = false;
|
|
/// whether or not to use unscaled time
|
|
public bool UseUnscaledTime = true;
|
|
/// whether or not you want to revert to the InitialValue after the control ends
|
|
public bool RevertToInitialValueAfterEnd = true;
|
|
/// if this is true, this component will use material property blocks instead of working on an instance of the material.
|
|
[Tooltip("if this is true, this component will use material property blocks instead of working on an instance of the material.")]
|
|
[MMEnumCondition("TargetType", (int)TargetTypes.Renderer)]
|
|
public bool UseMaterialPropertyBlocks = false;
|
|
/// whether or not to perform extra safety checks (safer, more costly)
|
|
public bool SafeMode = false;
|
|
|
|
/// the curve to apply to the tween
|
|
[Header("Ping Pong")]
|
|
public MMTweenType Curve;
|
|
/// the minimum value for the ping pong
|
|
public float MinValue = 0f;
|
|
/// the maximum value for the ping pong
|
|
public float MaxValue = 5f;
|
|
/// the duration of one ping (or pong)
|
|
public float Duration = 1f;
|
|
/// the duration of the pause between two ping (or pongs) (in seconds)
|
|
public float PingPongPauseDuration = 1f;
|
|
|
|
[Header("Driven")]
|
|
/// the value that will be applied to the controlled float in driven mode
|
|
public float DrivenLevel = 0f;
|
|
|
|
[Header("Random")]
|
|
[MMVector("Min", "Max")]
|
|
/// the noise amplitude
|
|
public Vector2 Amplitude = new Vector2(0f,5f);
|
|
[MMVector("Min", "Max")]
|
|
/// the noise frequency
|
|
public Vector2 Frequency = new Vector2(1f, 1f);
|
|
[MMVector("Min", "Max")]
|
|
/// the noise shift
|
|
public Vector2 Shift = new Vector2(0f, 1f);
|
|
|
|
/// if this is true, will let you remap the noise value (without amplitude) to the bounds you've specified
|
|
public bool RemapNoiseValues = false;
|
|
/// the value to which to remap the random's zero bound
|
|
[MMCondition("RemapNoiseValues", true)]
|
|
public float RemapNoiseZero = 0f;
|
|
/// the value to which to remap the random's one bound
|
|
[MMCondition("RemapNoiseValues", true)]
|
|
public float RemapNoiseOne = 1f;
|
|
|
|
[Header("OneTime")]
|
|
/// the duration of the One Time shake
|
|
public float OneTimeDuration = 1f;
|
|
/// the amplitude of the One Time shake (this will be multiplied by the curve's height)
|
|
public float OneTimeAmplitude = 1f;
|
|
/// the low value to remap the normalized curve value to
|
|
public float OneTimeRemapMin = 0f;
|
|
/// the high value to remap the normalized curve value to
|
|
public float OneTimeRemapMax = 1f;
|
|
/// the curve to apply to the one time shake
|
|
public AnimationCurve OneTimeCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));
|
|
[MMInspectorButton("OneTime")]
|
|
/// a test button for the one time shake
|
|
public bool OneTimeButton;
|
|
/// whether or not this controller should go back to sleep after a OneTime
|
|
public bool DisableAfterOneTime = false;
|
|
/// whether or not this controller should go back to sleep after a OneTime
|
|
public bool DisableGameObjectAfterOneTime = false;
|
|
|
|
[Header("AudioAnalyzer")]
|
|
/// the bound audio analyzer used to drive this controller
|
|
public MMAudioAnalyzer AudioAnalyzer;
|
|
/// the ID of the selected beat on the analyzer
|
|
public int BeatID;
|
|
/// the multiplier to apply to the value out of the analyzer
|
|
public float AudioAnalyzerMultiplier = 1f;
|
|
/// the offset to apply to the value out of the analyzer
|
|
public float AudioAnalyzerOffset = 0f;
|
|
/// the speed at which to lerp the value
|
|
public float AudioAnalyzerLerp = 60f;
|
|
|
|
[Header("ToDestination")]
|
|
/// the value to go to when in ToDestination mode
|
|
public float ToDestinationValue = 1f;
|
|
/// the duration of the ToDestination tween
|
|
public float ToDestinationDuration = 1f;
|
|
/// the curve to use to tween to the ToDestination value
|
|
public AnimationCurve ToDestinationCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 0.6f), new Keyframe(1f, 1f));
|
|
/// a test button for the one time shake
|
|
[MMInspectorButton("ToDestination")]
|
|
public bool ToDestinationButton;
|
|
/// whether or not this controller should go back to sleep after a OneTime
|
|
public bool DisableAfterToDestination = false;
|
|
|
|
[Header("Debug")]
|
|
[MMReadOnly]
|
|
/// the initial value of the controlled float
|
|
public float InitialValue;
|
|
[MMReadOnly]
|
|
/// the current value of the controlled float
|
|
public float CurrentValue;
|
|
[MMReadOnly]
|
|
/// the current value of the controlled float, normalized
|
|
public float CurrentValueNormalized = 0f;
|
|
[MMReadOnly]
|
|
/// the current value of the controlled float
|
|
public Color InitialColor;
|
|
|
|
[MMReadOnly]
|
|
/// the ID of the property
|
|
public int PropertyID;
|
|
[MMReadOnly]
|
|
/// whether or not the property got found
|
|
public bool PropertyFound = false;
|
|
[MMReadOnly]
|
|
/// the target material
|
|
public Material TargetMaterial;
|
|
|
|
/// internal use only
|
|
[HideInInspector]
|
|
public float PingPong;
|
|
|
|
protected float _randomAmplitude;
|
|
protected float _randomFrequency;
|
|
protected float _randomShift;
|
|
protected float _elapsedTime = 0f;
|
|
|
|
protected bool _shaking = false;
|
|
protected float _startedTimestamp = 0f;
|
|
protected float _remappedTimeSinceStart = 0f;
|
|
protected Color _currentColor;
|
|
|
|
protected Vector4 _vectorValue;
|
|
|
|
protected float _pingPongDirection = 1f;
|
|
protected float _lastPingPongPauseAt = 0f;
|
|
protected float _initialValue = 0f;
|
|
protected Color _fromColorStorage;
|
|
protected bool _activeLastFrame = false;
|
|
protected MaterialPropertyBlock _propertyBlock;
|
|
|
|
/// <summary>
|
|
/// Finds an attribute (property or field) on the target object
|
|
/// </summary>
|
|
/// <param name="propertyName"></param>
|
|
/// <returns></returns>
|
|
public virtual bool FindShaderProperty(string propertyName)
|
|
{
|
|
if (TargetType == TargetTypes.Renderer)
|
|
{
|
|
if (CreateMaterialInstance)
|
|
{
|
|
TargetRenderer.materials[TargetMaterialID] = new Material(TargetRenderer.materials[TargetMaterialID]);
|
|
}
|
|
TargetMaterial = UseMaterialPropertyBlocks ? TargetRenderer.sharedMaterials[TargetMaterialID] : TargetRenderer.materials[TargetMaterialID];
|
|
}
|
|
else if (TargetType == TargetTypes.Image)
|
|
{
|
|
if (CreateMaterialInstance)
|
|
{
|
|
TargetImage.material = new Material(TargetImage.material);
|
|
}
|
|
TargetMaterial = TargetImage.material;
|
|
}
|
|
else if (TargetType == TargetTypes.RawImage)
|
|
{
|
|
if (CreateMaterialInstance)
|
|
{
|
|
TargetRawImage.material = new Material(TargetRawImage.material);
|
|
}
|
|
TargetMaterial = TargetRawImage.material;
|
|
}
|
|
else if (TargetType == TargetTypes.Text)
|
|
{
|
|
if (CreateMaterialInstance)
|
|
{
|
|
TargetText.material = new Material(TargetText.material);
|
|
}
|
|
TargetMaterial = TargetText.material;
|
|
}
|
|
|
|
if (PropertyType == PropertyTypes.Keyword)
|
|
{
|
|
PropertyFound = true;
|
|
return true;
|
|
}
|
|
if (TargetMaterial.HasProperty(propertyName))
|
|
{
|
|
PropertyID = Shader.PropertyToID(propertyName);
|
|
PropertyFound = true;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// On start we initialize our controller
|
|
/// </summary>
|
|
protected virtual void Awake()
|
|
{
|
|
Initialization();
|
|
}
|
|
|
|
/// <summary>
|
|
/// On enable, grabs the initial value
|
|
/// </summary>
|
|
protected virtual void OnEnable()
|
|
{
|
|
InitialValue = GetInitialValue();
|
|
if (PropertyType == PropertyTypes.Color)
|
|
{
|
|
InitialColor = TargetMaterial.GetColor(PropertyID);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if the renderer is null, false otherwise
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected virtual bool RendererIsNull()
|
|
{
|
|
if ((TargetType == TargetTypes.Renderer) && (TargetRenderer == null))
|
|
{
|
|
return true;
|
|
}
|
|
if ((TargetType == TargetTypes.Image) && (TargetImage == null))
|
|
{
|
|
return true;
|
|
}
|
|
if ((TargetType == TargetTypes.RawImage) && (TargetRawImage == null))
|
|
{
|
|
return true;
|
|
}
|
|
if ((TargetType == TargetTypes.Text) && (TargetText == null))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Grabs the target property and initializes stuff
|
|
/// </summary>
|
|
public virtual void Initialization()
|
|
{
|
|
if (RendererIsNull() || (string.IsNullOrEmpty(TargetPropertyName)))
|
|
{
|
|
return;
|
|
}
|
|
if (TargetType != TargetTypes.Renderer)
|
|
{
|
|
UseMaterialPropertyBlocks = false;
|
|
}
|
|
|
|
PropertyFound = FindShaderProperty(TargetPropertyName);
|
|
if (!PropertyFound)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_elapsedTime = 0f;
|
|
_randomAmplitude = Random.Range(Amplitude.x, Amplitude.y);
|
|
_randomFrequency = Random.Range(Frequency.x, Frequency.y);
|
|
_randomShift = Random.Range(Shift.x, Shift.y);
|
|
|
|
if ((TargetType == TargetTypes.Renderer) && UseMaterialPropertyBlocks)
|
|
{
|
|
_propertyBlock = new MaterialPropertyBlock();
|
|
TargetRenderer.GetPropertyBlock(_propertyBlock, TargetMaterialID);
|
|
}
|
|
|
|
InitialValue = GetInitialValue();
|
|
if (PropertyType == PropertyTypes.Color)
|
|
{
|
|
InitialColor = TargetMaterial.GetColor(PropertyID);
|
|
}
|
|
|
|
_shaking = false;
|
|
if (ControlMode == ControlModes.OneTime)
|
|
{
|
|
this.enabled = false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the level to the value passed in parameters
|
|
/// </summary>
|
|
/// <param name="level"></param>
|
|
public virtual void SetDrivenLevelAbsolute(float level)
|
|
{
|
|
DrivenLevel = level;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the level to the remapped value passed in parameters
|
|
/// </summary>
|
|
/// <param name="normalizedLevel"></param>
|
|
/// <param name="remapZero"></param>
|
|
/// <param name="remapOne"></param>
|
|
public virtual void SetDrivenLevelNormalized(float normalizedLevel, float remapZero, float remapOne)
|
|
{
|
|
DrivenLevel = MMMaths.Remap(normalizedLevel, 0f, 1f, remapZero, remapOne);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Triggers a one time shake of the shader controller
|
|
/// </summary>
|
|
public virtual void OneTime()
|
|
{
|
|
if (!CacheMaterial)
|
|
{
|
|
Initialization();
|
|
}
|
|
|
|
if (RendererIsNull() || (!PropertyFound))
|
|
{
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
this.gameObject.SetActive(true);
|
|
this.enabled = true;
|
|
ControlMode = ControlModes.OneTime;
|
|
_startedTimestamp = GetTime();
|
|
_shaking = true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Triggers a one time shake of the controller to a specified destination value
|
|
/// </summary>
|
|
public virtual void ToDestination()
|
|
{
|
|
if (!CacheMaterial)
|
|
{
|
|
Initialization();
|
|
}
|
|
if (RendererIsNull() || (!PropertyFound))
|
|
{
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
this.enabled = true;
|
|
if (PropertyType == PropertyTypes.Color)
|
|
{
|
|
_fromColorStorage = FromColor;
|
|
FromColor = TargetMaterial.GetColor(PropertyID);
|
|
}
|
|
ControlMode = ControlModes.ToDestination;
|
|
_startedTimestamp = GetTime();
|
|
_shaking = true;
|
|
_initialValue = GetInitialValue();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the relevant delta time
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected float GetDeltaTime()
|
|
{
|
|
return UseUnscaledTime ? Time.unscaledDeltaTime : Time.deltaTime;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the relevant time
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected float GetTime()
|
|
{
|
|
return UseUnscaledTime ? Time.unscaledTime : Time.time;
|
|
}
|
|
|
|
/// <summary>
|
|
/// On Update, we move our value based on the defined settings
|
|
/// </summary>
|
|
protected virtual void Update()
|
|
{
|
|
UpdateValue();
|
|
}
|
|
|
|
protected virtual void OnDisable()
|
|
{
|
|
if (RevertToInitialValueAfterEnd)
|
|
{
|
|
CurrentValue = InitialValue;
|
|
_currentColor = InitialColor;
|
|
SetValue(CurrentValue);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the value over time based on the selected options
|
|
/// </summary>
|
|
protected virtual void UpdateValue()
|
|
{
|
|
if (SafeMode)
|
|
{
|
|
if (RendererIsNull() || (!PropertyFound))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
switch (ControlMode)
|
|
{
|
|
case ControlModes.PingPong:
|
|
if (GetTime() - _lastPingPongPauseAt < PingPongPauseDuration)
|
|
{
|
|
return;
|
|
}
|
|
PingPong += GetDeltaTime() * _pingPongDirection;
|
|
if (PingPong < 0f)
|
|
{
|
|
PingPong = 0f;
|
|
_pingPongDirection = -_pingPongDirection;
|
|
_lastPingPongPauseAt = GetTime();
|
|
}
|
|
|
|
if (PingPong > Duration)
|
|
{
|
|
PingPong = Duration;
|
|
_pingPongDirection = -_pingPongDirection;
|
|
_lastPingPongPauseAt = GetTime();
|
|
}
|
|
CurrentValue = MMTween.Tween(PingPong, 0f, Duration, MinValue, MaxValue, Curve);
|
|
CurrentValueNormalized = MMMaths.Remap(CurrentValue, MinValue, MaxValue, 0f, 1f);
|
|
break;
|
|
case ControlModes.Random:
|
|
_elapsedTime += GetDeltaTime();
|
|
CurrentValueNormalized = Mathf.PerlinNoise(_randomFrequency * _elapsedTime, _randomShift);
|
|
if (RemapNoiseValues)
|
|
{
|
|
CurrentValue = CurrentValueNormalized;
|
|
CurrentValue = MMMaths.Remap(CurrentValue, 0f, 1f, RemapNoiseZero, RemapNoiseOne);
|
|
}
|
|
else
|
|
{
|
|
CurrentValue = (CurrentValueNormalized * 2.0f - 1.0f) * _randomAmplitude;
|
|
}
|
|
break;
|
|
case ControlModes.OneTime:
|
|
if (!_shaking)
|
|
{
|
|
return;
|
|
}
|
|
_remappedTimeSinceStart = MMMaths.Remap(GetTime() - _startedTimestamp, 0f, OneTimeDuration, 0f, 1f);
|
|
CurrentValueNormalized = OneTimeCurve.Evaluate(_remappedTimeSinceStart);
|
|
CurrentValue = MMMaths.Remap(CurrentValueNormalized, 0f, 1f, OneTimeRemapMin, OneTimeRemapMax);
|
|
CurrentValue *= OneTimeAmplitude;
|
|
break;
|
|
case ControlModes.AudioAnalyzer:
|
|
CurrentValue = Mathf.Lerp(CurrentValue, AudioAnalyzer.Beats[BeatID].CurrentValue * AudioAnalyzerMultiplier + AudioAnalyzerOffset, AudioAnalyzerLerp * GetDeltaTime());
|
|
CurrentValueNormalized = Mathf.Clamp(AudioAnalyzer.Beats[BeatID].CurrentValue, 0f, 1f);
|
|
break;
|
|
case ControlModes.Driven:
|
|
CurrentValue = DrivenLevel;
|
|
CurrentValueNormalized = Mathf.Clamp(CurrentValue, 0f, 1f);
|
|
break;
|
|
case ControlModes.ToDestination:
|
|
if (!_shaking)
|
|
{
|
|
return;
|
|
}
|
|
_remappedTimeSinceStart = MMMaths.Remap(GetTime() - _startedTimestamp, 0f, ToDestinationDuration, 0f, 1f);
|
|
float time = ToDestinationCurve.Evaluate(_remappedTimeSinceStart);
|
|
CurrentValue = Mathf.LerpUnclamped(_initialValue, ToDestinationValue, time);
|
|
CurrentValueNormalized = MMMaths.Remap(CurrentValue, _initialValue, ToDestinationValue, 0f, 1f);
|
|
break;
|
|
}
|
|
|
|
if (PropertyType == PropertyTypes.Color)
|
|
{
|
|
_currentColor = Color.Lerp(FromColor, ToColor, CurrentValue);
|
|
}
|
|
|
|
if (AddToInitialValue)
|
|
{
|
|
CurrentValue += InitialValue;
|
|
}
|
|
|
|
if ((ControlMode == ControlModes.OneTime) && _shaking && (GetTime() - _startedTimestamp > OneTimeDuration))
|
|
{
|
|
_shaking = false;
|
|
if (RevertToInitialValueAfterEnd)
|
|
{
|
|
CurrentValue = InitialValue;
|
|
if (PropertyType == PropertyTypes.Color)
|
|
{
|
|
_currentColor = InitialColor;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CurrentValue = OneTimeCurve.Evaluate(1f);
|
|
CurrentValue = MMMaths.Remap(CurrentValue, 0f, 1f, OneTimeRemapMin, OneTimeRemapMax);
|
|
CurrentValue *= OneTimeAmplitude;
|
|
}
|
|
SetValue(CurrentValue);
|
|
if (DisableAfterOneTime)
|
|
{
|
|
this.enabled = false;
|
|
}
|
|
if (DisableGameObjectAfterOneTime)
|
|
{
|
|
this.gameObject.SetActive(false);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ((ControlMode == ControlModes.ToDestination) && _shaking && (GetTime() - _startedTimestamp > ToDestinationDuration))
|
|
{
|
|
_shaking = false;
|
|
FromColor = _fromColorStorage;
|
|
if (RevertToInitialValueAfterEnd)
|
|
{
|
|
CurrentValue = InitialValue;
|
|
if (PropertyType == PropertyTypes.Color)
|
|
{
|
|
_currentColor = InitialColor;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CurrentValue = ToDestinationValue;
|
|
}
|
|
SetValue(CurrentValue);
|
|
if (DisableAfterToDestination)
|
|
{
|
|
this.enabled = false;
|
|
}
|
|
return;
|
|
}
|
|
|
|
SetValue(CurrentValue);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Grabs and stores the initial value
|
|
/// </summary>
|
|
protected virtual float GetInitialValue()
|
|
{
|
|
if (TargetMaterial == null)
|
|
{
|
|
Debug.LogWarning("Material is null", this);
|
|
return 0f;
|
|
}
|
|
|
|
switch (PropertyType)
|
|
{
|
|
case PropertyTypes.Bool:
|
|
return TargetMaterial.GetInt(PropertyID);
|
|
|
|
case PropertyTypes.Int:
|
|
return TargetMaterial.GetInt(PropertyID);
|
|
|
|
case PropertyTypes.Float:
|
|
return TargetMaterial.GetFloat(PropertyID);
|
|
|
|
case PropertyTypes.Vector:
|
|
return TargetMaterial.GetVector(PropertyID).x;
|
|
|
|
case PropertyTypes.Keyword:
|
|
return TargetMaterial.IsKeywordEnabled(TargetPropertyName) ? 1f : 0f;
|
|
|
|
case PropertyTypes.Color:
|
|
if (ControlMode != ControlModes.ToDestination)
|
|
{
|
|
InitialColor = TargetMaterial.GetColor(PropertyID);
|
|
}
|
|
return 0f;
|
|
|
|
default:
|
|
return 0f;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the value in the shader
|
|
/// </summary>
|
|
/// <param name="newValue"></param>
|
|
protected virtual void SetValue(float newValue)
|
|
{
|
|
if (TargetType == TargetTypes.Image && UseMaterialForRendering)
|
|
{
|
|
if (SafeMode)
|
|
{
|
|
if (TargetImage == null)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
TargetMaterial = TargetImage.materialForRendering;
|
|
}
|
|
|
|
switch (PropertyType)
|
|
{
|
|
case PropertyTypes.Bool:
|
|
newValue = (newValue > 0f) ? 1f : 0f;
|
|
int newBool = Mathf.RoundToInt(newValue);
|
|
if (UseMaterialPropertyBlocks)
|
|
{
|
|
TargetRenderer.GetPropertyBlock(_propertyBlock);
|
|
_propertyBlock.SetInt(PropertyID, newBool);
|
|
TargetRenderer.SetPropertyBlock(_propertyBlock, TargetMaterialID);
|
|
}
|
|
else
|
|
{
|
|
TargetMaterial.SetInt(PropertyID, newBool);
|
|
}
|
|
break;
|
|
|
|
case PropertyTypes.Keyword:
|
|
newValue = (newValue > 0f) ? 1f : 0f;
|
|
if (newValue == 0f)
|
|
{
|
|
TargetMaterial.DisableKeyword(TargetPropertyName);
|
|
}
|
|
else
|
|
{
|
|
TargetMaterial.EnableKeyword(TargetPropertyName);
|
|
}
|
|
break;
|
|
|
|
case PropertyTypes.Int:
|
|
int newInt = Mathf.RoundToInt(newValue);
|
|
if (UseMaterialPropertyBlocks)
|
|
{
|
|
TargetRenderer.GetPropertyBlock(_propertyBlock);
|
|
_propertyBlock.SetInt(PropertyID, newInt);
|
|
TargetRenderer.SetPropertyBlock(_propertyBlock, TargetMaterialID);
|
|
}
|
|
else
|
|
{
|
|
TargetMaterial.SetInt(PropertyID, newInt);
|
|
}
|
|
break;
|
|
|
|
case PropertyTypes.Float:
|
|
if (UseMaterialPropertyBlocks)
|
|
{
|
|
TargetRenderer.GetPropertyBlock(_propertyBlock);
|
|
_propertyBlock.SetFloat(PropertyID, newValue);
|
|
TargetRenderer.SetPropertyBlock(_propertyBlock, TargetMaterialID);
|
|
}
|
|
else
|
|
{
|
|
TargetMaterial.SetFloat(PropertyID, newValue);
|
|
}
|
|
break;
|
|
|
|
case PropertyTypes.Vector:
|
|
_vectorValue = TargetMaterial.GetVector(PropertyID);
|
|
if (X)
|
|
{
|
|
_vectorValue.x = newValue;
|
|
}
|
|
if (Y)
|
|
{
|
|
_vectorValue.y = newValue;
|
|
}
|
|
if (Z)
|
|
{
|
|
_vectorValue.z = newValue;
|
|
}
|
|
if (W)
|
|
{
|
|
_vectorValue.w = newValue;
|
|
}
|
|
if (UseMaterialPropertyBlocks)
|
|
{
|
|
TargetRenderer.GetPropertyBlock(_propertyBlock);
|
|
_propertyBlock.SetVector(PropertyID, _vectorValue);
|
|
TargetRenderer.SetPropertyBlock(_propertyBlock, TargetMaterialID);
|
|
}
|
|
else
|
|
{
|
|
TargetMaterial.SetVector(PropertyID, _vectorValue);
|
|
}
|
|
break;
|
|
|
|
case PropertyTypes.Color:
|
|
if (UseMaterialPropertyBlocks)
|
|
{
|
|
TargetRenderer.GetPropertyBlock(_propertyBlock);
|
|
_propertyBlock.SetColor(PropertyID, _currentColor);
|
|
TargetRenderer.SetPropertyBlock(_propertyBlock, TargetMaterialID);
|
|
}
|
|
else
|
|
{
|
|
TargetMaterial.SetColor(PropertyID, _currentColor);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Interrupts any tween in progress, and disables itself
|
|
/// </summary>
|
|
public virtual void Stop()
|
|
{
|
|
_shaking = false;
|
|
this.enabled = false;
|
|
}
|
|
}
|
|
}
|
|
|