Visualize mesh normals in Unity3D

README.md

Visualize the normals of a mesh

It's meant to be simple and easy to use, and therefore it has been made as a custom editor of MeshFilter. It needs no preparations.

How to use

Drop the file in an Editor folder.

Updates

• store the normals length i editor prefs
• adjust the normals length in the mesh filter inspector

NormalsVisualizer.cs

using UnityEditor;
using UnityEngine;

[CustomEditor(typeof(MeshFilter))]
public class NormalsVisualizer : Editor {

    private const string     EDITOR_PREF_KEY = "_normals_length";
    private       Mesh       mesh;
    private       MeshFilter mf;
    private       Vector3[]  verts;
    private       Vector3[]  normals;
    private       float      normalsLength = 1f;

    private void OnEnable() {
        mf   = target as MeshFilter;
        if (mf != null) {
            mesh = mf.sharedMesh;
        }
        normalsLength = EditorPrefs.GetFloat(EDITOR_PREF_KEY);
    }

    private void OnSceneGUI() {
        if (mesh == null) {
            return;
        }

        Handles.matrix = mf.transform.localToWorldMatrix;
        Handles.color = Color.yellow;
        verts = mesh.vertices;
        normals = mesh.normals;
        int len = mesh.vertexCount;
        
        for (int i = 0; i < len; i++) {
            Handles.DrawLine(verts[i], verts[i] + normals[i] * normalsLength);
        }
    }

    public override void OnInspectorGUI() {
        base.OnInspectorGUI();
        EditorGUI.BeginChangeCheck();
        normalsLength = EditorGUILayout.FloatField("Normals length", normalsLength);
        if (EditorGUI.EndChangeCheck()) {
            EditorPrefs.SetFloat(EDITOR_PREF_KEY, normalsLength);
        }
    }
}

I have updated the code:

1. Added zTest to hide normals which are under the object
2. Added small circles at the end of each line for better visual clarity, and to better indicate the direction

using UnityEditor;
using UnityEngine;
using UnityEngine.Rendering;

[CustomEditor(typeof(MeshFilter))]
public class NormalsVisualizer : Editor
{
    private const string EDITOR_PREF_KEY = "mesh_normals_length";
    private const string EDITOR_PREF_BOOL = "mesh_show_normals";
    private Mesh mesh;
    private MeshFilter meshFilter;
    private Vector3[] vertices;
    private Vector3[] normals;
    private float normalsLength = 1f;
    private bool showNormals;

    private void OnEnable()
    {
        meshFilter = target as MeshFilter;
        if (meshFilter != null)
            mesh = meshFilter.sharedMesh;

        normalsLength = EditorPrefs.GetFloat(EDITOR_PREF_KEY);
        showNormals = EditorPrefs.GetBool(EDITOR_PREF_BOOL);
    }

    private void OnSceneGUI()
    {
        if (!showNormals || mesh == null)
            return;

        Handles.zTest = CompareFunction.LessEqual;
        Handles.matrix = meshFilter.transform.localToWorldMatrix;
        vertices = mesh.vertices;
        normals = mesh.normals;

        for (int i = 0; i < mesh.vertexCount; i++)
        {
            Vector3 vertexPosition = vertices[i];
            Vector3 lineEndPosition = vertices[i] + normals[i] * normalsLength;

            Handles.color = Color.yellow;
            Handles.DrawLine(vertexPosition, lineEndPosition);

            Handles.color = Color.cyan;
            Handles.DrawSolidDisc(lineEndPosition, lineEndPosition, 0.1f);
        }
    }

    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();

        EditorGUI.BeginChangeCheck();
        {
            showNormals = EditorGUILayout.Toggle("Show Normals", showNormals);
            normalsLength = EditorGUILayout.FloatField("Normals Length", normalsLength);
            
            if (normalsLength < 0)
                normalsLength = 0;
        }
        if (EditorGUI.EndChangeCheck())
        {
            EditorPrefs.SetBool(EDITOR_PREF_BOOL, showNormals);
            EditorPrefs.SetFloat(EDITOR_PREF_KEY, normalsLength);
        }
    }
}