Diffuse shading

Before starting our journey into texture mapping, it is important to understand how diffuse materials work. Certain objects might have a uniform color and smooth surface, but not smooth enough to shine on reflected light. These matte materials are best represented with a Diffuse shader. While in the real world, pure diffuse materials do not exist; Diffuse shaders are relatively cheap to implement and find a large application in games with low-poly aesthetics.

Getting ready

There are several ways in which you can create your own Diffuse shader. A quick way is to start with the Standard Shader in Unity 5 and edit it to remove any texture, similarly to what was previously done in Chapter 1, Creating Your First Shader.

How to do it...

Let's start with our Standard Shader, and apply the following changes:

1. Remove all the properties except _Color:

   _Color ("Color", Color) = (1,1,1,1)

2. From the SubShader{} section, remove the _MainTex, _Glossiness, and _Metallic variables. You should not remove the reference to uv_MainTex as Cg does not allow the Input struct to be empty. The value will be simply ignored.
3. Remove the content of the surf() function and replace it with the following:

   o.Albedo = _Color.rgb;

4. Your shader should look as follows:

   Shader "CookbookShaders/Diffuse" {
     Properties {
       _Color ("Color", Color) = (1,1,1,1)
     }
     SubShader {
       Tags { "RenderType"="Opaque" }
       LOD 200
       
       CGPROGRAM
       #pragma surface surf Standard fullforwardshadows
       #pragma target 3.0
       struct Input {
         float2 uv_MainTex;
       };
       fixed4 _Color;
   
       void surf (Input IN, inout SurfaceOutputStandard o) {
         o.Albedo = _Color.rgb;
       }
    ENDCG
     } 
     FallBack "Diffuse"
   }

As this shader has been refitted from a Standard Shader, it will use physically-based rendering to simulate how light behaves on your models. If you are trying to achieve a non-photorealistic look, you can change the first #pragma directive so that it uses Lambert rather than Standard. If you do so, you should also replace SurfaceOutputStandard with SurfaceOutput.

How it works...

The way shaders allow you to communicate the rendering properties of your material to their lighting model is via a surface output. It is basically a wrapper around all the parameters that the current lighting model needs. It should not surprise you that different lighting models have different surface output structs. The following table shows the three main output structs used in Unity 5 and how they can be used:

The SurfaceOutput struct has the following properties:

• fixed3 Albedo;: This is the diffuse color of the material
• fixed3 Normal;: This is the tangent space normal, if written
• fixed3 Emission;: This is the color of the light emitted by the material (this property is declared as half3 in the Standard Shaders)
• fixed Alpha;: This is the transparency of the material
• half Specular;: This is the specular power from 0 to 1
• fixed Gloss;: This is the specular intensity

The SurfaceOutputStandard struct has the following properties:

• fixed3 Albedo;: This is the base color of the material (whether it's diffuse or specular)
• fixed3 Normal;
• half3 Emission;: This property is declared as half3, while it was defined as fixed3 in SurfaceOutput
• fixed Alpha;
• half Occlusion;: This is the occlusion (default 1)
• half Smoothness;: This is the smoothness (0 = rough, 1 = smooth)
• half Metallic;: 0 = non-metal, 1= metal

The SurfaceOutputStandardSpecular struct has the following properties:

• fixed3 Albedo;.
• fixed3 Normal;.
• half3 Emission;.
• fixed Alpha;.
• half Occlusion;.
• half Smoothness;.
• fixed3 Specular;: This is the specular color. This is very different from the Specular property in SurfaceOutput as it allows specifying a color rather than a single value.

Using a Surface Shader correctly is a matter of initializing the surface output with the correct values.