• Products
  • Solutions
  • Made with Unity
  • Learning
  • Support & Services
  • Community
  • Asset Store
  • Get Unity

UNITY ACCOUNT

You need a Unity Account to shop in the Online and Asset Stores, participate in the Unity Community and manage your license portfolio. Login Create account
  • Blog
  • Forums
  • Answers
  • Evangelists
  • User Groups
  • Beta Program
  • Advisory Panel

Navigation

  • Home
  • Products
  • Solutions
  • Made with Unity
  • Learning
  • Support & Services
  • Community
    • Blog
    • Forums
    • Answers
    • Evangelists
    • User Groups
    • Beta Program
    • Advisory Panel

Unity account

You need a Unity Account to shop in the Online and Asset Stores, participate in the Unity Community and manage your license portfolio. Login Create account

Language

  • Chinese
  • Spanish
  • Japanese
  • Korean
  • Portuguese
  • Ask a question
  • Spaces
    • Default
    • Help Room
    • META
    • Moderators
    • Topics
    • Questions
    • Users
    • Badges
  • Home /
avatar image
0
Question by Ochreous · Oct 18, 2014 at 07:03 AM · shadertexturematerial

Shader Shadow Effect Issues

I've been working on this shader and I have not received any errors from the console. But I'm not getting all the effects from the shader. There should be a shadow effect along with the rest of the shader's effects. But it's not appearing. Did I not implement my shadow effect correctly? How do I determine what is wrong if the console doesn't say there's anything wrong?

 Shader "Custom/Shadow Shader" {
     Properties {
         _MainTex ("Base (RGB)", 2D) = "white" {}
         _Bump ("Bump", 2D) = "bump" {}
         _ColorMerge ("Color Merge", Range(0.1,20000)) = 8
         _Ramp ("Ramp Texture", 2D) = "white" {}
         _Outline ("Outline", Range(0, 0.15)) = 0.08
         _Color ("Diffuse Color", Color) = (1,1,1,1) 
       _UnlitColor ("Unlit Diffuse Color", Color) = (0.5,0.5,0.5,1) 
       _DiffuseThreshold ("Threshold for Diffuse Colors", Range(0,1)) 
          = 0.1 
       _ShadowColor ("Outline Color", Color) = (0,0,0,1)
       _LitShadowThickness ("Lit Outline Thickness", Range(0,1)) = 0.1
       _UnlitShadowThickness ("Unlit Outline Thickness", Range(0,1)) 
          = 0.4
       _SpecColor ("Specular Color", Color) = (1,1,1,1) 
       _Shininess ("Shininess", Float) = 10
     }
     SubShader {
         Tags { "RenderType"="Opaque" }
         LOD 200
  
         Pass {
  
             Cull Front
             Lighting Off
             ZWrite On
             Tags { "LightMode"="ForwardBase" }
  
             CGPROGRAM
             #pragma vertex vert
             #pragma fragment frag
  
             #include "UnityCG.cginc"
             uniform float4 _LightColor0; 
             // color of light source (from "Lighting.cginc")
  
          // User-specified properties
          uniform float4 _Color; 
          uniform float4 _UnlitColor;
          uniform float _DiffuseThreshold;
          uniform float4 _ShadowColor;
          uniform float _LitShadowThickness;
          uniform float _UnlitShadowThickness;
          uniform float4 _SpecColor; 
          uniform float _Shininess;
  
          struct vertexInput {
             float4 vertex : POSITION;
             float3 normal : NORMAL;
          };
          struct vertexOutput {
             float4 pos : SV_POSITION;
             float4 posWorld : TEXCOORD0;
             float3 normalDir : TEXCOORD1;
          };
  
          vertexOutput vert(vertexInput input) 
          {
             vertexOutput output;
  
             float4x4 modelMatrix = _Object2World;
             float4x4 modelMatrixInverse = _World2Object; 
                // multiplication with unity_Scale.w is unnecessary 
                // because we normalize transformed vectors
  
             output.posWorld = mul(modelMatrix, input.vertex);
             output.normalDir = normalize(
                mul(float4(input.normal, 0.0), modelMatrixInverse).xyz);
             output.pos = mul(UNITY_MATRIX_MVP, input.vertex);
             return output;
          }
                   float4 frag(vertexOutput input) : COLOR
          {
             float3 normalDirection = normalize(input.normalDir);
  
             float3 viewDirection = normalize(
                _WorldSpaceCameraPos - input.posWorld.xyz);
             float3 lightDirection;
             float attenuation;
  
             if (0.0 == _WorldSpaceLightPos0.w) // directional light?
             {
                attenuation = 1.0; // no attenuation
                lightDirection = normalize(_WorldSpaceLightPos0.xyz);
             } 
             else // point or spot light
             {
                float3 vertexToLightSource = 
                   _WorldSpaceLightPos0.xyz - input.posWorld.xyz;
                float distance = length(vertexToLightSource);
                attenuation = 1.0 / distance; // linear attenuation 
                lightDirection = normalize(vertexToLightSource);
             }
  
             // default: unlit 
             float3 fragmentColor = _UnlitColor.rgb; 
  
             // low priority: diffuse illumination
             if (attenuation 
                * max(0.0, dot(normalDirection, lightDirection)) 
                >= _DiffuseThreshold)
             {
                fragmentColor = _LightColor0.rgb * _Color.rgb; 
             }
  
             // higher priority: outline
             if (dot(viewDirection, normalDirection) 
                < lerp(_UnlitShadowThickness, _LitShadowThickness, 
                max(0.0, dot(normalDirection, lightDirection))))
             {
                fragmentColor = _LightColor0.rgb * _ShadowColor.rgb; 
             }
  
             // highest priority: highlights
             if (dot(normalDirection, lightDirection) > 0.0 
                // light source on the right side?
                && attenuation *  pow(max(0.0, dot(
                reflect(-lightDirection, normalDirection), 
                viewDirection)), _Shininess) > 0.5) 
                // more than half highlight intensity? 
             {
                fragmentColor = _SpecColor.a 
                   * _LightColor0.rgb * _SpecColor.rgb
                   + (1.0 - _SpecColor.a) * fragmentColor;
             }
             return float4(fragmentColor, 1.0);
          }
             struct a2v
             {
                 float4 vertex : POSITION;
                 float3 normal : NORMAL;
                 float3 tangent : TANGENT;
             };
  
             struct v2f
             {
                 float4 pos : POSITION;
             };
  
             float _Outline;
  
             v2f vert (a2v v)
             {
                 v2f o;
                 float4 pos = mul( UNITY_MATRIX_MV, v.vertex);
                 float3 normal = mul( (float3x3)UNITY_MATRIX_IT_MV, v.normal); 
                 normal.z = -0.4;
                 pos = pos + float4(normalize(normal),0) * _Outline;
                 o.pos = mul(UNITY_MATRIX_P, pos);
  
                 return o;
             }
  
             float4 frag (v2f IN) : COLOR
             {
                 return float(0);
             }
  
             ENDCG
  
         }
  
         Pass {
  
             Cull Back
             Lighting On
             Tags { "LightMode"="ForwardBase" }
             Blend SrcAlpha OneMinusSrcAlpha 
             CGPROGRAM
             #pragma vertex vert
             #pragma fragment frag
  
             #include "UnityCG.cginc"
              uniform float4 _LightColor0; 
             // color of light source (from "Lighting.cginc")
  
          // User-specified properties
          uniform float4 _Color; 
          uniform float4 _UnlitColor;
          uniform float _DiffuseThreshold;
          uniform float4 _ShadowColor;
          uniform float _LitShadowThickness;
          uniform float _UnlitShadowThickness;
          uniform float4 _SpecColor; 
          uniform float _Shininess;
  
          struct vertexInput {
             float4 vertex : POSITION;
             float3 normal : NORMAL;
          };
          struct vertexOutput {
             float4 pos : SV_POSITION;
             float4 posWorld : TEXCOORD0;
             float3 normalDir : TEXCOORD1;
          };
  
          vertexOutput vert(vertexInput input) 
          {
             vertexOutput output;
  
             float4x4 modelMatrix = _Object2World;
             float4x4 modelMatrixInverse = _World2Object; 
                // multiplication with unity_Scale.w is unnecessary 
                // because we normalize transformed vectors
  
             output.posWorld = mul(modelMatrix, input.vertex);
             output.normalDir = normalize(
                mul(float4(input.normal, 0.0), modelMatrixInverse).rgb);
             output.pos = mul(UNITY_MATRIX_MVP, input.vertex);
             return output;
          }
                   float4 frag(vertexOutput input) : COLOR
          {
             float3 normalDirection = normalize(input.normalDir);
  
             float3 viewDirection = normalize(
                _WorldSpaceCameraPos - input.posWorld.rgb);
             float3 lightDirection;
             float attenuation;
  
             if (0.0 == _WorldSpaceLightPos0.w) // directional light?
             {
                attenuation = 1.0; // no attenuation
                lightDirection = normalize(_WorldSpaceLightPos0.xyz);
             } 
             else // point or spot light
             {
                float3 vertexToLightSource = 
                   _WorldSpaceLightPos0.xyz - input.posWorld.xyz;
                float distance = length(vertexToLightSource);
                attenuation = 1.0 / distance; // linear attenuation 
                lightDirection = normalize(vertexToLightSource);
             }
  
             float4 fragmentColor = float4(0.0, 0.0, 0.0, 0.0);
             if (dot(normalDirection, lightDirection) > 0.0 
                // light source on the right side?
                && attenuation *  pow(max(0.0, dot(
                reflect(-lightDirection, normalDirection), 
                viewDirection)), _Shininess) > 0.5) 
                // more than half highlight intensity? 
             {
                fragmentColor = 
                   float4(_LightColor0.rgb, 1.0) * _SpecColor;
             }
             return fragmentColor;
          }
  
             sampler2D _MainTex;
             sampler2D _Bump;
             sampler2D _Ramp;
  
             float4 _MainTex_ST;
             float4 _Bump_ST;
  
             float _Tooniness;
             float _ColorMerge;
  
             struct a2v
             {
                 float4 vertex : POSITION;
                 float3 normal : NORMAL;
                 float4 texcoord : TEXCOORD0;
                 float4 tangent : TANGENT;
  
             };
  
             struct v2f
             {
                 float4 pos : POSITION;
                 float2 uv : TEXCOORD0;
                 float2 uv2 : TEXCOORD1;
                 float3 lightDirection : TEXCOORD2;
  
             };
  
             v2f vert (a2v v)
             {
                 v2f o;
                 //Create a rotation matrix for tangent space
                 TANGENT_SPACE_ROTATION;
                 //Store the light's direction in tangent space
                 o.lightDirection = mul(rotation, ObjSpaceLightDir(v.vertex));
                 //Transform the vertex to projection space
                 o.pos = mul( UNITY_MATRIX_MVP, v.vertex);
                 //Get the UV coordinates
                 o.uv = TRANSFORM_TEX (v.texcoord, _MainTex); 
                 o.uv2 = TRANSFORM_TEX (v.texcoord, _Bump);
                 return o;
             }
  
             float4 frag(v2f i) : COLOR 
             {
                 //Get the color of the pixel from the texture
                 float4 c = tex2D (_MainTex, i.uv); 
                 //Merge the colours
                 c.rgb = (floor(c.rgb*_ColorMerge)/_ColorMerge);
  
                 //Get the normal from the bump map
                 float3 n =  UnpackNormal(tex2D (_Bump, i.uv2));
  
                 //Based on the ambient light
                 float3 lightColor = UNITY_LIGHTMODEL_AMBIENT.xyz;
  
                 //Work out this distance of the light
                 float lengthSq = dot(i.lightDirection, i.lightDirection);
                 //Fix the attenuation based on the distance
                 float atten = 1.0 / (1.0 + lengthSq);
                 //Angle to the light
                 float diff = saturate (dot (n, normalize(i.lightDirection))); 
                 //Perform our toon light mapping
                 diff = tex2D(_Ramp, float2(diff, 0.5));
                 //Update the colour
                 lightColor += _LightColor0.rgb * (diff * atten);
                 //Product the final color
                 c.rgb = lightColor * c.rgb * 2;
                 return c;
  
             }
  
             ENDCG
         }
  
     }
     FallBack "Diffuse"
 }
