LINQUtils

LINQUtils.cs

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System;

public static class LINQUtils {
	public static IEnumerable<T> Zip<A, B, T>(
		IEnumerable<A> seqA, IEnumerable<B> seqB, Func<A, B, T> func)
	{
		using (var iteratorA = seqA.GetEnumerator())
			using (var iteratorB = seqB.GetEnumerator())
		{
			while (iteratorA.MoveNext() && iteratorB.MoveNext())
			{
				yield return func(iteratorA.Current, iteratorB.Current);
			}
		}
	}

	public static IEnumerator Fade<T>(ref T from, T to, float duration, Func<T,T,float,T> lerp){
		return (new FadeContainer<T>(ref from, to, duration, lerp)).Get();
	}

	public static IEnumerator Fade(ref Vector2 from, Vector2 to, float duration){
		return Fade<Vector2>(ref from, to, duration, Vector2.Lerp);
	}

	public static IEnumerator Fade(ref Vector3 from, Vector3 to, float duration){
		return Fade<Vector3>(ref from, to, duration, Vector3.Lerp);
	}

	public static IEnumerator Fade(ref Vector4 from, Vector4 to, float duration){
		return Fade<Vector4>(ref from, to, duration, Vector4.Lerp);
	}

	public static IEnumerator Fade(ref Color from, Color to, float duration){
		return Fade<Color>(ref from, to, duration, Color.Lerp);
	}

	public static IEnumerator Fade(ref Quaternion from, Quaternion to, float duration){
		return Fade<Quaternion>(ref from, to, duration, Quaternion.Slerp);
	}

	public static IEnumerator Fade(ref float from, float to, float duration){
		return Fade<float>(ref from, to, duration, Mathf.Lerp);
	}


	private class FadeContainer<T>{
		T source;
		Func<T,T,float,T> lerp;
		IEnumerator coroutine;
		
		public FadeContainer(ref T source, T target, float duration, Func<T,T,float,T> lerp){
			this.source = source;
			this.lerp = lerp;
			this.coroutine = DoFade(target, duration);
		}
		
		public IEnumerator Get(){
			return coroutine;
		}
		
		private IEnumerator DoFade(T to, float duration){
			T fromCopy = source;
			float time = duration;
			yield return null;
			while (time > 0){
				time -= Time.deltaTime / Time.timeScale;
				source = lerp(fromCopy, to, 1 - duration/time);
				yield return new WaitForEndOfFrame();
			}
		}
	}
}