【转载】Unity&Shader基础篇-常用函数的使用与案例

一、前言

继前面的系列文章之后，本篇继续讲解Cg的常用函数的使用案例，帮助巩固Cg语言的基础知识。这些函数都可以在Cg的教程里The Cg Tutorial找到示例代码和函数意义。本文讲解几个常用的函数，分别有

1、Step(a,x):如果x<a返回0；如果x>或=a返回1

2、Clamp(x,a,a):如果x<a返回a；如果x>b返回b；如果在a和b之间就返回x

3、smoothstep(min,max,x):返回的值为–2*((x –min )/(max –min ))3 +3*((x –min )/(max –min ))2

4、lerp(a,b,f):线性插值函数，返回值为（1-f）*a+b*f

5、三角函数sin、cos

二、常用函数的使用实例1、Step函数，在中的Shader实例代码如下：

 

 

Shader "Unlit/Chapter5-Step"
{
        Properties
        {
                _background("背景色",Color)=(0,0,0,0)
        }
        SubShader
        {
                // No culling or depth
                Cull Off ZWrite Off ZTest Always
 
                CGINCLUDE
                ENDCG
 
 
        Pass
        {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
 
                #include "UnityCG.cginc"
                float4 _background;
 
        struct appdata
        {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
        };
 
        struct v2f
        {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
        };
 
        v2f vert(appdata v)
        {
                v2f o;
                o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
                o.uv = v.uv;
                o.uv.y = 1 - o.uv.y;
                return o;
        }
 
        // Functions
        fixed4 frag(v2f i) : SV_Target
        {
                float2 r = 2.0*(i.uv - 0.5);
                //_ScreenParams是Unity内置的变量
                float aspectRatio = _ScreenParams.x / _ScreenParams.y;
                r.x *= aspectRatio;
 
                fixed3 pixel = _background.xyz;
                float edge, variable, ret;
 
                //将屏幕划分成五个部分
 
                //第一部分
                if (r.x < -0.6*aspectRatio)
                {
                        variable = r.y;
                        edge = 0.2;
                        if (variable > edge)
                        {
                                ret = 1.0;
                        }
                        else
                        {
                                ret = 0;
                        }
                }
                else if (r.x < -0.2*aspectRatio)
                {
                        variable = r.y;
                        edge = -0.2;
                        //step(a,x):如果x<a结果返回0，反之返回1
                        ret = step(edge, variable);
                }
                else if (r.x < 0.2*aspectRatio)
                {
                        ret = 1.0 - step(0.5, r.y);
                }
                else if (r.x < 0.6*aspectRatio)
                {
                        ret = 0.3 + 0.5*step(-0.4, r.y);
                }
                else
                {
                        ret = step(-0.3, r.y) * (1.0 - step(0.2, r.y));
                }
                pixel = fixed3(ret, ret, ret);
                return fixed4(pixel, 1.0);
 
        }
 
 
                ENDCG
        }
        }
}

 

 

得到的效果图如图所示：

 

2、Clamp函数，在Unity中的Shader实例代码如下：

