zoukankan      html  css  js  c++  java

  • [UnityShader2]顶点片段着色器实例

    主要参考博客：http://blog.csdn.NET/mobanchengshuang?viewmode=contents


    1.条纹向上运动

    [csharp]  view plain  copy
    1. Shader "Custom/New" {  
    2.     Properties  
    3.     {  
    4.         _MainTex("Base (RGB)", 2D) = "white" {}  
    5.         _Speed("Speed", float) = 1  
    6.         _Width("Width", float) = 1  
    7.         _Space("Space", float) = 0.1  
    8.     }  
    9.     SubShader  
    10.     {  
    11.         //Blend One One  
    12.         //AlphaTest Greater 0.1  
    13.         Cull off  
    14.         Pass  
    15.         {  
    16.             CGPROGRAM  
    17.             #pragma vertex vert     
    18.             #pragma fragment frag      
    19.             #include "UnityCG.cginc"  
    20.   
    21.             sampler2D _MainTex;  
    22.             float _Speed;  
    23.             float _Width;  
    24.             float _Space;  
    25.   
    26.             struct vertexOutput   
    27.             {  
    28.                 float4 pos : SV_POSITION;  
    29.                 float2 tex : TEXCOORD0;  
    30.                 float4 srcPos : TEXCOORD1;  
    31.             };  
    32.             vertexOutput vert(appdata_full input)  
    33.             {  
    34.                 vertexOutput output;  
    35.                 output.pos = mul(UNITY_MATRIX_MVP, input.vertex);    
    36.                 output.tex = input.texcoord;  
    37.                 output.srcPos = input.vertex;  
    38.                   
    39.                 return output;  
    40.             }   
    41.             float4 frag(vertexOutput input) : COLOR  
    42.             {  
    43.                 /*if (fmod(abs(input.srcPos.y), _Space) < _Width) 
    44.                 { 
    45.                     float x = input.tex.x + _Time * _Speed; 
    46.                     float2 newUV = float2(x, input.tex.y); 
    47.                     float4 c = tex2D(_MainTex, newUV); 
    48.                     return c; 
    49.                 }*/  
    50.                 float a = input.srcPos.y - _Time * _Speed;  
    51.                 if (fmod(abs(a), _Space) < _Width)  
    52.                 {  
    53.                     float4 c = tex2D(_MainTex, input.tex);  
    54.                     return c;  
    55.                 }  
    56.                 else  
    57.                 {  
    58.                     float4 c = float4(0, 0, 0, 0);  
    59.                     clip(c.a - 0.5);  
    60.                     return c;  
    61.                 }             
    62.             }  
    63.             ENDCG  
    64.         }  
    65.     }  
    66.     FallBack "Diffuse"  
    67. }  


    2.反色

    [csharp]  view plain  copy
    1. Shader "Custom/New" {  
    2.     Properties  
    3.     {  
    4.         _MainTex("Base (RGB)", 2D) = "white" {}  
    5.         _Color("MainColor(RGB)", Color) = (1, 1, 1, 1)  
    6.     }  
    7.     SubShader  
    8.     {  
    9.         Pass  
    10.         {  
    11.             CGPROGRAM  
    12.             #pragma vertex vert     
    13.             #pragma fragment frag      
    14.             #include "UnityCG.cginc"  
    15.   
    16.             sampler2D _MainTex;  
    17.             float4 _Color;  
    18.   
    19.             struct vertexOutput  
    20.             {  
    21.                 float4 pos : SV_POSITION;  
    22.                 float2 tex : TEXCOORD0;  
    23.                 float4 srcPos : TEXCOORD1;  
    24.             };  
    25.             vertexOutput vert(appdata_full input)  
    26.             {  
    27.                 vertexOutput output;  
    28.                 output.pos = mul(UNITY_MATRIX_MVP, input.vertex);  
    29.                 output.tex = input.texcoord;  
    30.                 output.srcPos = input.vertex;  
    31.   
    32.                 return output;  
    33.             }  
    34.             float4 frag(vertexOutput input) : COLOR  
    35.             {  
    36.                 float4 c = tex2D(_MainTex, input.tex);  
    37.                 float4 newCol = _Color - c;  
    38.                 return newCol;    
    39.             }  
    40.         ENDCG  
    41.     }  
    42.     }  
    43.     FallBack "Diffuse"  
    44. }  


    3.边缘高光

    [csharp]  view plain  copy
    1. Shader "Custom/New" {  
    2.     Properties  
    3.     {  
    4.         _MainTex("Base (RGB)", 2D) = "white" {}  
    5.         //_Color("MainColor(RGB)", Color) = (1, 1, 1, 1)  
    6.         _RimColor("RimColor(RGB)", Color) = (1, 1, 1, 1)  
    7.         _RimPower("RimPower", float) = 1  
    8.     }  
    9.     SubShader  
    10.     {  
    11.         Pass  
    12.         {  
    13.             CGPROGRAM  
    14.             #pragma vertex vert     
    15.             #pragma fragment frag      
    16.             #include "UnityCG.cginc"  
    17.   
    18.             sampler2D _MainTex;  
    19.             //float4 _Color;  
    20.             float4 _RimColor;  
    21.             float _RimPower;  
    22.   
    23.             struct vertexOutput  
    24.             {  
    25.                 float4 pos : SV_POSITION;  
    26.                 float2 tex : TEXCOORD0;  
    27.                 float4 srcPos : TEXCOORD1;  
    28.                 float3 col : COLOR;  
    29.             };  
    30.             vertexOutput vert(appdata_full input)  
    31.             {  
    32.                 vertexOutput output;  
    33.                 output.pos = mul(UNITY_MATRIX_MVP, input.vertex);  
    34.                 output.tex = input.texcoord;  
    35.                 output.srcPos = input.vertex;  
    36.   
    37.                 float3 viewDir = normalize(ObjSpaceViewDir(input.vertex));  
    38.                 float dotProduct = 1 - saturate(dot(input.normal, viewDir));  
    39.                 //output.col = _RimColor.rgb * pow(dotProduct, _RimPower);  
    40.                 float rimWidth = 0.7;  
    41.                 output.col.rgb = smoothstep(1 - rimWidth, 1.0, dotProduct);  
    42.                 output.col *= _RimColor;  
    43.                 return output;  
    44.             }  
    45.             float4 frag(vertexOutput input) : COLOR  
    46.             {  
    47.                 float4 a = float4(input.col, 1);  
    48.                 float4 b = tex2D(_MainTex, input.tex);  
    49.                 float4 c = a + b;  
    50.                 return c;  
    51.             }  
    52.             ENDCG  
    53.         }  
    54.     }  
    55.     FallBack "Diffuse"  
    56. }  


    4.遮挡高光

    [csharp]  view plain  copy
    1. Shader "Custom/New" {  
    2.     Properties  
    3.     {  
    4.         _MainTex("Base (RGB)", 2D) = "white" {}  
    5.         _RimColor("RimColor(RGB)", Color) = (1, 1, 1, 1)  
    6.         _RimPower("RimPower", float) = 1  
    7.     }  
    8.     SubShader  
    9.     {  
    10.         Pass  
    11.         {  
    12.             //Blend SrcAlpha OneMinusSrcAlpha  
    13.             Blend One One  
    14.             ZTest Greater  
    15.   
    16.             CGPROGRAM  
    17.             #pragma vertex vert     
    18.             #pragma fragment frag      
    19.             #include "UnityCG.cginc"  
    20.   
    21.             sampler2D _MainTex;  
    22.             float4 _RimColor;  
    23.             float _RimPower;  
    24.   
    25.             struct vertexOutput  
    26.             {  
    27.                 float4 pos : SV_POSITION;  
    28.                 float2 tex : TEXCOORD0;  
    29.                 float4 srcPos : TEXCOORD1;  
    30.                 float3 col : COLOR;  
    31.             };  
    32.             vertexOutput vert(appdata_full input)  
    33.             {  
    34.                 vertexOutput output;  
    35.                 output.pos = mul(UNITY_MATRIX_MVP, input.vertex);  
    36.                 output.tex = input.texcoord;  
    37.                 output.srcPos = input.vertex;  
    38.   
    39.                 float3 viewDir = normalize(ObjSpaceViewDir(input.vertex));  
    40.                 float dotProduct = 1 - saturate(dot(input.normal, viewDir));  
    41.                 //output.col = _RimColor.rgb * pow(dotProduct, _RimPower);  
    42.                 float rimWidth = 0.7;  
    43.                 output.col.rgb = smoothstep(1 - rimWidth, 1.0, dotProduct);  
    44.                 output.col *= _RimColor;  
    45.                 return output;  
    46.             }  
    47.             float4 frag(vertexOutput input) : COLOR  
    48.             {  
    49.                 float4 a = float4(input.col, 1);  
    50.                 return a * 2;  
    51.             }  
    52.             ENDCG  
    53.         }  
    54.         Pass  
    55.         {  
    56.             ZTest Less  
    57.             SetTexture[_MainTex]{}  
    58.         }  
    59.     }  
    60.     FallBack "Diffuse"  
    61. }  


    1.模型自身坐标位置与颜色的映射

    [csharp]  view plain  copy
    1. Shader "Custom/RGBCube" {    
    2.     SubShader     
    3.     {    
    4.         Pass {    
    5.         CGPROGRAM    
    6.         #pragma vertex vert //顶点着色器入口函数声明    
    7.         #pragma fragment frag // 片段着色器入口函数声明    
    8.         //顶点输出结构体    
    9.         struct vertexOutput {    
    10.             //声明结构体的成员pos,类型为float类型的4元向量，语义为SV_POSITION,col同理;    
    11.             float4 pos : SV_POSITION;    
    12.             float4 col : TEXCOORD0;    
    13.         };    
    14.         //顶点着色器入口函数vert，与pragma第一条声明匹配，返回类型为刚刚定义的顶点输出结构体    
    15.         vertexOutput vert(float4 vertexPos : POSITION)    
    16.             
    17.         {    
    18.             vertexOutput output; //这里不需要struct关键字    
    19.             //顶点着色器将数据写入输出结构体中。    
    20.             output.pos = mul(UNITY_MATRIX_MVP, vertexPos);    
    21.             //mul是顶点变换函数，UNITY_MATRIX_MVP是unity的内建矩阵，vertexPos是这个函数的形参    
    22.             //此行代码的作用为将形参vertexPos（本例即Cube对象的顶点向量）按照unity的内建矩阵进行顶点变换    
    23.             output.col = vertexPos + float4(0.5, 0.5, 0.5, 0.0);    
    24.             //这行代码是实现RGB立方体的关键    
    25.             //因为我们的直角坐标系原点没有在顶点上而是在cube的几何中心，故其值域为{-0,5,-0.5,-0.5,1}至{0.5,0.5,0.5,1}    
    26.             //但是这里接受的类型为float4，可见第四元应该是无意义的常数1    
    27.             //意思是vertexPos的值域为{-0.5,-0.5,-0.5,1}至{0.5,0.5,0.5,1}    
    28.             //而对这个值域进行+{0.5,0.5,0.5,0}的矢量相加才能得到RGB （A恒定为1）的所有颜色区间    
    29.                 
    30.             return output;    
    31.             //将输出结构体返回，进入下一个环节(简单理解为给片段着色器)    
    32.             //ps:更细致的环节有顶点变换-->顶点着色-->几何元的构建-->光栅化几何元    
    33.             //-->片段着色-->略    
    34.         }    
    35.         //片段着色器入口函数frag，与pragma第二条声明匹配，返回类型为float4语义为COLOR,    
    36.         //这里除了颜色没有其他的输出，所以没有输出结构体    
    37.         float4 frag(vertexOutput input) : COLOR     
    38.         //此函数的形参类型为顶点着色器的输出结构体，没有语义    
    39.         //原因就在于片段着色器位于顶点着色器的下一个环节，参数按照这个顺序传递    
    40.         {    
    41.             //由于col属性已经在顶点着色器中计算，直接返回进入下一环节    
    42.             //下一环节是什么这里不探讨了    
    43.             return input.col;    
    44.         }    
    45.         ENDCG    
    46.         }    
    47.     }    
    48.     //如果以上SubShader渲染失败则回滚采用Diffuse    
    49.     FallBack "Diffuse"    
    50. }  


    2.模型纹理坐标与颜色的映射

    [csharp]  view plain  copy
    1. Shader "Custom/RGBCube" {    
    2.     SubShader     
    3.     {    
    4.         Pass{  
    5.         CGPROGRAM    
    6.         #pragma vertex vert    
    7.         #pragma fragment frag    
    8.         #include "UnityCG.cginc"    
    9.         struct vertexOutput {    
    10.         float4 pos : SV_POSITION;    
    11.         float4 col : TEXCOORD0;    
    12.         };    
    13.         vertexOutput vert(appdata_full input)    
    14.         {    
    15.             vertexOutput output;    
    16.             output.pos = mul(UNITY_MATRIX_MVP, input.vertex);    
    17.             output.col = input.texcoord;    
    18.             return output;    
    19.         }    
    20.         float4 frag(vertexOutput input) : COLOR    
    21.         {    
    22.             return input.col;    
    23.         }    
    24.         ENDCG}     
    25.     }    
    26.     //如果以上SubShader渲染失败则回滚采用Diffuse    
    27.     FallBack "Diffuse"    
    28. }  


    3.假彩色效果

    [csharp]  view plain  copy
    1. Shader "Custom/RGBCube" {    
    2.     SubShader     
    3.     {    
    4.         Pass{  
    5.         CGPROGRAM    
    6.         #pragma vertex vert    
    7.         #pragma fragment frag    
    8.         #include "UnityCG.cginc"    
    9.         struct vertexOutput {    
    10.         float4 pos : SV_POSITION;    
    11.         float4 col : TEXCOORD0;    
    12.         };    
    13.         vertexOutput vert(appdata_full input)    
    14.         {    
    15.             vertexOutput output;    
    16.             output.pos = mul(UNITY_MATRIX_MVP, input.vertex);    
    17.             output.col = float4(0.0, input.texcoord.y, 0.0, 1.0);    
    18.             return output;    
    19.         }    
    20.         float4 frag(vertexOutput input) : COLOR    
    21.         {    
    22.             return input.col;    
    23.         }    
    24.         ENDCG}     
    25.     }    
    26.     //如果以上SubShader渲染失败则回滚采用Diffuse    
    27.     FallBack "Diffuse"    
    28. }  


    4.法向量与颜色的映射

    [csharp]  view plain  copy
    1. Shader "Custom/RGBCube" {    
    2.     SubShader     
    3.     {    
    4.         Pass{  
    5.         CGPROGRAM    
    6.         #pragma vertex vert    
    7.         #pragma fragment frag    
    8.         #include "UnityCG.cginc"    
    9.         struct vertexOutput {    
    10.         float4 pos : SV_POSITION;    
    11.         float4 col : TEXCOORD0;    
    12.         };    
    13.         vertexOutput vert(appdata_full input)    
    14.         {    
    15.             vertexOutput output;    
    16.             output.pos = mul(UNITY_MATRIX_MVP, input.vertex);    
    17.             output.col = float4((input.normal + float3(1.0, 1.0, 1.0)) / 2.0, 1.0);   
    18.             return output;    
    19.         }    
    20.         float4 frag(vertexOutput input) : COLOR    
    21.         {    
    22.             return input.col;    
    23.         }    
    24.         ENDCG}     
    25.     }    
    26.     //如果以上SubShader渲染失败则回滚采用Diffuse    
    27.     FallBack "Diffuse"    
    28. }  


    5.裁剪效果

    [csharp]  view plain  copy
    1. Shader "Custom/RGBCube" {    
    2.     SubShader     
    3.     {    
    4.         Pass{    
    5.         Cull Off // 关掉裁剪模式，作用后面再说    
    6.         CGPROGRAM    
    7.         #pragma vertex vert    
    8.         #pragma fragment frag    
    9.         #include "UnityCG.cginc"    
    10.         struct vertexOutput {    
    11.             float4 pos : SV_POSITION;    
    12.             //由顶点着色器输出mesh信息中的纹理坐标，这个坐标是以对象为坐标系的    
    13.             float4 posInObjectCoords : TEXCOORD0;    
    14.         };    
    15.         vertexOutput vert(appdata_full input)    
    16.         {    
    17.             vertexOutput output;    
    18.             output.pos = mul(UNITY_MATRIX_MVP, input.vertex);    
    19.             //直接把texcoord传递给片段着色器    
    20.             output.posInObjectCoords = input.texcoord;    
    21.             return output;    
    22.         }    
    23.         float4 frag(vertexOutput input) : COLOR    
    24.         {    
    25.             //当坐标的y值大于0.5的时候擦除片段    
    26.             if (input.posInObjectCoords.y > 0.5)    
    27.             {    
    28.                 discard;     
    29.             }    
    30.                 
    31.             //其余部分仍然按y值大小生成经度绿色球    
    32.             return float4(0.0, input.posInObjectCoords.y , 0.0, 1.0);     
    33.         }    
    34.         ENDCG    
    35.         }    
    36.     }    
    37.     //如果以上SubShader渲染失败则回滚采用Diffuse    
    38.     FallBack "Diffuse"    
    39. }  


    6.内部裁剪与外部裁剪

    [csharp]  view plain  copy
    1. Shader "Custom/RGBCube" {    
    2.     SubShader     
    3.     {    
    4.         Pass{    
    5.         Cull front // 外部剪裁，那么这个通道可以理解为是给篮球的内表面上色    
    6.         CGPROGRAM    
    7.         #pragma vertex vert    
    8.         #pragma fragment frag    
    9.         #include "UnityCG.cginc"    
    10.         struct vertexOutput {    
    11.             float4 pos : SV_POSITION;    
    12.             //由顶点着色器输出mesh信息中的纹理坐标，这个坐标是以对象为坐标系的    
    13.             float4 posInObjectCoords : TEXCOORD0;    
    14.         };    
    15.         vertexOutput vert(appdata_full input)    
    16.         {    
    17.             vertexOutput output;    
    18.             output.pos = mul(UNITY_MATRIX_MVP, input.vertex);    
    19.             //直接把texcoord传递给片段着色器    
    20.             output.posInObjectCoords = input.texcoord;    
    21.             return output;    
    22.         }    
    23.         float4 frag(vertexOutput input) : COLOR    
    24.         {    
    25.             //当坐标的y值大于0.5的时候擦除片段    
    26.             if (input.posInObjectCoords.y > 0.5)    
    27.             {    
    28.                 discard;     
    29.             }    
    30.                 
    31.             //其余部分仍然按y值大小生成经度绿色球    
    32.             return float4(0.0, input.posInObjectCoords.y , 0.0, 1.0);     
    33.         }    
    34.         ENDCG    
    35.         }     
    36.             
    37.         Pass{    
    38.         Cull back //内部剪裁，那么这个通道可以理解为是给篮球的外表面上色    
    39.         CGPROGRAM    
    40.         #pragma vertex vert    
    41.         #pragma fragment frag    
    42.         #include "UnityCG.cginc"    
    43.         struct vertexOutput {    
    44.             float4 pos : SV_POSITION;    
    45.             //由顶点着色器输出mesh信息中的纹理坐标，这个坐标是以对象为坐标系的    
    46.             float4 posInObjectCoords : TEXCOORD0;    
    47.         };    
    48.         vertexOutput vert(appdata_full input)    
    49.         {    
    50.             vertexOutput output;    
    51.             output.pos = mul(UNITY_MATRIX_MVP, input.vertex);    
    52.             //直接把texcoord传递给片段着色器    
    53.             output.posInObjectCoords = input.texcoord;    
    54.             return output;    
    55.         }    
    56.         float4 frag(vertexOutput input) : COLOR    
    57.         {    
    58.             //当坐标的y值大于0.5的时候擦除片段    
    59.             if (input.posInObjectCoords.y > 0.5)    
    60.             {    
    61.                 discard;     
    62.             }    
    63.                 
    64.             //其余部分仍然按y值大小生成经度红色球    
    65.             return float4(input.posInObjectCoords.y, 0.0 , 0.0, 1.0);     
    66.         }    
    67.         ENDCG    
    68.         }     
    69.     }    
    70.     //如果以上SubShader渲染失败则回滚采用Diffuse    
    71.     FallBack "Diffuse"    
    72. }  


    7.圆角矩形

    [csharp]  view plain  copy
    1. Shader "Custom/RoundRect" {    
    2.     Properties {    
    3.         //两种内容模式，图片模式    
    4.         _MainTex ("Base (RGB)", 2D) = "white" {}    
    5.         //纯色模式    
    6.         //_MainColor ("Color", COLOR) = (1,1,1,1)    
    7.         //圆角半径，默认为0.1    
    8.         _Radius("Radius",float) = 0.1    
    9.     }    
    10.     SubShader {    
    11.             
    12.         Pass{    
    13.             CGPROGRAM    
    14.             #pragma vertex vert   
    15.             #pragma fragment frag    
    16.               
    17.             #include "UnityCG.cginc"    
    18.             //获取3个属性 并传值到CG代码段    
    19.             sampler2D _MainTex;    
    20.             float _Radius;  
    21.             float4 _MainColor;    
    22.                 
    23.             struct vertexOutput {  
    24.                 float4 pos : SV_POSITION;  
    25.                 //由顶点着色器输出mesh信息中的纹理坐标，这个坐标是以对象为坐标系的    
    26.                 float4 posInObjectCoords : TEXCOORD0;  
    27.             };  
    28.             vertexOutput vert(appdata_full input)  
    29.             {  
    30.                 vertexOutput output;  
    31.                 output.pos = mul(UNITY_MATRIX_MVP, input.vertex);  
    32.                 //直接把texcoord传递给片段着色器    
    33.                 output.posInObjectCoords = input.texcoord;  
    34.                 return output;  
    35.             }  
    36.     
    37.             //片段着色器入口函数    
    38.             float4 frag(vertexOutput input) : COLOR  
    39.             {            
    40.                 float4 c = tex2D(_MainTex, input.posInObjectCoords);//将图片信息按坐标转换成颜色    
    41.                 //float4 c=_MainColor;  //纯色    
    42.                     
    43.                 //x,y两个变元，区间均为[0,1]    
    44.                 float x = input.posInObjectCoords.x;  
    45.                 float y = input.posInObjectCoords.y;  
    46.                     
    47.                 if (x < _Radius && y < _Radius)  
    48.                 {  
    49.                     if (pow((x - _Radius), 2) + pow(y - _Radius, 2) > pow(_Radius, 2))  
    50.                         discard;  
    51.                 }  
    52.                 else if (x < _Radius && y > (1 - _Radius))  
    53.                 {  
    54.                     if (pow((x - _Radius), 2) + pow(y - (1 - _Radius), 2) > pow(_Radius, 2))  
    55.                         discard;  
    56.                 }  
    57.                 else if (x > (1 - _Radius) && y < _Radius)  
    58.                 {  
    59.                     if (pow((x - (1 - _Radius)), 2) + pow(y - _Radius, 2) > pow(_Radius, 2))  
    60.                         discard;  
    61.                 }  
    62.                 else if (x > (1 - _Radius) && y > (1 - _Radius))  
    63.                 {  
    64.                     if (pow((x - (1 - _Radius)), 2) + pow(y - (1 - _Radius), 2) > pow(_Radius, 2))  
    65.                         discard;  
    66.                 }  
    67.                 return c;    
    68.             }    
    69.             ENDCG  
    70.         }    
    71.     }     
    72.     FallBack "Diffuse"    
    73. }  


    8.漫反射

    [csharp]  view plain  copy
    1. Shader "Esfog/Diffuse"   
    2. {  
    3.     Properties   
    4.     {  
    5.         _MainTex ("Base (RGB)", 2D) = "white" {}  
    6.     }  
    7.     SubShader   
    8.     {  
    9.         Pass  
    10.         {  
    11.             Tags { "RenderType"="Opaque" "LightMode"="ForwardBase"}  
    12.             CGPROGRAM  
    13.             #pragma vertex vert  
    14.             #pragma fragment frag  
    15.             #include "UnityCG.cginc"  
    16.   
    17.             uniform sampler2D _MainTex;  
    18.             uniform float4    _LightColor0;  
    19.             struct VertexOutput   
    20.             {  
    21.                 float4 pos:SV_POSITION;  
    22.                 float2 uv_MainTex:TEXCOORD0;  
    23.                 float3 normal:TEXCOORD1;  
    24.             };  
    25.   
    26.             VertexOutput vert(appdata_base input)  
    27.             {  
    28.                 VertexOutput o;  
    29.                 o.pos = mul(UNITY_MATRIX_MVP,input.vertex);  
    30.                 o.uv_MainTex = input.texcoord.xy;  
    31.                 o.normal = normalize(mul(float4(input.normal,0),_World2Object));  
    32.                 return o;  
    33.             }  
    34.   
    35.             float4 frag(VertexOutput input):COLOR  
    36.             {  
    37.                 float3 normalDir = normalize(input.normal);  
    38.                 float3 lightDir = normalize(_WorldSpaceLightPos0.xyz);  
    39.                 float3 Kd = tex2D(_MainTex,input.uv_MainTex).xyz;  
    40.                 float3 diffuseReflection = Kd * _LightColor0.rgb * max(0,dot(normalDir,lightDir));  
    41.                 return float4(diffuseReflection,1);  
    42.             }  
    43.             ENDCG  
    44.         }  
    45.     }   
    46.     FallBack "Diffuse"  
    47. }  


    9.多光源漫反射

    [csharp]  view plain  copy
    1. Shader "Esfog/Diffuse"   
    2. {  
    3.     Properties   
    4.     {  
    5.         _MainTex ("Base (RGB)", 2D) = "white" {}  
    6.     }  
    7.     SubShader   
    8.     {  
    9.         Pass  
    10.         {  
    11.             Tags { "RenderType"="Opaque" "LightMode"="ForwardBase"}  
    12.             CGPROGRAM  
    13.             #pragma vertex vert  
    14.             #pragma fragment frag  
    15.             #include "UnityCG.cginc"  
    16.   
    17.             uniform sampler2D _MainTex;  
    18.             uniform float4    _LightColor0;  
    19.             struct VertexOutput   
    20.             {  
    21.                 float4 pos:SV_POSITION;  
    22.                 float2 uv_MainTex:TEXCOORD0;  
    23.                 float3 normal:TEXCOORD1;  
    24.             };  
    25.   
    26.             VertexOutput vert(appdata_base input)  
    27.             {  
    28.                 VertexOutput o;  
    29.                 o.pos = mul(UNITY_MATRIX_MVP,input.vertex);  
    30.                 o.uv_MainTex = input.texcoord.xy;  
    31.                 o.normal = normalize(mul(float4(input.normal,0),_World2Object));  
    32.                 return o;  
    33.             }  
    34.   
    35.             float4 frag(VertexOutput input):COLOR  
    36.             {  
    37.                 float3 normalDir = normalize(input.normal);  
    38.                 float3 lightDir = normalize(_WorldSpaceLightPos0.xyz);  
    39.                 float3 Kd = tex2D(_MainTex,input.uv_MainTex).xyz;  
    40.                 float3 diffuseReflection = Kd * _LightColor0.rgb * max(0,dot(normalDir,lightDir));  
    41.                 return float4(diffuseReflection,1);  
    42.             }  
    43.             ENDCG  
    44.         }  
    45.   
    46.         Pass  
    47.         {  
    48.             Tags { "RenderType"="Opaque" "LightMode"="ForwardAdd"}  
    49.   
    50.             //此通道的片段着色器输出颜色时帧缓存已经有了颜色，所以需要混合    
    51.             //混合模式为1比1            
    52.             Blend One One   
    53.   
    54.             CGPROGRAM  
    55.             #pragma vertex vert  
    56.             #pragma fragment frag  
    57.             #include "UnityCG.cginc"  
    58.   
    59.             uniform sampler2D _MainTex;  
    60.             uniform float4    _LightColor0;  
    61.             struct VertexOutput   
    62.             {  
    63.                 float4 pos:SV_POSITION;  
    64.                 float2 uv_MainTex:TEXCOORD0;  
    65.                 float3 normal:TEXCOORD1;  
    66.             };  
    67.   
    68.             VertexOutput vert(appdata_base input)  
    69.             {  
    70.                 VertexOutput o;  
    71.                 o.pos = mul(UNITY_MATRIX_MVP,input.vertex);  
    72.                 o.uv_MainTex = input.texcoord.xy;  
    73.                 o.normal = normalize(mul(float4(input.normal,0),_World2Object));  
    74.                 return o;  
    75.             }  
    76.   
    77.             float4 frag(VertexOutput input):COLOR  
    78.             {  
    79.                 float3 normalDir = normalize(input.normal);  
    80.                 float3 lightDir = normalize(_WorldSpaceLightPos0.xyz);  
    81.                 float3 Kd = tex2D(_MainTex,input.uv_MainTex).xyz;  
    82.                 float3 diffuseReflection = Kd * _LightColor0.rgb * max(0,dot(normalDir,lightDir));  
    83.                 return float4(diffuseReflection,1);  
    84.             }  
    85.             ENDCG  
    86.         }  
    87.     }   
    88.     FallBack "Diffuse"  
    89. }  


    10.逐顶点的镜面反射
  • 相关阅读:
    从坐标系图中理解“空间变换”
    Normal Map中的值， Tangent Space， 求算 Tangent 与 Binormal 与 TBN Matrix
    A Personal Understanding to Matrix Transformation in Graphics
    [转] 双数组前缀树
    [转] Hive简介
    [转] 远程访问服务器Jupyter Notebook的两种方法
    [转] LSTM中的pack和pad
    [转] Beam Search
    [转] linux提示符过长tips
    [转] batch normalization相关
  • 原文地址：https://www.cnblogs.com/jrmy/p/14316290.html
Copyright © 2011-2022 走看看