几何变换_扭曲01

2020-07-02  本文已影响0人  Rayson

1.空白shader


Shader "Unlit/niuqu"
{
    SubShader{

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

            struct a2v
            {
                 float4 vertex : POSITION;
            };
 
            struct v2f {                
                float4 pos:POSITION;
                float4 color:COLOR;
            };          

            v2f vert(appdata_base v )
                {
                    v2f o;
                    o.pos= UnityObjectToClipPos(v.vertex);      
                    o.color= fixed4(1,1,1,1);       
                    return o; 
                }   
            fixed4 frag(v2f i):SV_TARGET            //返回类型要统一 传入传出类型一定要一致
                {
                    return i.color;
                }
            ENDCG
            }
    }   
}



Shader "Unlit/niuqu"
{
    SubShader{

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

            struct a2v
            {
                 float4 vertex : POSITION;
            };
 
            struct v2f {                
                float4 pos:POSITION;
                float4 color:COLOR;
            };          

            

            v2f vert(appdata_base v )

                {
                    float angle=length(v.vertex)*_SinTime.w ;           //模长计算

                    //加入旋转矩阵
                    float4x4 m = 

                    {
                        float4(cos(angle),0,sin(angle),0),
                        float4(0,1,0,1),
                        float4(-sin(angle),0,cos(angle),0),
                        float4(0,0,0,1)
                    };

                    float4x4 p = UNITY_MATRIX_MVP;

                    m =mul(p,m);
                    v2f o;
                    o.pos= mul(m,v.vertex);     //传入矩阵变换
                    o.color= fixed4(0,1,1,1);       //以高度作为颜色
                    return o; 
                }   
            fixed4 frag(v2f i):SV_TARGET            //返回类型要统一 传入传出类型一定要一致
                {
                    return i.color;
                }
            ENDCG
            }
    }   
}
效果参考

矩阵优化


Shader "Unlit/niuqu"
{
   SubShader{

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

           struct a2v
           {
                float4 vertex : POSITION;
           };

           struct v2f {                
               float4 pos:POSITION;
               float4 color:COLOR;
           };          


           v2f vert(appdata_base v )

               {
                   float angle=length(v.vertex)*_SinTime.w ;           //模长计算

                   float x = cos(angle)*v.vertex.x + sin(angle)*v.vertex.z;
                   float z = cos(angle)*v.vertex.z - sin(angle)*v.vertex.x;
                   v.vertex.x = x;
                   v.vertex.z = z;
                   
                   v2f o;
                   float4x4 p = UNITY_MATRIX_MVP;      //用MVP矩阵去变换新矩阵
                   o.pos= mul(p,v.vertex);             //传入矩阵变换
                   o.color= fixed4(0,1,1,1);           //以高度作为颜色
                   return o; 
               }   
           fixed4 frag(v2f i):SV_TARGET            //返回类型要统一 传入传出类型一定要一致
               {
                   return i.color;
               }
           ENDCG
           }
   }   
}

Z方向顶点缩放 效果


矩阵公式

Shader "Unlit/niuqu"
{
    SubShader{
            pass{               
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
            
            struct a2v
            {
                 float4 vertex : POSITION;
            };
 
            struct v2f {                
                float4 pos:POSITION;
                float4 color:COLOR;
            };          

            v2f vert(appdata_base v )
                {
                    float angle=length(v.vertex)*_SinTime.w ;           //模长计算

                    // float x = cos(angle)*v.vertex.x + sin(angle)*v.vertex.z;
                    // float z = cos(angle)*v.vertex.z - sin(angle)*v.vertex.x;
                    // v.vertex.x = x;
                    // v.vertex.z = z;
                     float4x4 m = 
                    {
                        float4(sin(angle),0,0,0),
                        float4(0,1,0,1),
                        float4(0,0,1,0),
                        float4(0,0,0,1)
                    };
                    v.vertex = mul(m,v.vertex);
                    v2f o;
                    float4x4 p = UNITY_MATRIX_MVP;      //用MVP矩阵去变换新矩阵
                    o.pos= mul(p,v.vertex);             //传入矩阵变换
                    o.color= fixed4(0,1,1,1);           //以高度作为颜色
                    return o; 
                }   
            fixed4 frag(v2f i):SV_TARGET            //返回类型要统一 传入传出类型一定要一致
                {
                    return i.color;
                }
            ENDCG
            }
    }   
}

效果

通过给 x值做效果限制 限制在0-1之间


Shader "Unlit/niuqu"
{
    SubShader{
            pass{               
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct a2v
            {
                 float4 vertex : POSITION;
            };
 
            struct v2f {                
                float4 pos:POSITION;
                float4 color:COLOR;
            };          

            v2f vert(appdata_base v )
                {
                    float angle=length(v.vertex)*_SinTime.w ;           //模长计算

                    // float x = cos(angle)*v.vertex.x + sin(angle)*v.vertex.z;
                    // float z = cos(angle)*v.vertex.z - sin(angle)*v.vertex.x;
                    // v.vertex.x = x;
                    // v.vertex.z = z;
                     float4x4 m = 
                    {
                        float4(sin(angle)/8+0.5 ,0,0,0),  //X/2+0.5 把值限制在0 - 1之间
                        float4(0,1,0,1),
                        float4(0,0,1,0),
                        float4(0,0,0,1)
                    };
                    v.vertex = mul(m,v.vertex);
                    v2f o;
                    float4x4 p = UNITY_MATRIX_MVP;      //用MVP矩阵去变换新矩阵
                    o.pos= mul(p,v.vertex);             //传入矩阵变换
                    o.color= fixed4(0,1,1,1);           //以高度作为颜色
                    return o; 
                }   
            fixed4 frag(v2f i):SV_TARGET            //返回类型要统一 传入传出类型一定要一致
                {
                    return i.color;
                }
            ENDCG
            }
    }   
}


随时间因子做匀速变化


Shader "Unlit/niuqu"
{
    SubShader{
            pass{               
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct a2v
            {
                 float4 vertex : POSITION;
            };
 
            struct v2f {                
                float4 pos:POSITION;
                float4 color:COLOR;
            };          

            v2f vert(appdata_base v )
                {
                //  float angle=length(v.vertex)*_SinTime.w ;           //模长计算

                    // float x = cos(angle)*v.vertex.x + sin(angle)*v.vertex.z;
                    // float z = cos(angle)*v.vertex.z - sin(angle)*v.vertex.x;
                    // v.vertex.x = x;
                    // v.vertex.z = z;
                    float angle = v.vertex.z+_Time.y ;          //z值+缩放时间因子 会得出随着时间叠加不断变 匀速扭曲的效果

                     float4x4 m = 
                    {
                        float4(sin(angle)/8+0.5 ,0,0,0),  //X/2+0.5 把值限制在0 - 1之间
                        float4(0,1,0,1),
                        float4(0,0,1,0),
                        float4(0,0,0,1)
                    };
                    v.vertex = mul(m,v.vertex);
                    v2f o;
                    float4x4 p = UNITY_MATRIX_MVP;      //用MVP矩阵去变换新矩阵
                    o.pos= mul(p,v.vertex);             //传入矩阵变换
                    o.color= fixed4(0,1,1,1);           //以高度作为颜色
                    return o; 
                }   
            fixed4 frag(v2f i):SV_TARGET            //返回类型要统一 传入传出类型一定要一致
                {
                    return i.color;
                }
            ENDCG
            }
    }   
}

image.png
上一篇 下一篇

猜你喜欢

热点阅读