Shader "Unlit/Chapter5-Step"
{
        Properties
        {
                _background("背景色",Color)=(0,0,0,0)
        }
        SubShader
        {
                // No culling or depth
                Cull Off ZWrite Off ZTest Always
 
                CGINCLUDE
                ENDCG
 
 
        Pass
        {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
 
                #include "UnityCG.cginc"
                float4 _background;
 
        struct appdata
        {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
        };
 
        struct v2f
        {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
        };
 
        v2f vert(appdata v)
        {
                v2f o;
                o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
                o.uv = v.uv;
                o.uv.y = 1 - o.uv.y;
                return o;
        }
 
        // Functions
        fixed4 frag(v2f i) : SV_Target
        {
                float2 r = 2.0*(i.uv - 0.5);
                //_ScreenParams是Unity内置的变量
                float aspectRatio = _ScreenParams.x / _ScreenParams.y;
                r.x *= aspectRatio;
 
                fixed3 pixel = _background.xyz;
                float edge, variable, ret;
 
                //将屏幕划分成五个部分
 
                //第一部分
                if (r.x < -0.6*aspectRatio)
                {
                        variable = r.y;
                        edge = 0.2;
                        if (variable > edge)
                        {
                                ret = 1.0;
                        }
                        else
                        {
                                ret = 0;
                        }
                }
                else if (r.x < -0.2*aspectRatio)
                {
                        variable = r.y;
                        edge = -0.2;
                        //step(a,x):如果x<a结果返回0，反之返回1
                        ret = step(edge, variable);
                }
                else if (r.x < 0.2*aspectRatio)
                {
                        ret = 1.0 - step(0.5, r.y);
                }
                else if (r.x < 0.6*aspectRatio)
                {
                        ret = 0.3 + 0.5*step(-0.4, r.y);
                }
                else
                {
                        ret = step(-0.3, r.y) * (1.0 - step(0.2, r.y));
                }
                pixel = fixed3(ret, ret, ret);
                return fixed4(pixel, 1.0);
 
        }
 
 
                ENDCG
        }
        }
}

 

效果图如图所示：

 

 

说明：对比1和2的图会明显发现，在使用Clamp处理的时候，边缘的颜色会有渐变的效果。

 

3、smoothstep，这个脚本只给出片段着色器部分，其他部分同2，代码如下：

Shader "Unlit/Chapter5-Step"
{
        Properties
        {
                _background("背景色",Color)=(0,0,0,0)
        }
        SubShader
        {
                // No culling or depth
                Cull Off ZWrite Off ZTest Always
 
                CGINCLUDE
                ENDCG
 
 
        Pass
        {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
 
                #include "UnityCG.cginc"
                float4 _background;
 
        struct appdata
        {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
        };
 
        struct v2f
        {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
        };
 
        v2f vert(appdata v)
        {
                v2f o;
                o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
                o.uv = v.uv;
                o.uv.y = 1 - o.uv.y;
                return o;
        }
 
        // Functions
        fixed4 frag(v2f i) : SV_Target
        {
                float2 r = 2.0*(i.uv - 0.5);
                //_ScreenParams是Unity内置的变量
                float aspectRatio = _ScreenParams.x / _ScreenParams.y;
                r.x *= aspectRatio;
 
                fixed3 pixel = _background.xyz;
                float edge, variable, ret;
 
                //将屏幕划分成五个部分
 
                //第一部分
                if (r.x < -0.6*aspectRatio)
                {
                        variable = r.y;
                        edge = 0.2;
                        if (variable > edge)
                        {
                                ret = 1.0;
                        }
                        else
                        {
                                ret = 0;
                        }
                }
                else if (r.x < -0.2*aspectRatio)
                {
                        variable = r.y;
                        edge = -0.2;
                        //step(a,x):如果x<a结果返回0，反之返回1
                        ret = step(edge, variable);
                }
                else if (r.x < 0.2*aspectRatio)
                {
                        ret = 1.0 - step(0.5, r.y);
                }
                else if (r.x < 0.6*aspectRatio)
                {
                        ret = 0.3 + 0.5*step(-0.4, r.y);
                }
                else
                {
                        ret = step(-0.3, r.y) * (1.0 - step(0.2, r.y));
                }
                pixel = fixed3(ret, ret, ret);
                return fixed4(pixel, 1.0);
 
        }
 
 
                ENDCG
        }
        }
}

 

 

得到的效果图如上图所示，这个效果要对比之前的两个，可以发现有明显的过渡效果。当然不是说这个函数就比之前的函数好用，各有千秋，只是在本篇文章中特有的安排而已。

 

4、lerp函数，Unity中的Shader代码如下：

