Unity shader 之，Shader内部时间离散处理 [推广有奖]

0关注
0粉丝

等待验证会员

学前班

40%

还不是VIP/贵宾

-

0%

威望: 0 级
论坛币: 0 个
通用积分: 0
学术水平: 0 点
热心指数: 0 点
信用等级: 0 点
经验: 20 点
帖子: 1
精华: 0
在线时间: 0 小时
注册时间: 2018-10-17
最后登录: 2018-10-17

楼主

benjiu2296 发表于 2025-11-28 14:50:43 |AI写论文

是否 +2 论坛币

k人参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

哈喽，大家好！我是你们熟悉的熊猫老师，今天带来一篇关于Shader性能优化的实用教程。本次内容不涉及图形渲染效果，而是聚焦于算法层面的计算优化。在实际开发中，我们常常会遇到这样的问题：某些Shader效果并不需要每帧都进行实时计算，但又不希望额外挂载C#脚本来控制更新频率，更不愿意使用粒子系统来实现类似功能——尤其是从性能角度考虑时。那么，有没有一种更优雅的解决方案呢？面对这种情况，通常有两种选择： 1. 直接放弃，准备跑路…… 2. 采用一种被称为“时间离散处理”的进阶方案。显然，我们不会选择第一条路。接下来重点讲解第二种方法：通过将时间进行离散化处理，以整数倍的时间间隔代替连续的Time值，从而减少不必要的高频计算。虽然该算法需要自行编写，但原理清晰、实现简单，且对性能有显著提升。下面我们来看一个对比示例。左侧为使用Amplify Shader Editor（ASE）生成的效果，右侧则是手写代码实现的结果。两者视觉表现完全一致，但在性能消耗上却存在明显差异。

这是ASE版本的效果链接图，供参考学习：（掌握技术应从最基础的例子入手，理解最核心的原理）

原版ASE生成的代码如下所示：