Comment
Add comment
10 |3000 characters needed characters left characters exceeded
▼
  • Viewable by all users
  • Viewable by moderators
  • Viewable by moderators and the original poster
  • Advanced visibility
Viewable by all users

0 Replies

· Add your reply
  • Sort: 

Your answer

Hint: You can notify a user about this post by typing @username

Up to 2 attachments (including images) can be used with a maximum of 524.3 kB each and 1.0 MB total.

Welcome to Unity Answers

The best place to ask and answer questions about development with Unity.

To help users navigate the site we have posted a site navigation guide.

If you are a new user to Unity Answers, check out our FAQ for more information.

Make sure to check out our Knowledge Base for commonly asked Unity questions.

If you are a moderator, see our Moderator Guidelines page.

We are making improvements to UA, see the list of changes.



Follow this Question

Answers Answers and Comments

26 People are following this question.

avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image avatar image

Related Questions

How to apply different textures to one model? 1 Answer

Assign Texture To Material Unity 4.6 1 Answer

Cheapest Way to Render Texture on Quad 0 Answers

Sprite obstruction transparent area 1 Answer

Which is the best inbuilt Unity transparent Shader to use for an iphone game. 1 Answer

  • Anonymous
  • Sign in
  • Create
  • Ask a question
  • Spaces
  • Default
  • Help Room
  • META
  • Moderators
  • Explore
  • Topics
  • Questions
  • Users
  • Badges