TLDR; I created a behaviour script that lets you highlight vertices on any type of mesh in unity3d.
I have been playing lately with mesh deformations and I needed a way to visually see the selected vertices (and neighbor vertex connections) for the meshes I was manipulating. To do this I created a simple MonoBehaviour script that one attaches to an empty game object that is a children of the mesh that is being manipulated and simply call two functions to highlight or remove vertices of said mesh.
Someone might find this utility useful. There might be other ways to do it but this one that I developed works pretty well for my needs. If you find it useful let me know; it makes me happy to know that I helped someone on the interwebs with my work :).
Its worth mentioning that the mesh to manipulate *needs* to have a mesh collider. This is how it looks:
Anyways. Without further ado. Here it goes:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 |
/* Created by: Juan Sebastian Munoz Arango naruse@gmail.com all rights reserved This class creates a connection graph for neighbor vertices from the parent mesh and subsequently generates a line mesh that highlights neighboor vertices. */ using System.Threading; using System.Collections; using System.Collections.Generic; using UnityEngine; public class NeighborVertexHighlight : MonoBehaviour { private Mesh highlightMesh; private Mesh parentMesh; //refers to the mesh we are getting the indices to highlight private List<int>[] neighborGraph;//precomputed neighbor graph private Dictionary<Vector3, VertexNeighbor> indexNeighbors;//contains the current indices that we want to highlight List<Vector3> vertices = new List<Vector3>(); List<int> indices = new List<int>(); Dictionary<int, int> indexRemap = new Dictionary<int, int>(); private bool finishedProcessingNeighborGraph = false; void Start() { indexNeighbors = new Dictionary<Vector3, VertexNeighbor>(); if (transform.parent == null) Debug.LogError("NeighboorHighlight needs to be attached to a child of the mesh one wants to highlight"); parentMesh = transform.parent.GetComponent<MeshFilter>().mesh; if (parentMesh == null) Debug.LogError("Parent GameObject doesnt have a mesh"); Material meshMat = new Material(Shader.Find("Unlit/Color")); meshMat.color = Color.red; gameObject.AddComponent<MeshRenderer>().material = meshMat; gameObject.AddComponent<MeshFilter>(); /* Neighbor Graph generation */ ProcessNeighborGraph(); } private void ThreadedNeighborGraphProcess(Vector3[] parentVerts, int[] parentTriangs) { finishedProcessingNeighborGraph = false; Debug.Log("Generating neighbor hierarchy in other thread..."); neighborGraph = GenerateNeighborGraph(parentVerts, parentTriangs); Debug.Log("Finished generating hierarchy!"); finishedProcessingNeighborGraph = true; } private void ProcessNeighborGraph() { finishedProcessingNeighborGraph = false; Vector3[] parentVerts = parentMesh.vertices; int[] parentTriangs = parentMesh.triangles; Thread graphWorker = new Thread(new ThreadStart(() => ThreadedNeighborGraphProcess(parentVerts, parentTriangs))); graphWorker.Start(); } public void AddIndex(int i) { if (!finishedProcessingNeighborGraph) { Debug.LogError("Cant add index as neighbor graph is being processed!"); return; } if (!indexNeighbors.ContainsKey(parentMesh.vertices[i])) { indexNeighbors.Add(parentMesh.vertices[i], new VertexNeighbor(i, neighborGraph[i])); AddVertexToMesh(parentMesh.vertices[i], i); } } public void RemoveIndex(int i) { if (!finishedProcessingNeighborGraph) { Debug.LogError("Cant remove index as neighbor graph is being processed!"); return; } if (indexNeighbors.ContainsKey(parentMesh.vertices[i])) { indexNeighbors.Remove(parentMesh.vertices[i]); RemoveVertexFromMesh(parentMesh.vertices[i], i); } } private void AddVertexToMesh(Vector3 vert, int index) { highlightMesh = new Mesh(); List<int> neighborsOfIndex = neighborGraph[index]; if (!indexRemap.ContainsKey(index)) { vertices.Add(vert); indexRemap.Add(index, vertices.Count - 1); } for (int i = 0; i < neighborsOfIndex.Count; i++) { indices.Add(indexRemap[index]); if (indexRemap.ContainsKey(neighborsOfIndex[i])) { indices.Add(indexRemap[neighborsOfIndex[i]]); } else { vertices.Add(parentMesh.vertices[neighborsOfIndex[i]]); indexRemap.Add(neighborsOfIndex[i], vertices.Count - 1); indices.Add(indexRemap[neighborsOfIndex[i]]); } } highlightMesh.SetVertices(vertices); highlightMesh.SetIndices(indices.ToArray(), MeshTopology.Lines, 0); GetComponent<MeshFilter>().sharedMesh = highlightMesh; } private void RemoveVertexFromMesh(Vector3 vert, int index) { highlightMesh = new Mesh(); if(indexRemap.ContainsKey(index)) { for(int i = 0; i < indices.Count-1; i++) { if(indices[i] == indexRemap[index]) { indices[i] = -1; indices[i + 1] = -1; } } indices.RemoveAll(x => x == -1); } highlightMesh.SetVertices(vertices); highlightMesh.SetIndices(indices.ToArray(), MeshTopology.Lines, 0); GetComponent<MeshFilter>().sharedMesh = highlightMesh; } private List<int>[] GenerateNeighborGraph(Vector3[] _vertices, int[] _triangles) { List<int>[] neighbor = new List<int>[_vertices.Length]; Dictionary<Vector3, int> currentConnections = new Dictionary<Vector3, int>(); for (int j = 0; j < _triangles.Length; j += 3) { int j1 = _triangles[j + 0]; int j2 = _triangles[j + 1]; int j3 = _triangles[j + 2]; if (neighbor[j1] == null) neighbor[j1] = new List<int>(); if (neighbor[j2] == null) neighbor[j2] = new List<int>(); if (neighbor[j3] == null) neighbor[j3] = new List<int>(); if (!currentConnections.ContainsKey(_vertices[j1])) currentConnections.Add(_vertices[j1], j1); if (!currentConnections.ContainsKey(_vertices[j2])) currentConnections.Add(_vertices[j2], j2); if (!currentConnections.ContainsKey(_vertices[j3])) currentConnections.Add(_vertices[j3], j3); neighbor[currentConnections[_vertices[j1]]].Add(j2); neighbor[currentConnections[_vertices[j1]]].Add(j3); neighbor[currentConnections[_vertices[j2]]].Add(j1); neighbor[currentConnections[_vertices[j2]]].Add(j3); neighbor[currentConnections[_vertices[j3]]].Add(j1); neighbor[currentConnections[_vertices[j3]]].Add(j2); } return neighbor; } //contains index of a vertex and its neighbor indexes private class VertexNeighbor { private int index; public int Index { get { return index; } } private List<int> neighborIndexes; public List<int> NeighborIndexes { get { return neighborIndexes; } } public VertexNeighbor(int i, List<int> indexes) { index = i; neighborIndexes = indexes; } } } |
And a simple script that makes it work by “Painting” with the left click on certain parts of the mesh.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
using System.Collections; using System.Collections.Generic; using UnityEngine; public class PaintRemoveVerticesExample : MonoBehaviour { public float speed = 40; void Update () { RaycastHit rayHit; Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); if(Physics.Raycast(ray, out rayHit)) { MeshCollider hitObjCollider = rayHit.collider as MeshCollider; NeighborVertexHighlight vertHighlighter = rayHit.transform.GetComponentInChildren<NeighborVertexHighlight>(); if(hitObjCollider != null && vertHighlighter != null) { if(Input.GetMouseButton(0))//left mouse pressed - add vertices to highlight vertHighlighter.AddIndex(hitObjCollider.sharedMesh.triangles[rayHit.triangleIndex*3]); if(Input.GetMouseButton(1))//right mouse pressed - remove highlighted vertices vertHighlighter.RemoveIndex(hitObjCollider.sharedMesh.triangles[rayHit.triangleIndex*3]); } else Debug.LogError("Hit object: " + rayHit.transform.name + " doesnt have a NeighborVertexHighlight behaviour OR doesnt have a mesh collider"); } //rotate mesh if(Input.GetKey(KeyCode.LeftArrow)) transform.RotateAround(transform.position, Vector3.up, speed * Time.deltaTime); if(Input.GetKey(KeyCode.RightArrow)) transform.RotateAround(transform.position, Vector3.up, -speed * Time.deltaTime); } void OnGUI() { GUILayout.Label("Press left click over mesh to paint vertices"); GUILayout.Label("Press right click over mesh to remove vertices"); GUILayout.Label("Left/right arrow to rotate sphere"); } } |
To make it work, simply create an empty Game Object as a children of the mesh to highlight and attach the “NeighborVertexHighlighter” script component to it. To test the script you can attach the “PaintRemoveVerticesExample” script to the mesh to highlight. *Its important to remember that the mesh to be highlighted requires a MeshCollider component*
How it works:
The way this works is by creating a list of arrays of integers for each of the vertices; this list contains the indices of the neighbor vertices for any given vertex. This neighbor list is calculated on a separate thread (to not block the main thread) and is Order the number of triangles the mesh has.
Two main functions can be called in the highlighter script. AddIndex(int i) and RemoveIndex(int i), One just needs to pass the index of the vertex one wants to highlight and the script will automatically create a mesh with the indices that are going to be highlighted.
Internally a dictionary<Vector3, VertexNeighbor> contains the current indices that are being highlighted. This dictionarly is modified with AddIndex and RemoveIndex functions. It is worth noting that I used the position of the vertex as the key instead of the index of the vertex in the vertex array because I found that some meshes (like the base cube in Unity) contain different separate vertices in the same exact position, hence this algorithm would highlight only the index neighbors. Because of this is useful to use the position of the vertex as the key in case the mesh contains different vertices in the same position.
In order to map/know which vertex refers to the original mesh in the highlighted mesh, another dictionary is used, its called indexRemap<int, int>. This dictionary easily lets one translate from the mesh to highlight vertex indices to the highlighted mesh vertex indices.
Finally, after an index is added or removed, a line mesh is created with the already saved indices in the class. The idea is pretty simple but works pretty well.
Future work:
Perhaps this could be further optimized by not creating a mesh every time an index is added or removed but perhaps having all the indices of the original mesh and adding, removing triangles. But unfortunately this will make it consume more memory. So I will have to assess how good this will work in huge meshes.