Shader "Unlit/Chapter5-Step"
{
        Properties
        {
                _background("背景色",Color)=(0,0,0,0)
        }
        SubShader
        {
                // No culling or depth
                Cull Off ZWrite Off ZTest Always
 
                CGINCLUDE
                ENDCG
 
 
        Pass
        {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
 
                #include "UnityCG.cginc"
                float4 _background;
 
        struct appdata
        {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
        };
 
        struct v2f
        {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
        };
 
        v2f vert(appdata v)
        {
                v2f o;
                o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
                o.uv = v.uv;
                o.uv.y = 1 - o.uv.y;
                return o;
        }
 
        // Functions
        fixed4 frag(v2f i) : SV_Target
        {
                float2 r = 2.0*(i.uv - 0.5);
                //_ScreenParams是Unity内置的变量
                float aspectRatio = _ScreenParams.x / _ScreenParams.y;
                r.x *= aspectRatio;
 
                fixed3 pixel = _background.xyz;
                float edge, variable, ret;
 
                //将屏幕划分成五个部分
 
                //第一部分
                if (r.x < -0.6*aspectRatio)
                {
                        variable = r.y;
                        edge = 0.2;
                        if (variable > edge)
                        {
                                ret = 1.0;
                        }
                        else
                        {
                                ret = 0;
                        }
                }
                else if (r.x < -0.2*aspectRatio)
                {
                        variable = r.y;
                        edge = -0.2;
                        //step(a,x):如果x<a结果返回0，反之返回1
                        ret = step(edge, variable);
                }
                else if (r.x < 0.2*aspectRatio)
                {
                        ret = 1.0 - step(0.5, r.y);
                }
                else if (r.x < 0.6*aspectRatio)
                {
                        ret = 0.3 + 0.5*step(-0.4, r.y);
                }
                else
                {
                        ret = step(-0.3, r.y) * (1.0 - step(0.2, r.y));
                }
                pixel = fixed3(ret, ret, ret);
                return fixed4(pixel, 1.0);
 
        }
 
 
                ENDCG
        }
        }
}

 

 

效果图如图所示：

 

这个Shader中对lerp函数和smoothstep函数做了对比，其中第三个区域是使用lerp函数的效果，第四个区域是先进行了smoothstep处理在进行lerp处理的效果。

 

5、lerp函数与直接的颜色加减进行对比：完整的Shader代码如下：

Shader "Unlit/Chapter5-Step"
{
        Properties
        {
                _background("背景色",Color)=(0,0,0,0)
        }
        SubShader
        {
                // No culling or depth
                Cull Off ZWrite Off ZTest Always
 
                CGINCLUDE
                ENDCG
 
 
        Pass
        {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
 
                #include "UnityCG.cginc"
                float4 _background;
 
        struct appdata
        {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
        };
 
        struct v2f
        {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
        };
 
        v2f vert(appdata v)
        {
                v2f o;
                o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
                o.uv = v.uv;
                o.uv.y = 1 - o.uv.y;
                return o;
        }
 
        // Functions
        fixed4 frag(v2f i) : SV_Target
        {
                float2 r = 2.0*(i.uv - 0.5);
                //_ScreenParams是Unity内置的变量
                float aspectRatio = _ScreenParams.x / _ScreenParams.y;
                r.x *= aspectRatio;
 
                fixed3 pixel = _background.xyz;
                float edge, variable, ret;
 
                //将屏幕划分成五个部分
 
                //第一部分
                if (r.x < -0.6*aspectRatio)
                {
                        variable = r.y;
                        edge = 0.2;
                        if (variable > edge)
                        {
                                ret = 1.0;
                        }
                        else
                        {
                                ret = 0;
                        }
                }
                else if (r.x < -0.2*aspectRatio)
                {
                        variable = r.y;
                        edge = -0.2;
                        //step(a,x):如果x<a结果返回0，反之返回1
                        ret = step(edge, variable);
                }
                else if (r.x < 0.2*aspectRatio)
                {
                        ret = 1.0 - step(0.5, r.y);
                }
                else if (r.x < 0.6*aspectRatio)
                {
                        ret = 0.3 + 0.5*step(-0.4, r.y);
                }
                else
                {
                        ret = step(-0.3, r.y) * (1.0 - step(0.2, r.y));
                }
                pixel = fixed3(ret, ret, ret);
                return fixed4(pixel, 1.0);
 
        }
 
 
                ENDCG
        }
        }
}

 

 

