QuickOutline: how can I change the shader to work with objects with two materials?

Hello folks,

I'm trying to create an outline effect that works also in VR and I am using the QuickOutline asset from the asset store with Unity Version 2018.4.8f1.

The problem is that I have some model that has more than one material and that makes the outline appear only one part of it.

Do you know why and how can I solve it?

I found out that the same thing happens when using different shader found online on objects that have more than one material and that probably it is due to the fact that I need to change something in the #pragma fragment function, but I don't know exactly how.

The quick Outline use the script outline.cs to add at run time to material with two different shaders that are responsible to create the outline:

The Script: // // Outline.cs // QuickOutline // // Created by Chris Nolet on 3/30/18. // Copyright © 2018 Chris Nolet. All rights reserved. //

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine;
 
 [DisallowMultipleComponent]
 
 public class Outline : MonoBehaviour {
   private static HashSet<Mesh> registeredMeshes = new HashSet<Mesh>();
 
   public enum Mode {
     OutlineAll,
     OutlineVisible,
     OutlineHidden,
     OutlineAndSilhouette,
     SilhouetteOnly
   }
 
   public Mode OutlineMode {
     get { return outlineMode; }
     set {
       outlineMode = value;
       needsUpdate = true;
     }
   }
 
   public Color OutlineColor {
     get { return outlineColor; }
     set {
       outlineColor = value;
       needsUpdate = true;
     }
   }
 
   public float OutlineWidth {
     get { return outlineWidth; }
     set {
       outlineWidth = value;
       needsUpdate = true;
     }
   }
 
   [Serializable]
   private class ListVector3 {
     public List<Vector3> data;
   }
 
   [SerializeField]
   private Mode outlineMode;
 
   [SerializeField]
   private Color outlineColor = Color.white;
 
   [SerializeField, Range(0f, 10f)]
   private float outlineWidth = 2f;
 
   [Header("Optional")]
 
   [SerializeField, Tooltip("Precompute enabled: Per-vertex calculations are performed in the editor and serialized with the object. "
   + "Precompute disabled: Per-vertex calculations are performed at runtime in Awake(). This may cause a pause for large meshes.")]
   private bool precomputeOutline;
 
   [SerializeField, HideInInspector]
   private List<Mesh> bakeKeys = new List<Mesh>();
 
   [SerializeField, HideInInspector]
   private List<ListVector3> bakeValues = new List<ListVector3>();
 
   private Renderer[] renderers;
   private Material outlineMaskMaterial;
   private Material outlineFillMaterial;
 
   private bool needsUpdate;
 
   void Awake() {
 
     // Cache renderers
     renderers = GetComponentsInChildren<Renderer>();
 
     // Instantiate outline materials
     outlineMaskMaterial = Instantiate(Resources.Load<Material>(@"Materials/OutlineMask"));
     outlineFillMaterial = Instantiate(Resources.Load<Material>(@"Materials/OutlineFill"));
 
     outlineMaskMaterial.name = "OutlineMask (Instance)";
     outlineFillMaterial.name = "OutlineFill (Instance)";
 
     // Retrieve or generate smooth normals
     LoadSmoothNormals();
 
     // Apply material properties immediately
     needsUpdate = true;
   }
 
   void OnEnable() {
     foreach (var renderer in renderers) {
 
       // Append outline shaders
       var materials = renderer.sharedMaterials.ToList();
 
       materials.Add(outlineMaskMaterial);
       materials.Add(outlineFillMaterial);
 
       renderer.materials = materials.ToArray();
     }
   }
 
   void OnValidate() {
 
     // Update material properties
     needsUpdate = true;
 
     // Clear cache when baking is disabled or corrupted
     if (!precomputeOutline && bakeKeys.Count != 0 || bakeKeys.Count != bakeValues.Count) {
       bakeKeys.Clear();
       bakeValues.Clear();
     }
 
     // Generate smooth normals when baking is enabled
     if (precomputeOutline && bakeKeys.Count == 0) {
       Bake();
     }
   }
 
   void Update() {
     if (needsUpdate) {
       needsUpdate = false;
 
       UpdateMaterialProperties();
     }
   }
 
   void OnDisable() {
     foreach (var renderer in renderers) {
 
       // Remove outline shaders
       var materials = renderer.sharedMaterials.ToList();
 
       materials.Remove(outlineMaskMaterial);
       materials.Remove(outlineFillMaterial);
 
       renderer.materials = materials.ToArray();
     }
   }
 
   void OnDestroy() {
 
     // Destroy material instances
     Destroy(outlineMaskMaterial);
     Destroy(outlineFillMaterial);
   }
 
   void Bake() {
 
     // Generate smooth normals for each mesh
     var bakedMeshes = new HashSet<Mesh>();
 
     foreach (var meshFilter in GetComponentsInChildren<MeshFilter>()) {
 
       // Skip duplicates
       if (!bakedMeshes.Add(meshFilter.sharedMesh)) {
         continue;
       }
 
       // Serialize smooth normals
       var smoothNormals = SmoothNormals(meshFilter.sharedMesh);
 
       bakeKeys.Add(meshFilter.sharedMesh);
       bakeValues.Add(new ListVector3() { data = smoothNormals });
     }
   }
 
   void LoadSmoothNormals() {
 
     // Retrieve or generate smooth normals
     foreach (var meshFilter in GetComponentsInChildren<MeshFilter>()) {
 
       // Skip if smooth normals have already been adopted
       if (!registeredMeshes.Add(meshFilter.sharedMesh)) {
         continue;
       }
 
       // Retrieve or generate smooth normals
       var index = bakeKeys.IndexOf(meshFilter.sharedMesh);
       var smoothNormals = (index >= 0) ? bakeValues[index].data : SmoothNormals(meshFilter.sharedMesh);
 
       // Store smooth normals in UV3
       meshFilter.sharedMesh.SetUVs(3, smoothNormals);
     }
 
     // Clear UV3 on skinned mesh renderers
     foreach (var skinnedMeshRenderer in GetComponentsInChildren<SkinnedMeshRenderer>()) {
       if (registeredMeshes.Add(skinnedMeshRenderer.sharedMesh)) {
         skinnedMeshRenderer.sharedMesh.uv4 = new Vector2[skinnedMeshRenderer.sharedMesh.vertexCount];
       }
     }
   }
 
   List<Vector3> SmoothNormals(Mesh mesh) {
 
     // Group vertices by location
     var groups = mesh.vertices.Select((vertex, index) => new KeyValuePair<Vector3, int>(vertex, index)).GroupBy(pair => pair.Key);
 
     // Copy normals to a new list
     var smoothNormals = new List<Vector3>(mesh.normals);
 
     // Average normals for grouped vertices
     foreach (var group in groups) {
 
       // Skip single vertices
       if (group.Count() == 1) {
         continue;
       }
 
       // Calculate the average normal
       var smoothNormal = Vector3.zero;
 
       foreach (var pair in group) {
         smoothNormal += mesh.normals[pair.Value];
       }
 
       smoothNormal.Normalize();
 
       // Assign smooth normal to each vertex
       foreach (var pair in group) {
         smoothNormals[pair.Value] = smoothNormal;
       }
     }
 
     return smoothNormals;
   }
 
   void UpdateMaterialProperties() {
 
     // Apply properties according to mode
     outlineFillMaterial.SetColor("_OutlineColor", outlineColor);
 
     switch (outlineMode) {
       case Mode.OutlineAll:
         outlineMaskMaterial.SetFloat("_ZTest", (float)UnityEngine.Rendering.CompareFunction.Always);
         outlineFillMaterial.SetFloat("_ZTest", (float)UnityEngine.Rendering.CompareFunction.Always);
         outlineFillMaterial.SetFloat("_OutlineWidth", outlineWidth);
         break;
 
       case Mode.OutlineVisible:
         outlineMaskMaterial.SetFloat("_ZTest", (float)UnityEngine.Rendering.CompareFunction.Always);
         outlineFillMaterial.SetFloat("_ZTest", (float)UnityEngine.Rendering.CompareFunction.LessEqual);
         outlineFillMaterial.SetFloat("_OutlineWidth", outlineWidth);
         break;
 
       case Mode.OutlineHidden:
         outlineMaskMaterial.SetFloat("_ZTest", (float)UnityEngine.Rendering.CompareFunction.Always);
         outlineFillMaterial.SetFloat("_ZTest", (float)UnityEngine.Rendering.CompareFunction.Greater);
         outlineFillMaterial.SetFloat("_OutlineWidth", outlineWidth);
         break;
 
       case Mode.OutlineAndSilhouette:
         outlineMaskMaterial.SetFloat("_ZTest", (float)UnityEngine.Rendering.CompareFunction.LessEqual);
         outlineFillMaterial.SetFloat("_ZTest", (float)UnityEngine.Rendering.CompareFunction.Always);
         outlineFillMaterial.SetFloat("_OutlineWidth", outlineWidth);
         break;
 
       case Mode.SilhouetteOnly:
         outlineMaskMaterial.SetFloat("_ZTest", (float)UnityEngine.Rendering.CompareFunction.LessEqual);
         outlineFillMaterial.SetFloat("_ZTest", (float)UnityEngine.Rendering.CompareFunction.Greater);
         outlineFillMaterial.SetFloat("_OutlineWidth", 0);
         break;
     }
   }
 }
 