// Made with Amplify Shader Editor
// Available at the Unity Asset Store - http://u3d.as/y3X 
Shader "TA_Alpha"
{
	Properties
	{
		[HDR]_MainTex("_MainTex", 2D) = "white" {}
		[HDR]_Tint("Tint", Color) = (0.9103774,1,0.9645071,0)
		_Alpha("Alpha", 2D) = "white" {}
		_Speed("Speed", Float) = 0.1
	
		[HideInInspector] _texcoord( "", 2D ) = "white" {}
		[HideInInspector] __dirty( "", Int ) = 1
	}

	SubShader
	{
		Tags{ "RenderType" = "Transparent"  "Queue" = "Transparent+0" "IgnoreProjector" = "True" "IsEmissive" = "true"  }
		Cull Back
		CGINCLUDE
		#include "UnityShaderVariables.cginc"
		#include "UnityPBSLighting.cginc"
		#include "Lighting.cginc"
		#pragma target 3.0
		struct Input
		{
			float2 uv_texcoord;
		};

		uniform float _Speed;
		uniform sampler2D _MainTex;
		uniform float4 _MainTex_ST;
		uniform float4 _Tint;
		uniform sampler2D _Alpha;
		uniform float4 _Alpha_ST;


		float3 RotateAroundAxis( float3 center, float3 original, float3 u, float angle )
		{
			original -= center;
			float C = cos( angle );
			float S = sin( angle );
			float t = 1 - C;
			float m00 = t * u.x * u.x + C;
			float m01 = t* u.x * u.y - S * u.z;
			float m02 = t * u.x * u.z + S * u.y;
			float m10 = t * u.x * u.y + S * u.z;
			float m11 = t * u.y * u.y + C;
			float m12 = t * u.y * u.z - S * u.x;
			float m20 = t * u.x * u.z - S * u.y;
			float m21 = t * u.y * u.z + S * u.x;
			float m22 = t * u.z * u.z + C;
			float3x3 finalMatrix = float3x3( m00, m01, m02, m10, m11, m12, m20, m21, m22 );
			return mul( finalMatrix, original ) + center;
		}


		void vertexDataFunc( inout appdata_full v, out Input o )
		{
			UNITY_INITIALIZE_OUTPUT( Input, o );
			float mulTime17 = _Time.y * _Speed;
			float3 ase_vertex3Pos = v.vertex.xyz;
			float3 rotatedValue13 = RotateAroundAxis( float3( 0,0,0 ), ase_vertex3Pos, float3(0,1,0), mulTime17 );
			v.vertex.xyz = rotatedValue13;
			v.vertex.w = 1;
		}

		void surf( Input i , inout SurfaceOutputStandard o )
		{
			float2 uv_MainTex = i.uv_texcoord * _MainTex_ST.xy + _MainTex_ST.zw;
			o.Emission = ( tex2D( _MainTex, uv_MainTex ) * _Tint ).rgb;
			float2 uv_Alpha = i.uv_texcoord * _Alpha_ST.xy + _Alpha_ST.zw;
			o.Alpha = tex2D( _Alpha, uv_Alpha ).r;
		}

		ENDCG
		CGPROGRAM
		#pragma surface surf Standard alpha:fade keepalpha fullforwardshadows vertex:vertexDataFunc 

		ENDCG
		Pass
		{
			Name "ShadowCaster"
			Tags{ "LightMode" = "ShadowCaster" }
			ZWrite On
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			#pragma target 3.0
			#pragma multi_compile_shadowcaster
			#pragma multi_compile UNITY_PASS_SHADOWCASTER
			#pragma skip_variants FOG_LINEAR FOG_EXP FOG_EXP2
			#include "HLSLSupport.cginc"
			#if ( SHADER_API_D3D11 || SHADER_API_GLCORE || SHADER_API_GLES || SHADER_API_GLES3 || SHADER_API_METAL || SHADER_API_VULKAN )
				#define CAN_SKIP_VPOS
			#endif
			#include "UnityCG.cginc"
			#include "Lighting.cginc"
			#include "UnityPBSLighting.cginc"
			sampler3D _DitherMaskLOD;
			struct v2f
			{
				V2F_SHADOW_CASTER;
				float2 customPack1 : TEXCOORD1;
				float3 worldPos : TEXCOORD2;
				UNITY_VERTEX_INPUT_INSTANCE_ID
				UNITY_VERTEX_OUTPUT_STEREO
			};
			v2f vert( appdata_full v )
			{
				v2f o;
				UNITY_SETUP_INSTANCE_ID( v );
				UNITY_INITIALIZE_OUTPUT( v2f, o );
				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO( o );
				UNITY_TRANSFER_INSTANCE_ID( v, o );
				Input customInputData;
				vertexDataFunc( v, customInputData );
				float3 worldPos = mul( unity_ObjectToWorld, v.vertex ).xyz;
				half3 worldNormal = UnityObjectToWorldNormal( v.normal );
				o.customPack1.xy = customInputData.uv_texcoord;
				o.customPack1.xy = v.texcoord;
				o.worldPos = worldPos;
				TRANSFER_SHADOW_CASTER_NORMALOFFSET( o )
				return o;
			}
			half4 frag( v2f IN
			#if !defined( CAN_SKIP_VPOS )
			, UNITY_VPOS_TYPE vpos : VPOS
			#endif
			) : SV_Target
			{
				UNITY_SETUP_INSTANCE_ID( IN );
				Input surfIN;
				UNITY_INITIALIZE_OUTPUT( Input, surfIN );
				surfIN.uv_texcoord = IN.customPack1.xy;
				float3 worldPos = IN.worldPos;
				half3 worldViewDir = normalize( UnityWorldSpaceViewDir( worldPos ) );
				SurfaceOutputStandard o;
				UNITY_INITIALIZE_OUTPUT( SurfaceOutputStandard, o )
				surf( surfIN, o );
				#if defined( CAN_SKIP_VPOS )
				float2 vpos = IN.pos;
				#endif
				half alphaRef = tex3D( _DitherMaskLOD, float3( vpos.xy * 0.25, o.Alpha * 0.9375 ) ).a;
				clip( alphaRef - 0.01 );
				SHADOW_CASTER_FRAGMENT( IN )
			}
			ENDCG
		}
	}
	Fallback "Diffuse"
	CustomEditor "ASEMaterialInspector"
}
/*ASEBEGIN
Version=18800
406;129;1920;977;1457.315;529.5779;1.3;True;True
Node;AmplifyShaderEditor.CommentaryNode;19;-959.0353,121.038;Inherit;False;890;506;整体顶点动画 ;5;17;14;13;12;18;;1,1,1,1;0;0
Node;AmplifyShaderEditor.RangedFloatNode;14;-909.0353,304.9381;Inherit;False;Property;_Speed;Speed;3;0;Create;True;0;0;0;False;0;False;0.1;0.1;0;0;0;1;FLOAT;0
Node;AmplifyShaderEditor.SimpleTimeNode;17;-734.8353,347.8381;Inherit;False;1;0;FLOAT;1;False;1;FLOAT;0
Node;AmplifyShaderEditor.Vector3Node;12;-738.7358,193.138;Inherit;False;Constant;_RotationDirection;RotationDirection;2;0;Create;True;0;0;0;False;0;False;0,1,0;0,0,0;0;4;FLOAT3;0;FLOAT;1;FLOAT;2;FLOAT;3
Node;AmplifyShaderEditor.PosVertexDataNode;18;-740.0353,444.038;Inherit;False;0;0;5;FLOAT3;0;FLOAT;1;FLOAT;2;FLOAT;3;FLOAT;4
Node;AmplifyShaderEditor.SamplerNode;2;-678.0999,-402.3;Inherit;True;Property;_MainTex;_MainTex;0;1;[HDR];Create;True;0;0;0;False;0;False;-1;None;None;True;0;False;white;Auto;False;Object;-1;Auto;Texture2D;8;0;SAMPLER2D;;False;1;FLOAT2;0,0;False;2;FLOAT;0;False;3;FLOAT2;0,0;False;4;FLOAT2;0,0;False;5;FLOAT;1;False;6;FLOAT;0;False;7;SAMPLERSTATE;;False;5;COLOR;0;FLOAT;1;FLOAT;2;FLOAT;3;FLOAT;4
Node;AmplifyShaderEditor.ColorNode;8;-687.8998,-206.6;Inherit;False;Property;_Tint;Tint;1;1;[HDR];Create;True;0;0;0;False;0;False;0.9103774,1,0.9645071,0;0,0,0,0;True;0;5;COLOR;0;FLOAT;1;FLOAT;2;FLOAT;3;FLOAT;4
Node;AmplifyShaderEditor.SimpleMultiplyOpNode;4;-322.1,-254.5001;Inherit;False;2;2;0;COLOR;0,0,0,0;False;1;COLOR;0,0,0,0;False;1;COLOR;0
Node;AmplifyShaderEditor.SamplerNode;20;-465.7349,-133.162;Inherit;True;Property;_Alpha;Alpha;2;0;Create;True;0;0;0;False;0;False;-1;None;None;True;0;False;white;Auto;False;Object;-1;Auto;Texture2D;8;0;SAMPLER2D;;False;1;FLOAT2;0,0;False;2;FLOAT;0;False;3;FLOAT2;0,0;False;4;FLOAT2;0,0;False;5;FLOAT;1;False;6;FLOAT;0;False;7;SAMPLERSTATE;;False;5;COLOR;0;FLOAT;1;FLOAT;2;FLOAT;3;FLOAT;4
Node;AmplifyShaderEditor.RotateAboutAxisNode;13;-389.0353,169.738;Inherit;False;False;4;0;FLOAT3;0,0,0;False;1;FLOAT;0;False;2;FLOAT3;0,0,0;False;3;FLOAT3;0,0,0;False;1;FLOAT3;0
Node;AmplifyShaderEditor.StandardSurfaceOutputNode;9;365,-218;Float;False;True;-1;2;ASEMaterialInspector;0;0;Standard;TA_Alpha;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;False;False;False;False;False;False;Back;0;False;-1;0;False;-1;False;0;False;-1;0;False;-1;False;0;Transparent;0.5;True;True;0;False;Transparent;;Transparent;All;14;all;True;True;True;True;0;False;-1;False;0;False;-1;255;False;-1;255;False;-1;0;False;-1;0;False;-1;0;False;-1;0;False;-1;0;False;-1;0;False;-1;0;False;-1;0;False;-1;False;2;15;10;25;False;0.5;True;2;5;False;-1;10;False;-1;0;0;False;-1;0;False;-1;0;False;-1;0;False;-1;0;False;0;0,0,0,0;VertexOffset;True;False;Cylindrical;False;Absolute;0;;-1;-1;-1;-1;0;False;0;0;False;-1;-1;0;False;-1;0;0;0;False;0.1;False;-1;0;False;-1;False;16;0;FLOAT3;0,0,0;False;1;FLOAT3;0,0,0;False;2;FLOAT3;0,0,0;False;3;FLOAT;0;False;4;FLOAT;0;False;5;FLOAT;0;False;6;FLOAT3;0,0,0;False;7;FLOAT3;0,0,0;False;8;FLOAT;0;False;9;FLOAT;0;False;10;FLOAT;0;False;13;FLOAT3;0,0,0;False;11;FLOAT3;0,0,0;False;12;FLOAT3;0,0,0;False;14;FLOAT4;0,0,0,0;False;15;FLOAT3;0,0,0;False;0
WireConnection;17;0;14;0
WireConnection;4;0;2;0
WireConnection;4;1;8;0
WireConnection;13;0;12;0
WireConnection;13;1;17;0
WireConnection;13;3;18;0
WireConnection;9;2;4;0
WireConnection;9;9;20;1
WireConnection;9;11;13;0
ASEEND*/
//CHKSM=2F22B8227D330DA8D379CA30A1A6A8B71E58CAD2

