COS_UV 动画

 

不会传动图~自行脑补动态效果，嘻嘻

Shader 代码：用于UV动画，有三个pass，

1. 中心点为中心的放大和旋转，包含三层，可调整透明度和时间差。
2. 左下角为中心的旋转和放大，包含三层，同上。
3. UV顶点动画，包含两部分，基于X轴和Y轴的顶点变换。

C# 脚本：传入时间参数，便于暂停后还可以从暂停位置继续。

Shader "ABigDeal/UVAnimation"
	{
		Properties
		{
/Amplify 放大
			//通用
			_T("T",float)=0
			_Amplify_MainTex("Amplify MainTex", 2D) = "white" {}		//贴图
			_Amplify_Size("Amplify Size",float)=2						//大小
			_Amplify_Transparent("Amplify Transparent",Range(0,1)) = 1  //透明度
			_Amplify_Speed("Amplify Speed",float) = 1.0                 //放大速度
			_Amplify_Rotate("Amplify+Rotate",float)=1.0                 //放大中的旋转速度
			_Amplify_AtoBSpeed("Amplify AtoB Speed",Float) = 0.5       //切换颜色速度
			_Amplify_AColor("Amplify A Color",Color) = (1,1,1,1)           //颜色
			_Amplify_BColor("Amplify B Color",Color) = (1,1,1,1)           //颜色
			
			//重影A
			_Amplify_ATransform("Amplify A Transform ",Range(-1,1)) = 0  //延迟
			_Amplify_ATransparent("Amplify A Transparent",Range(0,1)) = 1//透明度
			//重影B
			_Amplify_BTransform("Amplify B Transform ",Range(-1,1)) = 0.2 //延迟
			_Amplify_BTransparent("Amplify B Transparent",Range(0,1)) = 0.8//透明度

			//重影C
			_Amplify_CTransform("Amplify C Transform ",Range(-1,1)) = 0.4 //延迟
			_Amplify_CTransparent("Amplify C Transparent",Range(0,1)) = 0.6//透明度



//Rotate 旋转
			//通用
			_Rotate_MainTex("Rotate MainTex", 2D) = "white" {}        //贴图
			_Rotate_Size("Rotate Size",float)=2.0					  //大小
			_Rotate_Transparent("Rotate Transparent",Range(0,1)) = 1  // 透明度
			_Rotate_Speed("Rotate Speed",float) = 1.0				  //旋转速度
			_Rotate_Amplify("Rotate+Amplify",float)=1.0               //旋转中放大的程度
			_Rotate_AtoBSpeed("Rotate AtoB Speed",Float) = 0.5       //切换颜色速度
			_Rotate_AColor("Rotate A Color",Color) = (1,1,1,1)           //颜色A
			_Rotate_BColor("Rotate B Color",Color) = (1,1,1,1)           //颜色B
			//重影A
			_Rotate_ATransform("Rotate A Transform ",Range(-1,1)) = 0  //延迟
			_Rotate_ATransparent("Rotate A Transparent",Range(0,1)) = 1 //透明度
			//重影B
			_Rotate_BTransform("Rotate B Transform ",Range(-1,1)) = 0  //延迟
			_Rotate_BTransparent("Rotate B Transparent",Range(0,1)) = 1 //透明度
			//重影C
			_Rotate_CTransform("Rotate C Transform ",Range(-1,1)) = 0  //延迟
			_Rotate_CTransparent("Rotate C Transparent",Range(0,1)) = 1 //透明度



/Translation 平移
			//通用
			_Translation_MainTex("Translation Maintex",2D)="white"{}	       //贴图
			_Translation_Transparent("Translation Transparent",Range(0,1))=1   //透明度
			_Translation_AtoBSpeed("Translation AtoB Speed",Float) = 0.5       //切换颜色速度
			_Translation_AColor("Translation A Color",Color) = (1,1,1,1)       //颜色A
			_Translation_BColor("Translation B Color",Color) = (1,1,1,1)       //颜色B

			
			_Translation_YSpeed("Y Speed",Float)=0.5                           //速度
			_Translation_XMagnitude("Translation X Magnitude",Float)=1         //变形
			_Translation_XFrequency("Translation X Frequency",Float)=1         //频率
			_Translation_XInvWaveLength("Translation X InvWaveLength",Float)=10//逆波长
			
			_Translation_XSpeed("X Speed",Float)=0.5                           //速度
			_Translation_YMagnitude("Translation Y Magnitude",Float)=1         //变形
			_Translation_YFrequency("Translation Y Frequency",Float)=1         //频率
			_Translation_YInvWaveLength("Translation Y InvWaveLength",Float)=10//逆波长

		}
			SubShader
		{
			Tags{ "RenderType" = "Transparent"  "Queue" = "Geometry" }
			
//			
///      Amplify 放大     
//
			Pass{
			Tags{ "LightMode" = "ForwardBase" }
			ZWrite Off
			Cull Off
			Blend SrcAlpha OneMinusSrcAlpha

			CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
		

				float _T;
			float _A;
		float _Amplify_Transparent;
		sampler2D _Amplify_MainTex;
		float4 _Amplify_MainTex_ST;
		float _Amplify_Speed;
		float _Amplify_CutOff;
		float _Amplify_AtoBSpeed;
		fixed4 _Amplify_AColor;
		fixed4 _Amplify_BColor;
		float _Amplify_Rotate;
		float _Amplify_Size;

		float _Amplify_ATransform;
		float _Amplify_ATransparent;

		float _Amplify_BTransform;
		float _Amplify_BTransparent;

		float _Amplify_CTransform;
		float _Amplify_CTransparent;
	

		struct a2v {
			float4 vertex : POSITION;
			float2 texcoord : TEXCOORD0;
		};
		struct v2f {
			float4 uv : TEXCOORD0;
			float4 pos : SV_POSITION;
		};
		v2f vert(a2v v)
		{
			v2f o;
			o.pos = UnityObjectToClipPos(v.vertex);
			o.uv.xy = TRANSFORM_TEX(v.texcoord, _Amplify_MainTex);
			UNITY_TRANSFER_FOG(o,o.vertex);
			return o;
		}


		fixed4 frag(v2f i) : SV_Target{
			/*float t;
		
			if (_T == 0) { _Time.y = _Time.y;
			t = frac(_Time.y);
			}
			else if (_T == 1) { _Time.y = t; }*/



			 _Time.y=_T;

		//时间速度控制
		float TA=_Time.y *_Amplify_Speed;
		if (TA == 0) { TA = 0.9; }

		float TR = _Time.y*_Amplify_Rotate;

		//偏移中心方便缩放旋转
		float2 uv = (i.uv.xy - float2(0.5, 0.5))*_Amplify_Size;
		
		
		float2 rotateA = float2(cos(TR - _Amplify_ATransform*_Amplify_Rotate), sin(TR - _Amplify_ATransform*_Amplify_Rotate));//旋转角度
		float2 uvA = uv.xy*frac(TA+ _Amplify_ATransform);	//放大
		//float2 uvA = uv.xy*sin(TA+ _Amplify_ATransform);	//放大

		uvA = float2(uvA.x*rotateA.x - uvA.y*rotateA.y, uvA.x*rotateA.y + uvA.y*rotateA.x);//旋转
		uvA += float2 (0.5, 0.5);//偏移回中心

		float2 rotateB = float2(cos(TR - _Amplify_BTransform*_Amplify_Rotate), sin(TR - _Amplify_BTransform*_Amplify_Rotate));//旋转角度
		float2 uvB = uv.xy*frac(TA + _Amplify_BTransform);	//放大
		uvB = float2(uvB.x*rotateB.x - uvB.y*rotateB.y, uvB.x*rotateB.y + uvB.y*rotateB.x);//旋转
		uvB += float2 (0.5, 0.5);//偏移回中心

		float2 rotateC = float2(cos(TR - _Amplify_CTransform*_Amplify_Rotate), sin(TR - _Amplify_CTransform*_Amplify_Rotate));//旋转角度
		float2 uvC = uv.xy*frac(TA + _Amplify_CTransform);	//放大
		uvC = float2(uvC.x*rotateC.x - uvC.y*rotateC.y, uvC.x*rotateC.y + uvC.y*rotateC.x);//旋转
		uvC += float2 (0.5, 0.5);//偏移回中心

		/*float CenterC = abs(frac(_Time.y - _Amplify_CTransform)*0.5);//中心位置偏移
		float BigC = 1 - abs(frac(_Time.y - _Amplify_CTransform)); // 放大
		float2 uvC = i.uv.xy*BigC + CenterC;*/

		
		fixed4 colA = tex2D(_Amplify_MainTex, uvA);
		colA.a = colA.a * _Amplify_ATransparent;

		fixed4 colB = tex2D(_Amplify_MainTex, uvB);
		colB.a = colB.a * _Amplify_BTransparent;

		fixed4 colC = tex2D(_Amplify_MainTex, uvC);
		colC.a = colC.a * _Amplify_CTransparent;

		fixed4 col = colA + colB + colC;
		float3 Color = lerp(_Amplify_AColor.rgb, _Amplify_BColor.rgb,sin(_Time.y*_Amplify_AtoBSpeed));
		col.rgb =Color;
		col.a *= _Amplify_Transparent;
		return col;
		}
			ENDCG
		}

//			
///     Rotate   旋转     
//
			Pass{
			Tags{ "LightMode" = "ForwardBase" }
			ZWrite Off
			Cull Off
			Blend SrcAlpha OneMinusSrcAlpha

			CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
				float _T;
		float _Rotate_Transparent;
		sampler2D _Rotate_MainTex;
		float4 _Rotate_MainTex_ST;
		float _Rotate_Speed;
		float _Rotate_CutOff;
		float _Rotate_AtoBSpeed;
		fixed4 _Rotate_BColor;
		fixed4 _Rotate_AColor;
		float _Rotate_Size;
		float _Rotate_Amplify;

		float _Rotate_ATransform;
		float _Rotate_ATransparent;

		float _Rotate_BTransform;
		float _Rotate_BTransparent;

		float _Rotate_CTransform;
		float _Rotate_CTransparent;



		struct a2v {
			float4 vertex : POSITION;
			float2 texcoord : TEXCOORD0;
		};
		struct v2f {
			float4 uv : TEXCOORD0;
			float4 pos : SV_POSITION;
		};
		v2f vert(a2v v)
		{
			v2f o;
			o.pos = UnityObjectToClipPos(v.vertex);
			o.uv.xy = TRANSFORM_TEX(v.texcoord, _Rotate_MainTex);
			UNITY_TRANSFER_FOG(o,o.vertex);
			return o;
		}


		fixed4 frag(v2f i) : SV_Target{
			_Time.y = _T;
		
		float2 uv = (i.uv.xy - float2(0.5,0.5))*_Rotate_Size;
		float TA = _Time.y*_Rotate_Amplify;
		if (TA == 0) { TA = 0.9; }

		float TR = _Rotate_Speed*_Time.y;
		float2 rotateA = float2(cos(TR-_Rotate_ATransform), sin(TR-_Rotate_ATransform));
		float TRB = TR-_Rotate_BTransform;
		float2 rotateB = float2(cos(TRB), sin(TRB));
		float TRC = TR - _Rotate_CTransform;
		float2 rotateC = float2(cos(TRC), sin(TRC));
		//float2 rotateC = float2(cos(TR - _Rotate_CTransform), sin(TR - _Rotate_CTransform));

		//uv.xy = uv.xy*max((abs(sin(-(_Time.y- _Rotate_ATransform)*_Rotate_Amplify))*3),0.8);//放大
		float2 uvA = uv.xy*max((abs(sin(-(_Time.y - _Rotate_ATransform)*_Rotate_Amplify)) * 3), 0.8);
		uvA = float2(uvA.x*rotateA.x - uvA.y*rotateA.y, uvA.x*rotateA.y + uvA.y*rotateA.x);
		
		float2 uvB = uv.xy*max((abs(sin(-(_Time.y - _Rotate_BTransform)*_Rotate_Amplify)) * 3), 0.8);
		uvB = float2(uvB.x*rotateB.x - uvB.y*rotateB.y, uvB.x*rotateB.y + uvB.y*rotateB.x);
		
		float2 uvC = uv.xy*max((abs(sin(-(_Time.y - _Rotate_CTransform)*_Rotate_Amplify)) * 3), 0.8);
		uvC = float2(uvC.x*rotateC.x - uvC.y*rotateC.y, uvC.x*rotateC.y + uvC.y*rotateC.x);
		
		
		float4 colA = tex2D(_Rotate_MainTex,uvA);
		colA.a *= _Rotate_ATransparent;
		
		float4 colB = tex2D(_Rotate_MainTex, uvB);
		colB.a *= _Rotate_BTransparent;

		float4 colC = tex2D(_Rotate_MainTex, uvC);
		colC.a *= _Rotate_CTransparent;
		
		float4 col = colA +colB+colC;

		float3 Color = lerp(_Rotate_AColor.rgb, _Rotate_BColor.rgb, sin(_Time.y*_Rotate_AtoBSpeed));
		col.rgb = Color;
		col.a *= _Rotate_Transparent;




		return col;
		}
			ENDCG
		}


//			
///   Translation 平移    
//
		Pass{
		Tags{ "LightMode" = "ForwardBase" }
		ZWrite Off
		Cull Off
		Blend SrcAlpha OneMinusSrcAlpha

		CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
			float _T;
			sampler2D _Translation_MainTex;
			float4 _Translation_MainTex_ST;
			float _Translation_Transparent;
			float4 _Translation_Color;

			float _Translation_YSpeed;
			float _Translation_XMagnitude;
			float _Translation_XFrequency;
			float _Translation_XInvWaveLength;

			float _Translation_XSpeed;
			float _Translation_YMagnitude;
			float _Translation_YFrequency;
			float _Translation_YInvWaveLength;
			float4 _Translation_AColor;
			float4 _Translation_BColor;
			float _Translation_AtoBSpeed;

		struct a2v {
			float4 vertex : POSITION;
			float2 texcoord : TEXCOORD0;
		};
		struct v2f {
			float4 uv : TEXCOORD0;
			float4 pos : SV_POSITION;
		};
		v2f vert(a2v v)
		{
			v2f o;
			_Time.y = _T;
			float4 offset;
			offset.x = sin(_Translation_XFrequency*_Time.y + (v.vertex.x + v.vertex.y + v.vertex.z)*_Translation_XInvWaveLength)*_Translation_XMagnitude;
			offset.z = cos(_Translation_YFrequency*_Time.y + (v.vertex.x + v.vertex.y + v.vertex.z)*_Translation_YInvWaveLength)*_Translation_YMagnitude;
			offset.yw = float2(0,0);
			o.pos = UnityObjectToClipPos(v.vertex+offset);
			o.uv.xy = TRANSFORM_TEX(v.texcoord, _Translation_MainTex);
			o.uv.xy += float2(_Time.y*_Translation_XSpeed, _Time.y*_Translation_YSpeed);
			return o;
		}


		fixed4 frag(v2f i) : SV_Target{
			fixed4 col = tex2D(_Translation_MainTex,i.uv);
		_Time.y = _T;
		float3 Color = lerp(_Translation_AColor, _Translation_BColor, sin(_Time.y*_Translation_AtoBSpeed));
		col.rgb= Color;
		col.a *= _Translation_Transparent;
		return col;
		}
			ENDCG
		}

		}
	}

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