OutlineFill.shader

 //
 //  OutlineFill.shader
 //  QuickOutline
 //
 //  Created by Chris Nolet on 2/21/18.
 //  Copyright © 2018 Chris Nolet. All rights reserved.
 //
 
 Shader "Custom/Outline Fill" {
   Properties {
     [Enum(UnityEngine.Rendering.CompareFunction)] _ZTest("ZTest", Float) = 0
 
     _OutlineColor("Outline Color", Color) = (1, 1, 1, 1)
     _OutlineWidth("Outline Width", Range(0, 10)) = 2
   }
 
   SubShader {  // render things once
     Tags {
       "Queue" = "Transparent+110"
       "RenderType" = "Transparent"
       "DisableBatching" = "True"
     }
 
     Pass {
       Name "Fill"
       Cull Off
       ZTest [_ZTest]
       ZWrite Off
       Blend SrcAlpha OneMinusSrcAlpha
       ColorMask RGB
 
       Stencil {
         Ref 1
         Comp NotEqual
       }
 
       CGPROGRAM // Allows to talk with two different program languages the graphic card and unity one
       #include "UnityCG.cginc"
 
       #pragma vertex vert  // tells how to build the object
       #pragma fragment frag  // tells which color it should be 
 
       struct appdata {
         float4 vertex : POSITION;
         float3 normal : NORMAL;
         float3 smoothNormal : TEXCOORD3;
         UNITY_VERTEX_INPUT_INSTANCE_ID
       };
 
       struct v2f {  // vertex to fragment
         float4 position : SV_POSITION;
         fixed4 color : COLOR;
         UNITY_VERTEX_OUTPUT_STEREO
       };
 
       //enables to connect with the  properties we defined at the beginning
       uniform fixed4 _OutlineColor;
       uniform float _OutlineWidth;
 
       v2f vert(appdata input) { // defintion of the pragma vert function
         v2f output;
 
         UNITY_SETUP_INSTANCE_ID(input);
         UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
 
         float3 normal = any(input.smoothNormal) ? input.smoothNormal : input.normal;
         float3 viewPosition = UnityObjectToViewPos(input.vertex);
         float3 viewNormal = normalize(mul((float3x3)UNITY_MATRIX_IT_MV, normal));
 
         output.position = UnityViewToClipPos(viewPosition + viewNormal * -viewPosition.z * _OutlineWidth / 1000.0);
         output.color = _OutlineColor;
 
         return output;
       }
 
       fixed4 frag(v2f input) : SV_Target {
         return input.color;
       }
       ENDCG
     }
   }
 }
 

OutlineMask.shader

 Shader "Custom/Outline Mask" {
   Properties {
     [Enum(UnityEngine.Rendering.CompareFunction)] _ZTest("ZTest", Float) = 0
   }
 
   SubShader {
     Tags {
       "Queue" = "Transparent+100"
       "RenderType" = "Transparent"
     }
 
     Pass {
       Name "Mask"
       Cull Off
       ZTest [_ZTest]
       ZWrite Off
       ColorMask 0
 
       Stencil {
         Ref 1
         Pass Replace
       }
     }
   }
 }
 

EDIT:
This is how it looks like the element in the editor, I have 4 materials but just one mesh

Thank you for the help