得到的效果图如图所示：第一部分通过lerp函数来处理颜色重叠的部分，第二、三部分之间通过颜色的加减来处理颜色重叠的部分。

 

 

6、三角函数，sin、cos函数：利用正弦余弦函数来做图形的旋转，效果图如图所示：

 

 

蓝色的网格和蓝色的矩形、圆盘都是固定的，旋转的是红色的网格以及网格上的矩阵和圆盘，它的shader代码如下：

 

Shader "Unlit/Chapter5-Step"
{
        Properties
        {
                _background("背景色",Color)=(0,0,0,0)
        }
        SubShader
        {
                // No culling or depth
                Cull Off ZWrite Off ZTest Always
 
                CGINCLUDE
                ENDCG
 
 
        Pass
        {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
 
                #include "UnityCG.cginc"
                float4 _background;
 
        struct appdata
        {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
        };
 
        struct v2f
        {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
        };
 
        v2f vert(appdata v)
        {
                v2f o;
                o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
                o.uv = v.uv;
                o.uv.y = 1 - o.uv.y;
                return o;
        }
 
        // Functions
        fixed4 frag(v2f i) : SV_Target
        {
                float2 r = 2.0*(i.uv - 0.5);
                //_ScreenParams是Unity内置的变量
                float aspectRatio = _ScreenParams.x / _ScreenParams.y;
                r.x *= aspectRatio;
 
                fixed3 pixel = _background.xyz;
                float edge, variable, ret;
 
                //将屏幕划分成五个部分
 
                //第一部分
                if (r.x < -0.6*aspectRatio)
                {
                        variable = r.y;
                        edge = 0.2;
                        if (variable > edge)
                        {
                                ret = 1.0;
                        }
                        else
                        {
                                ret = 0;
                        }
                }
                else if (r.x < -0.2*aspectRatio)
                {
                        variable = r.y;
                        edge = -0.2;
                        //step(a,x):如果x<a结果返回0，反之返回1
                        ret = step(edge, variable);
                }
                else if (r.x < 0.2*aspectRatio)
                {
                        ret = 1.0 - step(0.5, r.y);
                }
                else if (r.x < 0.6*aspectRatio)
                {
                        ret = 0.3 + 0.5*step(-0.4, r.y);
                }
                else
                {
                        ret = step(-0.3, r.y) * (1.0 - step(0.2, r.y));
                }
                pixel = fixed3(ret, ret, ret);
                return fixed4(pixel, 1.0);
 
        }
 
 
                ENDCG
        }
        }
}

 

 

7、使用lerp函数来进行缩放，效果图所示：同样，蓝色部分是固定的，红色部分是缩放的的对象。

 

 

缩放的Shader的代码如下：

 

Shader "Unlit/Chapter5-Step"
{
        Properties
        {
                _background("背景色",Color)=(0,0,0,0)
        }
        SubShader
        {
                // No culling or depth
                Cull Off ZWrite Off ZTest Always
 
                CGINCLUDE
                ENDCG
 
 
        Pass
        {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
 
                #include "UnityCG.cginc"
                float4 _background;
 
        struct appdata
        {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
        };
 
        struct v2f
        {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
        };
 
        v2f vert(appdata v)
        {
                v2f o;
                o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
                o.uv = v.uv;
                o.uv.y = 1 - o.uv.y;
                return o;
        }
 
        // Functions
        fixed4 frag(v2f i) : SV_Target
        {
                float2 r = 2.0*(i.uv - 0.5);
                //_ScreenParams是Unity内置的变量
                float aspectRatio = _ScreenParams.x / _ScreenParams.y;
                r.x *= aspectRatio;
 
                fixed3 pixel = _background.xyz;
                float edge, variable, ret;
 
                //将屏幕划分成五个部分
 
                //第一部分
                if (r.x < -0.6*aspectRatio)
                {
                        variable = r.y;
                        edge = 0.2;
                        if (variable > edge)
                        {
                                ret = 1.0;
                        }
                        else
                        {
                                ret = 0;
                        }
                }
                else if (r.x < -0.2*aspectRatio)
                {
                        variable = r.y;
                        edge = -0.2;
                        //step(a,x):如果x<a结果返回0，反之返回1
                        ret = step(edge, variable);
                }
                else if (r.x < 0.2*aspectRatio)
                {
                        ret = 1.0 - step(0.5, r.y);
                }
                else if (r.x < 0.6*aspectRatio)
                {
                        ret = 0.3 + 0.5*step(-0.4, r.y);
                }
                else
                {
                        ret = step(-0.3, r.y) * (1.0 - step(0.2, r.y));
                }
                pixel = fixed3(ret, ret, ret);
                return fixed4(pixel, 1.0);
 
        }
 
 
                ENDCG
        }
        }
}

 

 

 

