BumpSpecModulate

From Unify Community Wiki
Revision as of 19:26, 19 October 2009 by NCarter (Talk | contribs)

Jump to: navigation, search

Description

Use this shader to have a bump mapped mesh that modulates between original texture color and "alpha color" based on alpha of main texture.

Usage

Place this shader somewhere in your Assets folder hierarchy, and assign it to a new material with the properties of your choice. Then assign the material to a mesh by dragging the material to the mesh.

ShaderLab - BumpedSpecModulate.shader

<shaderlab> Shader "BumpedSpecularModulate" { Properties {

   _Color ("Main Color", Color) = (1,1,1,0.5)
   _Color2 ("Alpha Color", Color) = (0.5, 0.5, 0.5, 0.5)
   _SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
   _Shininess ("Shininess", Range (0.03, 1)) = 0.078125
   _MainTex ("Base (RGB) Gloss (A)", 2D) = "white" {}
   _BumpMap ("Bumpmap (RGB)", 2D) = "bump" {}

} Category {

   Blend AppSrcAdd AppDstAdd
   Fog { Color [_AddFog] }
   
   // ------------------------------------------------------------------
   // ARB fragment program
   
   SubShader { 
       UsePass " Glossy/BASE"
       
       // Pixel lights
       Pass { 
           Name "PPL"  
           Tags {
               "LightMode" = "Pixel" 
               "LightTexCount" = "012"
           }

CGPROGRAM // profiles arbfp1 // fragment frag // fragmentoption ARB_fog_exp2 // fragmentoption ARB_precision_hint_fastest // vertex vert // autolight 7

  1. include "UnityCG.cginc"
  2. include "AutoLight.cginc"

struct v2f {

   V2F_POS_FOG;
   float3  uvK         : TEXCOORD0; // xy = UV, z = specular K
   float2  uv2         : TEXCOORD1;
   float3  viewDirT    : TEXCOORD2;
   float3  lightDirT   : TEXCOORD3;
   V2F_LIGHT_COORDS(TEXCOORD4);

}; struct v2f2 {

   V2F_POS_FOG;
   float3  uvK         : TEXCOORD0; // xy = UV, z = specular K
   float2  uv2         : TEXCOORD1;
   float3  viewDirT    : TEXCOORD2;
   float3  lightDirT   : TEXCOORD3;

};

uniform float _Shininess;


v2f vert (appdata_tan v) {

   v2f o;
   PositionFog( v.vertex, o.pos, o.fog );
   o.uvK.xy = TRANSFORM_UV(1);
   o.uvK.z = _Shininess * 128;
   o.uv2 = TRANSFORM_UV(0);
   TANGENT_SPACE_ROTATION;
   o.lightDirT = mul( rotation, ObjSpaceLightDir( v.vertex ) );    
   o.viewDirT = mul( rotation, ObjSpaceViewDir( v.vertex ) );  
   
   PASS_LIGHT_COORDS(2);
   return o;

}

uniform sampler2D _BumpMap : register(s0); uniform sampler2D _MainTex : register(s1);

uniform float4 _SpecColor; uniform float4 _Color2;

float4 frag (v2f2 i, LIGHTDECL(TEXUNIT2))  : COLOR {

   float4 texcol = tex2D( _MainTex, i.uvK.xy );
   // lerp between AlphaColor and texture color based on alpha
   texcol.rgb = lerp( _Color2.rgb, texcol.rgb, texcol.a );
   
   // get normal from the normal map
   float3 normal = tex2D(_BumpMap, i.uv2).xyz * 2.0 - 1.0;
   
   half4 c = SpecularLight( i.lightDirT, i.viewDirT, normal, texcol, i.uvK.z, LIGHTATT );
   return c;

} ENDCG

           SetTexture [_BumpMap] {combine texture}
           SetTexture [_MainTex] {combine texture}
           SetTexture [_LightTexture0] {combine texture} 
           SetTexture [_LightTextureB0] {combine texture}
       }
   }
   
   // ------------------------------------------------------------------
   // Radeon 9000
   
   SubShader {
       UsePass " Glossy/BASE"
       
       // Pixel lights with 0 light textures
       Pass {
           Name "PPL"
           Tags {
               "LightMode" = "Pixel"
               "LightTexCount" = "0"
           }

CGPROGRAM // vertex vert

  1. include "unityCG.cginc"

struct v2f {

   V2F_POS_FOG;
   float2 uv       : TEXCOORD0;
   float2 uv2      : TEXCOORD3;
   float3 lightDirT: TEXCOORD2;
   float3 halfDirT : TEXCOORD1; 

};

v2f vert(appdata_tan v) {

   v2f o;
   PositionFog( v.vertex, o.pos, o.fog );
   o.uv = TRANSFORM_UV(0);
   o.uv2 = TRANSFORM_UV(3);
   
   TANGENT_SPACE_ROTATION;
   o.lightDirT = mul( rotation, ObjSpaceLightDir( v.vertex ) );
   float3 viewDirT = mul( rotation, ObjSpaceViewDir( v.vertex ) );
   o.halfDirT = normalize( normalize(o.lightDirT) + normalize(viewDirT) );
   
   return o;

} ENDCG

           Program "" {
               SubProgram {
                   Local 0, [_SpecularLightColor0]
                   Local 1, [_ModelLightColor0]
                   Local 2, (0,[_Shininess],0,1)
                   Local 3, [_Color2]

"!!ATIfs1.0 StartConstants;

   CONSTANT c0 = program.local[0];
   CONSTANT c1 = program.local[1];
   CONSTANT c2 = program.local[2];
   CONSTANT c3 = program.local[3];

EndConstants;

StartPrelimPass;

   SampleMap r3, t3.str;           # normal
   SampleMap r2, t2.str;           # normalized light dir
   PassTexCoord r4, t1.str;        # half dir
   
   DOT3 r5.sat, r3.bias.2x, r2.bias.2x;    # diffuse (N.L)
   
   # Compute lookup UVs into specular falloff texture.
   # Normally it would be: r=sat(N.H), g=_Shininess*0.5
   # However, we'll use projective read on this to automatically
   # normalize H. Gives better precision in highlight.
   DOT3 r1.sat, r3.bias.2x, r4;    # N.H
   MUL  r1, r1, r1;                # (N.H)^2
   DOT3 r1.b.sat, r4, r4;          # .b = |H|^2
   MUL  r1.g, r1.b, c2.g;          # .g = |H|^2 * k

EndPass;

StartOutputPass;

   SampleMap r0, t0.str;           # main texture
   SampleMap r1, r1.str_dr;        # .a = specular (projective to normalize H)
   PassTexCoord r5, r5.str;        # diffuse
   
   LERP r0.rgb, r0.a, r0, c3;      # lerp between texture and color2
   MUL r1, r1.a, r5.b;
   MUL r5.rgb, r5, c1;             # modelLightColor.rgb * diffuse
   MUL r5.rgb, r5, r0;             # * texture
   MUL r1, r1, r0.a;               # spec *= gloss
   MUL r2, r1.a, c0;               # specColor * spec
   ADD r0.rgb.2x, r5, r2;          # (diff+spec)*2
   MOV r0.a, r2;

EndPass; "

               }
           }
           SetTexture[_MainTex] {combine texture}
           SetTexture[_SpecFalloff] {combine texture}
           SetTexture[_CubeNormalize] {combine texture}
           SetTexture[_BumpMap] {combine texture}
       }
       // Pixel lights with 1 light texture
       Pass {
           Name "PPL"
           Tags {
               "LightMode" = "Pixel"
               "LightTexCount" = "1"
           }

CGPROGRAM // vertex vert

  1. include "unityCG.cginc"

struct v2f {

   V2F_POS_FOG;
   float2 uv       : TEXCOORD0;
   float2 uv2      : TEXCOORD4;
   float3 lightDirT: TEXCOORD3;
   float3 halfDirT : TEXCOORD2;
   float4 LightCoord0 : TEXCOORD1;

};

v2f vert(appdata_tan v) {

   v2f o;
   PositionFog( v.vertex, o.pos, o.fog );
   o.uv = TRANSFORM_UV(0);
   o.uv2 = TRANSFORM_UV(4);
   
   TANGENT_SPACE_ROTATION;
   o.lightDirT = mul( rotation, ObjSpaceLightDir( v.vertex ) );
   float3 viewDirT = mul( rotation, ObjSpaceViewDir( v.vertex ) );
   o.halfDirT = normalize( normalize(o.lightDirT) + normalize(viewDirT) );
   
   o.LightCoord0 = LIGHT_COORD(1);
   
   return o;

} ENDCG

       Program "" {
           SubProgram {
               Local 0, [_SpecularLightColor0]
               Local 1, [_ModelLightColor0]
               Local 2, (0,[_Shininess],0,1)
               Local 3, [_Color2]

"!!ATIfs1.0 StartConstants;

   CONSTANT c0 = program.local[0];
   CONSTANT c1 = program.local[1];
   CONSTANT c2 = program.local[2];
   CONSTANT c3 = program.local[3];

EndConstants;

StartPrelimPass;

   SampleMap r4, t4.str;           # normal
   SampleMap r3, t3.str;           # normalized light dir
   PassTexCoord r1, t2.str;        # half dir
   
   DOT3 r5.sat, r4.bias.2x, r3.bias.2x;    # diffuse (N.L)
   
   # Compute lookup UVs into specular falloff texture.
   # Normally it would be: r=sat(N.H), g=_Shininess*0.5
   # However, we'll use projective read on this to automatically
   # normalize H. Gives better precision in highlight.
   DOT3 r2.sat, r4.bias.2x, r1;    # N.H
   MUL  r2, r2, r2;                # (N.H)^2
   DOT3 r2.b.sat, r1, r1;          # .b = |H|^2
   MUL  r2.g, r2.b, c2.g;          # .g = |H|^2 * k

EndPass;

StartOutputPass;

   SampleMap r0, t0.str;           # main texture
   SampleMap r1, t1.str;           # .a = attenuation
   SampleMap r2, r2.str_dr;        # .a = specular (projective to normalize H)
   PassTexCoord r5, r5.str;        # diffuse
   
   LERP r0.rgb, r0.a, r0, c3;      # lerp between texture and color2
   MUL r2, r2.a, r5.b;
   MUL r5.rgb, r5, c1;             # modelLightColor.rgb * diffuse
   MUL r5.rgb, r5, r0;             # * texture
   MUL r2, r2, r0.a;               # spec *= gloss
   MUL r3, r2.a, c0;               # specColor * spec
   ADD r0.rgb.2x, r5, r3;          # (diff+spec)*2
   MOV r0.a, r3;
   MUL r0, r0, r1.a;

EndPass; "

               }
           }
           SetTexture[_MainTex] {combine texture}
           SetTexture[_LightTexture0] {combine texture}
           SetTexture[_SpecFalloff] {combine texture}
           SetTexture[_CubeNormalize] {combine texture}
           SetTexture[_BumpMap] {combine texture}
       }
       
       // Pixel lights with 2 light textures
       Pass {
           Name "PPL"
           Tags {
               "LightMode" = "Pixel"
               "LightTexCount" = "2"
           }

CGPROGRAM // vertex vert

  1. include "unityCG.cginc"

struct v2f {

   V2F_POS_FOG;
   float2 uv       : TEXCOORD0;
   float2 uv2      : TEXCOORD5;
   float3 lightDirT: TEXCOORD3;
   float3 halfDirT : TEXCOORD2;
   float4 LightCoord0 : TEXCOORD1;
   float4 LightCoordB0 : TEXCOORD4;

};

v2f vert(appdata_tan v) {

   v2f o;
   PositionFog( v.vertex, o.pos, o.fog );
   o.uv = TRANSFORM_UV(0);
   o.uv2 = TRANSFORM_UV(5);
   
   TANGENT_SPACE_ROTATION;
   o.lightDirT = mul( rotation, ObjSpaceLightDir( v.vertex ) );
   float3 viewDirT = mul( rotation, ObjSpaceViewDir( v.vertex ) );
   o.halfDirT = normalize( normalize(o.lightDirT) + normalize(viewDirT) );
   
   o.LightCoord0 = LIGHT_COORD(1);
   o.LightCoordB0 = LIGHT_COORD(4);
   
   return o;

} ENDCG

           Program "" {
               SubProgram {
                   Local 0, [_SpecularLightColor0]
                   Local 1, [_ModelLightColor0]
                   Local 2, (0,[_Shininess],0,1)
                   Local 3, [_Color2]

"!!ATIfs1.0 StartConstants;

   CONSTANT c0 = program.local[0];
   CONSTANT c1 = program.local[1];
   CONSTANT c2 = program.local[2];
   CONSTANT c3 = program.local[3];

EndConstants;

StartPrelimPass;

   SampleMap r5, t5.str;           # normal
   SampleMap r3, t3.str;           # normalized light dir
   PassTexCoord r1, t2.str;        # half dir
   
   DOT3 r3.sat, r5.bias.2x, r3.bias.2x;    # diffuse (N.L)
   
   # Compute lookup UVs into specular falloff texture.
   # Normally it would be: r=sat(N.H), g=_Shininess*0.5
   # However, we'll use projective read on this to automatically
   # normalize H. Gives better precision in highlight.
   DOT3 r2.sat, r5.bias.2x, r1;    # N.H
   MUL  r2, r2, r2;                # (N.H)^2
   DOT3 r2.b.sat, r1, r1;          # .b = |H|^2
   MUL  r2.g, r2.b, c2.g;          # .g = |H|^2 * k
   
   MUL r4, r3, c1;

EndPass;

StartOutputPass;

   SampleMap r0, t0.str;           # main texture
   SampleMap r1, t1.stq_dq;        # .a = attenuation
   SampleMap r2, r2.str_dr;        # .a = specular (projective to normalize H)
   SampleMap r4, t4.stq_dq;        # .a = attenuation
   PassTexCoord r3, r3.str;        # diffuse
   PassTexCoord r5, r4.str;        # diffuse * modelLightColor
   
   LERP r0.rgb, r0.a, r0, c3;      # lerp between texture and color2
   MUL r5.rgb, r5, r0;             # * texture
   MUL r2, r2.a, r3.b;
   MUL r2, r2, r0.a;               # spec *= gloss
   MUL r3, r2.a, c0;               # specColor * spec
   ADD r0.rgb.2x, r5, r3;          # (diff+spec)*2
   MOV r0.a, r3;
   MUL r0, r0, r1.a;
   MUL r0, r0, r4.a;

EndPass; "

               }
           }
           SetTexture[_MainTex] {combine texture}
           SetTexture[_LightTexture0] {combine texture}
           SetTexture[_SpecFalloff] {combine texture}
           SetTexture[_CubeNormalize] {combine texture}
           SetTexture[_LightTextureB0] {combine texture}
           SetTexture[_BumpMap] {combine texture}
       }   
   }

}

FallBack " VertexLit", 1 } </shaderlab>

Personal tools
Namespaces

Variants
Actions
Navigation
Extras
Toolbox