public class UV_STOP : MonoBehaviour {

    public Material MaterialA;
    public Material MaterialB;
    public bool A;
    public float L;//游戏运行时间
    public float T;//材质运行时间
    public float S;//暂停时间
    public float Q;//时间与暂停时间的差

	// Use this for initialization
	void Start () {
        
	}
	
	// Update is called once per frame
	void Update () {
        //  T = MaterialA.GetFloat("_T");

        L = Time.time;

        if (A)
        {

            T = L - Q;
            // S = T;

            MaterialA.SetFloat("_T", T);
            if (MaterialB) { MaterialB.SetFloat("_T", T); }
        }
        else
        {

            S = T;
            MaterialA.SetFloat("_T", S);
            if (MaterialB) { MaterialB.SetFloat("_T", S); }
            Q = L - S;
        }

    }
}

---

日记：

第一次写UV动画的shader哈哈，真的感觉挺好玩哒，计算机的浪漫~

提醒自己吧，三角函数该补习去了，太差了，不过性能消耗还没有测，代码也没有优化，能复用的地方也没有整理起来，代码优化的部分一直也没有去学习，毕竟目前的能力，能实现效果都费劲，优化只能放后去补了。

教训：构思真的很重要，不要急着写代码，先参考别人的，做好“百度”的工作，不然全部推翻重新写真的很费时间和打击积极性，磨刀不误砍柴工！