[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.逐顶点的镜面反射


posted on 2017-08-24 18:57  仗帅闯江湖  阅读(192)  评论(0)  编辑  收藏  举报

导航