可以看出，其自动生成的代码结构较为冗余，属于典型的“可运行但不推荐学习”的类型。因此，我对该Shader进行了重构优化。由于原始ASE脚本基于Surface Shader，我也相应地采用了相同结构进行重写。这是我手动编写的优化版本代码：

Shader "Optimized/ObjectRotation"
{
    Properties
    {
        [HDR] _Color("Color", Color) = (1,1,1,0)
        _MainTex ("Texture", 2D) = "white" {}
        _Alpha ("Alpha", 2D) = "white" {}
        _RotationSpeed ("Rotation Speed", Float) = 1.0
        // 保留时间离散化功能，这是降低计算频率的核心
        _FrameInterval ("Frame Interval", Float) = 0.05
    }
    
    SubShader
    {
        Tags {
            "RenderType"="Transparent"
            "Queue" = "Transparent"
            "IgnoreProjector" = "True"
        }
        LOD 100
        
        // 重要：保持单Pass，这是合批的前提
        Blend SrcAlpha OneMinusSrcAlpha
        ZWrite Off
        Cull Back // 明确指定剔除，避免不必要的片元计算

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            // 添加此指令以支持动态合批（如果条件满足）
            #pragma multi_compile_fog

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
                UNITY_FOG_COORDS(1) // 雾效坐标
            };

            // 精度优化：纹理和颜色通常使用 half 或 fixed 即可
            sampler2D _MainTex;
            half4 _MainTex_ST; // ST变换使用half精度
            sampler2D _Alpha;
            half4 _Alpha_ST;
            half4 _Color;
            half _RotationSpeed;
            half _FrameInterval;

            // 优化函数：获取离散化时间
            half GetDiscreteTime(half currentTime, half interval)
            {
                return floor(currentTime / interval) * interval;
            }

            v2f vert (appdata v)
            {
                v2f o;
                
                // 1. 时间离散化计算
                half discreteTime = GetDiscreteTime(_Time.y, _FrameInterval);
                half angle = discreteTime * _RotationSpeed;

                // 2. 优化旋转计算：假设绕Y轴旋转，直接计算旋转后的坐标，避免完整矩阵
                half s, c;
                sincos(angle, s, c); // 使用sincos指令同时计算正弦和余弦，比分别调用sin/cos更高效
                
                float3 rotatedVertex = v.vertex.xyz;
                // 简化后的绕Y轴旋转公式
                rotatedVertex.xz = half2(
                    c * rotatedVertex.x + s * rotatedVertex.z,
                    c * rotatedVertex.z - s * rotatedVertex.x
                );

                o.vertex = UnityObjectToClipPos(rotatedVertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                UNITY_TRANSFER_FOG(o, o.vertex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // 片元着色器保持简单：纹理采样和混合
                half4 col = tex2D(_MainTex, i.uv) * _Color;
                half alpha = tex2D(_Alpha, i.uv).r;
                col.a = alpha;
                UNITY_APPLY_FOG(i.fogCoord, col); // 应用雾效
                return col;
            }
            ENDCG
        }
    }
    // 可添加Fallback
    Fallback "Transparent/VertexLit"
}

核心在于引入了“时间离散算法”，具体实现如下：

// 优化函数：获取离散化时间
 half GetDiscreteTime(half currentTime, half interval)
 {
     return floor(currentTime / interval) * interval;
 }

在涉及运动或动态变化的计算中，只需将原本使用的`_Time`变量替换为经过离散化处理后的时间值即可。例如：

// 1. 时间离散化计算
               half discreteTime = GetDiscreteTime(_Time.y, _FrameInterval);
               half angle = discreteTime * _RotationSpeed;

通过这种方式，可以有效降低GPU的计算频率，在保持视觉效果不变的前提下大幅提升运行效率。接下来是关键的性能对比数据：

从图表可以看出，在移动端设备上，手写优化后的Shader在帧率稳定性和GPU占用率方面均优于ASE默认输出版本。这说明合理的算法设计和代码结构对移动端渲染性能有着至关重要的影响。总结：在移动端进行Shader开发时，必须高度重视性能优化。避免盲目依赖可视化编辑工具生成的代码，学会用算法思维去精简和控制计算频率，才是提升项目整体表现的关键所在。