8、平移以及旋转和平移的组合，效果如图所示，这个Shader部分分了两个部分对旋转和平移进行组合使用，分别是

 

先旋转在平移和先平移再旋转，Shader的代码如下：

Shader "Unlit/Chapter5-Step"
{
        Properties
        {
                _background("背景色",Color)=(0,0,0,0)
        }
        SubShader
        {
                // No culling or depth
                Cull Off ZWrite Off ZTest Always
 
                CGINCLUDE
                ENDCG
 
 
        Pass
        {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
 
                #include "UnityCG.cginc"
                float4 _background;
 
        struct appdata
        {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
        };
 
        struct v2f
        {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
        };
 
        v2f vert(appdata v)
        {
                v2f o;
                o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
                o.uv = v.uv;
                o.uv.y = 1 - o.uv.y;
                return o;
        }
 
        // Functions
        fixed4 frag(v2f i) : SV_Target
        {
                float2 r = 2.0*(i.uv - 0.5);
                //_ScreenParams是Unity内置的变量
                float aspectRatio = _ScreenParams.x / _ScreenParams.y;
                r.x *= aspectRatio;
 
                fixed3 pixel = _background.xyz;
                float edge, variable, ret;
 
                //将屏幕划分成五个部分
 
                //第一部分
                if (r.x < -0.6*aspectRatio)
                {
                        variable = r.y;
                        edge = 0.2;
                        if (variable > edge)
                        {
                                ret = 1.0;
                        }
                        else
                        {
                                ret = 0;
                        }
                }
                else if (r.x < -0.2*aspectRatio)
                {
                        variable = r.y;
                        edge = -0.2;
                        //step(a,x):如果x<a结果返回0，反之返回1
                        ret = step(edge, variable);
                }
                else if (r.x < 0.2*aspectRatio)
                {
                        ret = 1.0 - step(0.5, r.y);
                }
                else if (r.x < 0.6*aspectRatio)
                {
                        ret = 0.3 + 0.5*step(-0.4, r.y);
                }
                else
                {
                        ret = step(-0.3, r.y) * (1.0 - step(0.2, r.y));
                }
                pixel = fixed3(ret, ret, ret);
                return fixed4(pixel, 1.0);
 
        }
 
 
                ENDCG
        }
        }
}

 

三、放两个大招—各种动画效果1、效果如图所示：从左到右分别是五个不同的动画效果，使用到的函数都是前面讲解的函数加上之后补充的旋转、缩放和平移效果。

Shader代码如下：

