protected virtual void StartFading(float initialAlpha, float endAlpha, float duration, MMTweenType curve, int id, bool ignoreTimeScale, Vector3 worldPosition) { if (id != ID) { return; } if (TargetCamera == null) { Debug.LogWarning(this.name + " : You're using a fader round but its TargetCamera hasn't been setup in its inspector. It can't fade."); return; } FaderMask.anchoredPosition = Vector3.zero; Vector3 viewportPosition = TargetCamera.WorldToViewportPoint(worldPosition); viewportPosition.x = Mathf.Clamp01(viewportPosition.x); viewportPosition.y = Mathf.Clamp01(viewportPosition.y); viewportPosition.z = Mathf.Clamp01(viewportPosition.z); FaderMask.anchorMin = viewportPosition; FaderMask.anchorMax = viewportPosition; IgnoreTimescale = ignoreTimeScale; EnableFader(); _fading = true; _initialScale = initialAlpha; _currentTargetScale = endAlpha; _fadeStartedAt = IgnoreTimescale ? Time.unscaledTime : Time.time; _currentCurve = curve; _currentDuration = duration; }
public MMSoundManagerSoundFadeEvent(int soundID, float fadeDuration, float finalVolume, MMTweenType fadeTween) { SoundID = soundID; FadeDuration = fadeDuration; FinalVolume = finalVolume; FadeTween = fadeTween; }
public MMSoundManagerTrackFadeEvent(MMSoundManager.MMSoundManagerTracks track, float fadeDuration, float finalVolume, MMTweenType fadeTween) { Track = track; FadeDuration = fadeDuration; FinalVolume = finalVolume; FadeTween = fadeTween; }
/// <summary> /// if we get a PostProcessingTriggerEvent /// </summary> /// <param name="curve"></param> /// <param name="active"></param> /// <param name="duration"></param> /// <param name="channel"></param> public virtual void OnMMPostProcessingMovingFilterEvent(MMTweenType curve, bool active, bool toggle, float duration, int channel = 0, bool stop = false) { if ((channel != Channel) && (channel != -1) && (Channel != -1)) { return; } if (stop) { _lastReachedState = Active; return; } Curve = curve; _duration = duration; if (toggle) { Active = !Active; } else { Active = active; } float currentTime = (TimeScale == TimeScales.Unscaled) ? Time.unscaledTime : Time.time; _lastMovementStartedAt = currentTime; }
/// <summary> /// Renders the specified grid on the specified tilemap, with optional slow mode (only works at runtime) /// </summary> /// <param name="grid"></param> /// <param name="tilemap"></param> /// <param name="tile"></param> /// <param name="slowRender"></param> /// <param name="slowRenderDuration"></param> /// <param name="slowRenderTweenType"></param> /// <param name="slowRenderSupport"></param> public static void RenderGrid(int[,] grid, MMTilemapGeneratorLayer layer, bool slowRender = false, float slowRenderDuration = 1f, MMTweenType slowRenderTweenType = null, MonoBehaviour slowRenderSupport = null) { if (layer.FusionMode == MMTilemapGeneratorLayer.FusionModes.Normal) { ClearTilemap(layer.TargetTilemap); } TileBase tile = layer.Tile; if (layer.FusionMode == MMTilemapGeneratorLayer.FusionModes.Combine) { grid = MMGridGenerator.InvertGrid(grid); tile = null; } if (layer.FusionMode == MMTilemapGeneratorLayer.FusionModes.Subtract) { grid = MMGridGenerator.InvertGrid(grid); } if (!slowRender || !Application.isPlaying) { DrawGrid(grid, layer.TargetTilemap, tile, 0, TotalFilledBlocks(grid)); } else { slowRenderSupport.StartCoroutine(SlowRenderGrid(grid, layer.TargetTilemap, tile, slowRenderDuration, slowRenderTweenType, 60)); } if (!Application.isPlaying && slowRender) { Debug.LogWarning("Rendering maps in SlowRender mode is only supported at runtime."); } }
/// <summary> /// Starts fading this fader from the specified initial alpha to the target /// </summary> /// <param name="initialAlpha"></param> /// <param name="endAlpha"></param> /// <param name="duration"></param> /// <param name="curve"></param> /// <param name="id"></param> /// <param name="ignoreTimeScale"></param> protected virtual void StartFading(float initialAlpha, float endAlpha, float duration, MMTweenType curve, int id, bool ignoreTimeScale) { if (id != ID) { return; } if ((!CanFadeToCurrentAlpha) && (_canvasGroup.alpha == endAlpha)) { return; } IgnoreTimescale = ignoreTimeScale; EnableFader(); _fading = true; _initialAlpha = initialAlpha; _currentTargetAlpha = endAlpha; _fadeStartedAt = IgnoreTimescale ? Time.unscaledTime : Time.time; _currentCurve = curve; _currentDuration = duration; if (Time.frameCount == 1) { _frameCountOne = true; } }
/// <summary> /// Initializes a new instance of the <see cref="MoreMountains.MMInterface.MMFadeInEvent"/> struct. /// </summary> /// <param name="duration">Duration.</param> public MMFadeInEvent(float duration, MMTweenType tween, int id = 0, bool ignoreTimeScale = true, Vector3 worldPosition = new Vector3()) { ID = id; Duration = duration; Curve = tween; IgnoreTimeScale = ignoreTimeScale; WorldPosition = worldPosition; }
/// <summary> /// On Start(), we start loading the new level asynchronously /// </summary> protected virtual void Start() { _tween = new MMTweenType(MMTween.MMTweenCurve.EaseOutCubic); _loadingTextValue = LoadingText.text; if (!string.IsNullOrEmpty(_sceneToLoad)) { StartCoroutine(LoadAsynchronously()); } }
public static void Trigger(float duration, MMTweenType tween, int id = 0, bool ignoreTimeScale = true, Vector3 worldPosition = new Vector3()) { e.ID = id; e.Duration = duration; e.Curve = tween; e.IgnoreTimeScale = ignoreTimeScale; e.WorldPosition = worldPosition; MMEventManager.TriggerEvent(e); }
protected virtual void StartFading(float initialAlpha, float endAlpha, float duration, MMTweenType curve, int id, bool ignoreTimeScale) { if (id != ID) { return; } IgnoreTimescale = ignoreTimeScale; EnableFader(); _fading = true; _initialAlpha = initialAlpha; _currentTargetAlpha = endAlpha; _fadeStartedAt = IgnoreTimescale ? Time.unscaledTime : Time.time; _currentCurve = curve; _currentDuration = duration; }
/// <summary> /// Fades an entire track over time /// </summary> /// <param name="track"></param> /// <param name="duration"></param> /// <param name="initialVolume"></param> /// <param name="finalVolume"></param> /// <param name="tweenType"></param> /// <returns></returns> protected virtual IEnumerator FadeTrackCoroutine(MMSoundManagerTracks track, float duration, float initialVolume, float finalVolume, MMTweenType tweenType) { float startedAt = Time.unscaledTime; if (tweenType == null) { tweenType = new MMTweenType(MMTween.MMTweenCurve.EaseInOutQuartic); } while (Time.unscaledTime - startedAt <= duration) { float elapsedTime = Time.unscaledTime - startedAt; float newVolume = MMTween.Tween(elapsedTime, 0f, duration, initialVolume, finalVolume, tweenType); settingsSo.SetTrackVolume(track, newVolume); yield return(null); } settingsSo.SetTrackVolume(track, finalVolume); }
/// <summary> /// Fades an audiosource's volume over time /// </summary> /// <param name="source"></param> /// <param name="duration"></param> /// <param name="initialVolume"></param> /// <param name="finalVolume"></param> /// <param name="tweenType"></param> /// <returns></returns> protected virtual IEnumerator FadeCoroutine(AudioSource source, float duration, float initialVolume, float finalVolume, MMTweenType tweenType) { float startedAt = Time.unscaledTime; if (tweenType == null) { tweenType = new MMTweenType(MMTween.MMTweenCurve.EaseInOutQuartic); } while (Time.unscaledTime - startedAt <= duration) { float elapsedTime = Time.unscaledTime - startedAt; float newVolume = MMTween.Tween(elapsedTime, 0f, duration, initialVolume, finalVolume, tweenType); source.volume = newVolume; yield return(null); } source.volume = finalVolume; }
/// <summary> /// Starts a fade /// </summary> /// <param name="fadingIn"></param> /// <param name="duration"></param> /// <param name="curve"></param> /// <param name="id"></param> /// <param name="ignoreTimeScale"></param> /// <param name="worldPosition"></param> protected virtual IEnumerator StartFading(bool fadingIn, float duration, MMTweenType curve, int id, bool ignoreTimeScale, Vector3 worldPosition) { if (id != ID) { yield break; } if (InitialDelay > 0f) { yield return(MMCoroutine.WaitFor(InitialDelay)); } if (!_initialized) { Initialization(); } if (curve == null) { curve = DefaultTween; } IgnoreTimescale = ignoreTimeScale; EnableFader(); _fading = true; _fadeStartedAt = IgnoreTimescale ? Time.unscaledTime : Time.time; _currentCurve = curve; _currentDuration = duration; _fromPosition = _rectTransform.anchoredPosition; _toPosition = fadingIn ? _initialPosition : ExitPosition(); _newPosition = MMTween.Tween(0f, 0f, duration, _fromPosition, _toPosition, _currentCurve); _rectTransform.anchoredPosition = _newPosition; }
/// <summary> /// Fades a target sound towards a final volume over time /// </summary> /// <param name="source"></param> /// <param name="duration"></param> /// <param name="initialVolume"></param> /// <param name="finalVolume"></param> /// <param name="tweenType"></param> public virtual void FadeSound(AudioSource source, float duration, float initialVolume, float finalVolume, MMTweenType tweenType) { StartCoroutine(FadeCoroutine(source, duration, initialVolume, finalVolume, tweenType)); }
/// <summary> /// Fades an entire track over the specified duration towards the desired finalVolume /// </summary> /// <param name="track"></param> /// <param name="duration"></param> /// <param name="initialVolume"></param> /// <param name="finalVolume"></param> /// <param name="tweenType"></param> public virtual void FadeTrack(MMSoundManagerTracks track, float duration, float initialVolume = 0f, float finalVolume = 1f, MMTweenType tweenType = null) { StartCoroutine(FadeTrackCoroutine(track, duration, initialVolume, finalVolume, tweenType)); }
/// <summary> /// Plays a sound, signature with all options /// </summary> /// <param name="audioClip"></param> /// <param name="mmSoundManagerTrack"></param> /// <param name="location"></param> /// <param name="loop"></param> /// <param name="volume"></param> /// <param name="ID"></param> /// <param name="fade"></param> /// <param name="fadeInitialVolume"></param> /// <param name="fadeDuration"></param> /// <param name="fadeTween"></param> /// <param name="persistent"></param> /// <param name="recycleAudioSource"></param> /// <param name="audioGroup"></param> /// <param name="pitch"></param> /// <param name="panStereo"></param> /// <param name="spatialBlend"></param> /// <param name="soloSingleTrack"></param> /// <param name="soloAllTracks"></param> /// <param name="autoUnSoloOnEnd"></param> /// <param name="bypassEffects"></param> /// <param name="bypassListenerEffects"></param> /// <param name="bypassReverbZones"></param> /// <param name="priority"></param> /// <param name="reverbZoneMix"></param> /// <param name="dopplerLevel"></param> /// <param name="spread"></param> /// <param name="rolloffMode"></param> /// <param name="minDistance"></param> /// <param name="maxDistance"></param> /// <returns></returns> public virtual AudioSource PlaySound(AudioClip audioClip, MMSoundManagerTracks mmSoundManagerTrack, Vector3 location, bool loop = false, float volume = 1.0f, int ID = 0, bool fade = false, float fadeInitialVolume = 0f, float fadeDuration = 1f, MMTweenType fadeTween = null, bool persistent = false, AudioSource recycleAudioSource = null, AudioMixerGroup audioGroup = null, float pitch = 1f, float panStereo = 0f, float spatialBlend = 0.0f, bool soloSingleTrack = false, bool soloAllTracks = false, bool autoUnSoloOnEnd = false, bool bypassEffects = false, bool bypassListenerEffects = false, bool bypassReverbZones = false, int priority = 128, float reverbZoneMix = 1f, float dopplerLevel = 1f, int spread = 0, AudioRolloffMode rolloffMode = AudioRolloffMode.Logarithmic, float minDistance = 1f, float maxDistance = 500f ) { if (!audioClip) { return(null); } // audio source setup --------------------------------------------------------------------------------- // we reuse an audiosource if one is passed in parameters AudioSource audioSource = recycleAudioSource; if (audioSource == null) { // we pick an idle audio source from the pool if possible audioSource = _pool.GetAvailableAudioSource(PoolCanExpand, this.transform); if ((audioSource != null) && (!loop)) { recycleAudioSource = audioSource; // we destroy the host after the clip has played (if it not tag for reusability. StartCoroutine(_pool.AutoDisableAudioSource(audioClip.length, audioSource.gameObject)); } } // we create an audio source if needed if (audioSource == null) { _tempAudioSourceGameObject = new GameObject("MMAudio_" + audioClip.name); audioSource = _tempAudioSourceGameObject.AddComponent <AudioSource>(); } // audio source settings --------------------------------------------------------------------------------- audioSource.transform.position = location; audioSource.time = 0.0f; audioSource.clip = audioClip; audioSource.pitch = pitch; audioSource.spatialBlend = spatialBlend; audioSource.panStereo = panStereo; audioSource.loop = loop; audioSource.bypassEffects = bypassEffects; audioSource.bypassListenerEffects = bypassListenerEffects; audioSource.bypassReverbZones = bypassReverbZones; audioSource.priority = priority; audioSource.reverbZoneMix = reverbZoneMix; audioSource.dopplerLevel = dopplerLevel; audioSource.spread = spread; audioSource.rolloffMode = rolloffMode; audioSource.minDistance = minDistance; audioSource.maxDistance = maxDistance; // track and volume --------------------------------------------------------------------------------- if (settingsSo != null) { audioSource.outputAudioMixerGroup = settingsSo.MasterAudioMixerGroup; switch (mmSoundManagerTrack) { case MMSoundManagerTracks.Master: audioSource.outputAudioMixerGroup = settingsSo.MasterAudioMixerGroup; break; case MMSoundManagerTracks.Music: audioSource.outputAudioMixerGroup = settingsSo.MusicAudioMixerGroup; break; case MMSoundManagerTracks.Sfx: audioSource.outputAudioMixerGroup = settingsSo.SfxAudioMixerGroup; break; case MMSoundManagerTracks.UI: audioSource.outputAudioMixerGroup = settingsSo.UIAudioMixerGroup; break; } } if (audioGroup) { audioSource.outputAudioMixerGroup = audioGroup; } audioSource.volume = volume; // we start playing the sound audioSource.Play(); // we destroy the host after the clip has played if it was a one time AS. if (!loop && !recycleAudioSource) { Destroy(_tempAudioSourceGameObject, audioClip.length); } // we fade the sound in if needed if (fade) { FadeSound(audioSource, fadeDuration, fadeInitialVolume, volume, fadeTween); } // we handle soloing if (soloSingleTrack) { MuteSoundsOnTrack(mmSoundManagerTrack, true, 0f); audioSource.mute = false; if (autoUnSoloOnEnd) { MuteSoundsOnTrack(mmSoundManagerTrack, false, audioClip.length); } } else if (soloAllTracks) { MuteAllSounds(); audioSource.mute = false; if (autoUnSoloOnEnd) { StartCoroutine(MuteAllSoundsCoroutine(audioClip.length, false)); } } // we prepare for storage _sound.ID = ID; _sound.Track = mmSoundManagerTrack; _sound.Source = audioSource; _sound.Persistent = persistent; // we check if that audiosource is already being tracked in _sounds bool alreadyIn = false; for (int i = 0; i < _sounds.Count; i++) { if (_sounds[i].Source == audioSource) { _sounds[i] = _sound; alreadyIn = true; } } if (!alreadyIn) { _sounds.Add(_sound); } // we return the audiosource reference return(audioSource); }
public static void Trigger(MMSoundManager.MMSoundManagerTracks track, float fadeDuration, float finalVolume, MMTweenType fadeTween) { e.Track = track; e.FadeDuration = fadeDuration; e.FinalVolume = finalVolume; e.FadeTween = fadeTween; MMEventManager.TriggerEvent(e); }
/// <summary> /// Call this static method to load a scene from anywhere /// </summary> /// <param name="sceneToLoadName">Level name.</param> public static void LoadScene(string sceneToLoadName, string loadingSceneName = "MMAdditiveLoadingScreen", ThreadPriority threadPriority = ThreadPriority.High, bool secureLoad = true, bool interpolateProgress = true, float beforeEntryFadeDelay = 0f, float entryFadeDuration = 0.25f, float afterEntryFadeDelay = 0.1f, float beforeExitFadeDelay = 0.25f, float exitFadeDuration = 0.2f, MMTweenType entryFadeTween = null, MMTweenType exitFadeTween = null, float progressBarSpeed = 5f, FadeModes fadeMode = FadeModes.FadeInThenOut, MMAdditiveSceneLoadingManagerSettings.UnloadMethods unloadMethod = MMAdditiveSceneLoadingManagerSettings.UnloadMethods.AllScenes) { if (_loadingInProgress) { Debug.LogError("MMLoadingSceneManagerAdditive : a request to load a new scene was emitted while a scene load was already in progress"); return; } if (entryFadeTween == null) { entryFadeTween = new MMTweenType(MMTween.MMTweenCurve.EaseInOutCubic); } if (exitFadeTween == null) { exitFadeTween = new MMTweenType(MMTween.MMTweenCurve.EaseInOutCubic); } if (secureLoad) { _scenesInBuild = MMScene.GetScenesInBuild(); if (!_scenesInBuild.Contains(sceneToLoadName)) { Debug.LogError("MMLoadingSceneManagerAdditive : impossible to load the '" + sceneToLoadName + "' scene, " + "there is no such scene in the project's build settings."); return; } if (!_scenesInBuild.Contains(loadingSceneName)) { Debug.LogError("MMLoadingSceneManagerAdditive : impossible to load the '" + loadingSceneName + "' scene, " + "there is no such scene in the project's build settings."); return; } } _loadingInProgress = true; _initialScenes = GetScenesToUnload(unloadMethod); Application.backgroundLoadingPriority = threadPriority; _sceneToLoadName = sceneToLoadName; _loadingScreenSceneName = loadingSceneName; _beforeEntryFadeDelay = beforeEntryFadeDelay; _entryFadeDuration = entryFadeDuration; _entryFadeTween = entryFadeTween; _afterEntryFadeDelay = afterEntryFadeDelay; _progressInterpolationSpeed = progressBarSpeed; _beforeExitFadeDelay = beforeExitFadeDelay; _exitFadeDuration = exitFadeDuration; _exitFadeTween = exitFadeTween; _fadeMode = fadeMode; _interpolateProgress = interpolateProgress; SceneManager.LoadScene(_loadingScreenSceneName, LoadSceneMode.Additive); }
static public void Trigger(MMTweenType curve, bool active, bool toggle, float duration, int channel = 0) { OnEvent?.Invoke(curve, active, toggle, duration, channel); }
public static Quaternion Tween(float currentTime, float initialTime, float endTime, Quaternion startValue, Quaternion endValue, MMTweenType tweenType) { if (tweenType.MMTweenDefinitionType == MMTweenDefinitionTypes.MMTween) { return(Tween(currentTime, initialTime, endTime, startValue, endValue, tweenType.MMTweenCurve)); } if (tweenType.MMTweenDefinitionType == MMTweenDefinitionTypes.AnimationCurve) { return(Tween(currentTime, initialTime, endTime, startValue, endValue, tweenType.Curve)); } return(Quaternion.identity); }
public static Vector3 Tween(float currentTime, float initialTime, float endTime, Vector3 startValue, Vector3 endValue, MMTweenType tweenType) { if (tweenType.MMTweenDefinitionType == MMTweenDefinitionTypes.MMTween) { return(Tween(currentTime, initialTime, endTime, startValue, endValue, tweenType.MMTweenCurve)); } if (tweenType.MMTweenDefinitionType == MMTweenDefinitionTypes.AnimationCurve) { return(Tween(currentTime, initialTime, endTime, startValue, endValue, tweenType.Curve)); } return(Vector3.zero); }
/// <summary> /// Renders a grid chunk by chunk - runtime only /// </summary> /// <param name="grid"></param> /// <param name="tilemap"></param> /// <param name="tile"></param> /// <param name="slowRenderDuration"></param> /// <param name="slowRenderTweenType"></param> /// <param name="frameRate"></param> /// <returns></returns> public static IEnumerator SlowRenderGrid(int[,] grid, Tilemap tilemap, TileBase tile, float slowRenderDuration, MMTweenType slowRenderTweenType, int frameRate) { int totalBlocks = TotalFilledBlocks(grid); totalBlocks = (totalBlocks == 0) ? 1 : totalBlocks; frameRate = (frameRate == 0) ? 1 : frameRate; float refreshFrequency = 1f / frameRate; float startedAt = Time.unscaledTime; float lastWaitAt = startedAt; int drawnBlocks = 0; int lastIndex = 0; while (Time.unscaledTime - startedAt < slowRenderDuration) { while (Time.unscaledTime - lastWaitAt < refreshFrequency) { yield return(null); } int remainingBlocks = totalBlocks - drawnBlocks; float elapsedTime = Time.unscaledTime - startedAt; float remainingTime = slowRenderDuration - elapsedTime; float normalizedProgress = MMMaths.Remap(elapsedTime, 0f, slowRenderDuration, 0f, 1f); float curveProgress = MMTween.Tween(normalizedProgress, 0f, 1f, 0f, 1f, slowRenderTweenType); float ratio = 1 - (normalizedProgress - curveProgress); int blocksToDraw = Mathf.RoundToInt((remainingBlocks / remainingTime) * refreshFrequency * ratio); lastIndex = DrawGrid(grid, tilemap, tile, lastIndex, blocksToDraw); drawnBlocks += blocksToDraw; lastWaitAt = Time.unscaledTime; } DrawGrid(grid, tilemap, tile, lastIndex, totalBlocks - lastIndex); }
public static void Trigger(int soundID, float fadeDuration, float finalVolume, MMTweenType fadeTween) { e.SoundID = soundID; e.FadeDuration = fadeDuration; e.FinalVolume = finalVolume; e.FadeTween = fadeTween; MMEventManager.TriggerEvent(e); }
static public AudioSource Trigger(AudioClip audioClip, MMSoundManager.MMSoundManagerTracks mmSoundManagerTrack, Vector3 location, bool loop = false, float volume = 1.0f, int ID = 0, bool fade = false, float fadeInitialVolume = 0f, float fadeDuration = 1f, MMTweenType fadeTween = null, bool persistent = false, AudioSource recycleAudioSource = null, AudioMixerGroup audioGroup = null, float pitch = 1f, float panStereo = 0f, float spatialBlend = 0.0f, bool soloSingleTrack = false, bool soloAllTracks = false, bool autoUnSoloOnEnd = false, bool bypassEffects = false, bool bypassListenerEffects = false, bool bypassReverbZones = false, int priority = 128, float reverbZoneMix = 1f, float dopplerLevel = 1f, int spread = 0, AudioRolloffMode rolloffMode = AudioRolloffMode.Logarithmic, float minDistance = 1f, float maxDistance = 500f) { MMSoundManagerPlayOptions options = MMSoundManagerPlayOptions.Default; options.MmSoundManagerTrack = mmSoundManagerTrack; options.Location = location; options.Loop = loop; options.Volume = volume; options.ID = ID; options.Fade = fade; options.FadeInitialVolume = fadeInitialVolume; options.FadeDuration = fadeDuration; options.FadeTween = fadeTween; options.Persistent = persistent; options.RecycleAudioSource = recycleAudioSource; options.AudioGroup = audioGroup; options.Pitch = pitch; options.PanStereo = panStereo; options.SpatialBlend = spatialBlend; options.SoloSingleTrack = soloSingleTrack; options.SoloAllTracks = soloAllTracks; options.AutoUnSoloOnEnd = autoUnSoloOnEnd; options.BypassEffects = bypassEffects; options.BypassListenerEffects = bypassListenerEffects; options.BypassReverbZones = bypassReverbZones; options.Priority = priority; options.ReverbZoneMix = reverbZoneMix; options.DopplerLevel = dopplerLevel; options.Spread = spread; options.RolloffMode = rolloffMode; options.MinDistance = minDistance; options.MaxDistance = maxDistance; return(OnEvent?.Invoke(audioClip, options)); }
// Tween type methods ------------------------------------------------------------------------------------------------------------------------ public static float Tween(float currentTime, float initialTime, float endTime, float startValue, float endValue, MMTweenType tweenType) { if (tweenType.MMTweenDefinitionType == MMTweenDefinitionTypes.MMTween) { return(Tween(currentTime, initialTime, endTime, startValue, endValue, tweenType.MMTweenCurve)); } if (tweenType.MMTweenDefinitionType == MMTweenDefinitionTypes.AnimationCurve) { return(Tween(currentTime, initialTime, endTime, startValue, endValue, tweenType.Curve)); } return(0f); }