Shader "Unlit/Chapter5-Step"
{
        Properties
        {
                _background("背景色",Color)=(0,0,0,0)
        }
        SubShader
        {
                // No culling or depth
                Cull Off ZWrite Off ZTest Always
 
                CGINCLUDE
                ENDCG
 
 
        Pass
        {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
 
                #include "UnityCG.cginc"
                float4 _background;
 
        struct appdata
        {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
        };
 
        struct v2f
        {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
        };
 
        v2f vert(appdata v)
        {
                v2f o;
                o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
                o.uv = v.uv;
                o.uv.y = 1 - o.uv.y;
                return o;
        }
 
        // Functions
        fixed4 frag(v2f i) : SV_Target
        {
                float2 r = 2.0*(i.uv - 0.5);
                //_ScreenParams是Unity内置的变量
                float aspectRatio = _ScreenParams.x / _ScreenParams.y;
                r.x *= aspectRatio;
 
                fixed3 pixel = _background.xyz;
                float edge, variable, ret;
 
                //将屏幕划分成五个部分
 
                //第一部分
                if (r.x < -0.6*aspectRatio)
                {
                        variable = r.y;
                        edge = 0.2;
                        if (variable > edge)
                        {
                                ret = 1.0;
                        }
                        else
                        {
                                ret = 0;
                        }
                }
                else if (r.x < -0.2*aspectRatio)
                {
                        variable = r.y;
                        edge = -0.2;
                        //step(a,x):如果x<a结果返回0，反之返回1
                        ret = step(edge, variable);
                }
                else if (r.x < 0.2*aspectRatio)
                {
                        ret = 1.0 - step(0.5, r.y);
                }
                else if (r.x < 0.6*aspectRatio)
                {
                        ret = 0.3 + 0.5*step(-0.4, r.y);
                }
                else
                {
                        ret = step(-0.3, r.y) * (1.0 - step(0.2, r.y));
                }
                pixel = fixed3(ret, ret, ret);
                return fixed4(pixel, 1.0);
 
        }
 
 
                ENDCG
        }
        }
}

 

代码中使用到了“_Time”变量，这个是Unity内置的四维向量，（t/20,t,t*2,t*3）因此“_Time.y=t”即获得系统的渲染的单位时间。
2、等离子流动效果，效果图如图所示：

Shader代码如下：

Shader "Unlit/Chapter5-Step"
{
        Properties
        {
                _background("背景色",Color)=(0,0,0,0)
        }
        SubShader
        {
                // No culling or depth
                Cull Off ZWrite Off ZTest Always
 
                CGINCLUDE
                ENDCG
 
 
        Pass
        {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
 
                #include "UnityCG.cginc"
                float4 _background;
 
        struct appdata
        {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
        };
 
        struct v2f
        {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
        };
 
        v2f vert(appdata v)
        {
                v2f o;
                o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
                o.uv = v.uv;
                o.uv.y = 1 - o.uv.y;
                return o;
        }
 
        // Functions
        fixed4 frag(v2f i) : SV_Target
        {
                float2 r = 2.0*(i.uv - 0.5);
                //_ScreenParams是Unity内置的变量
                float aspectRatio = _ScreenParams.x / _ScreenParams.y;
                r.x *= aspectRatio;
 
                fixed3 pixel = _background.xyz;
                float edge, variable, ret;
 
                //将屏幕划分成五个部分
 
                //第一部分
                if (r.x < -0.6*aspectRatio)
                {
                        variable = r.y;
                        edge = 0.2;
                        if (variable > edge)
                        {
                                ret = 1.0;
                        }
                        else
                        {
                                ret = 0;
                        }
                }
                else if (r.x < -0.2*aspectRatio)
                {
                        variable = r.y;
                        edge = -0.2;
                        //step(a,x):如果x<a结果返回0，反之返回1
                        ret = step(edge, variable);
                }
                else if (r.x < 0.2*aspectRatio)
                {
                        ret = 1.0 - step(0.5, r.y);
                }
                else if (r.x < 0.6*aspectRatio)
                {
                        ret = 0.3 + 0.5*step(-0.4, r.y);
                }
                else
                {
                        ret = step(-0.3, r.y) * (1.0 - step(0.2, r.y));
                }
                pixel = fixed3(ret, ret, ret);
                return fixed4(pixel, 1.0);
 
        }
 
 
                ENDCG
        }
        }
}

 

 

四、总结
1、Cg函数虽简单，使用得当也是逼格暴涨，对于想学好Shader童鞋来讲，还是要多从Cg语言基础着手，通过实例练习，不仅可以巩固基础知识，而且也可以在做的过程中添加学习的信心和兴趣。
2、正弦、余弦函数配合时间变量的使用能做到非常不错的动画效果，最好的效果还是要从根本上来讲还是数学，当今世界是学好数学和英语走遍天下都不怕了。

 

（原文地址游戏蛮牛凯尔八阿哥专栏，转载请注明出处）