Grasshopper Python script

2025-12-19 10:15 UTC gpt-5-2-thinking Open in ChatGPT ↗

Below is a Grasshopper Python (GhPython) script that:

takes a Rhino mesh
computes face–face neighbours (faces that share an edge)
writes the topology to a text file in a Unity-friendly JSON format

GhPython component setup

Inputs

M (Type hint: Mesh) – the mesh
filepath (Type hint: str) – full path to save, e.g.
C:\temp\mesh_adjacency.json (Windows) or /Users/me/temp/mesh_adjacency.json (macOS)

Outputs

neighbors – list of neighbor lists (per face)
ok – success boolean
msg – status text

GhPython code (paste into the component)

import Rhino
import json
import os

# Inputs:
#   M : Rhino.Geometry.Mesh
#   filepath : str
# Outputs:
#   neighbors : list
#   ok : bool
#   msg : str

def face_vertex_indices(mesh, fi):
    """Return a list of vertex indices for face fi (tri or quad)."""
    f = mesh.Faces[fi]
    if f.IsQuad:
        return [f.A, f.B, f.C, f.D]
    else:
        return [f.A, f.B, f.C]

def face_edges(verts):
    """Given face vertex indices in order, return undirected edges as sorted tuples."""
    n = len(verts)
    e = []
    for i in range(n):
        a = verts[i]
        b = verts[(i + 1) % n]
        if a < b:
            e.append((a, b))
        else:
            e.append((b, a))
    return e

def build_face_neighbors(mesh):
    """
    Build face adjacency by shared edges.
    Returns: list of sorted unique neighbor face indices for each face.
    """
    if mesh is None or mesh.Faces.Count == 0:
        return []

    face_count = mesh.Faces.Count

    # Map: edge (v0,v1) -> list of face indices that use it
    edge_to_faces = {}

    for fi in range(face_count):
        verts = face_vertex_indices(mesh, fi)
        for e in face_edges(verts):
            if e not in edge_to_faces:
                edge_to_faces[e] = [fi]
            else:
                edge_to_faces[e].append(fi)

    # Now build neighbors per face
    nbr_sets = [set() for _ in range(face_count)]

    for e, faces in edge_to_faces.items():
        if len(faces) < 2:
            continue  # boundary edge
        # All faces sharing this edge are neighbors of each other
        for i in range(len(faces)):
            fi = faces[i]
            for j in range(len(faces)):
                if i == j:
                    continue
                nbr_sets[fi].add(faces[j])

    neighbors = [sorted(list(s)) for s in nbr_sets]
    return neighbors

ok = False
msg = ""
neighbors = []

try:
    if M is None:
        raise Exception("Input mesh M is None.")

    neighbors = build_face_neighbors(M)

    if not filepath or not isinstance(filepath, str):
        raise Exception("Provide a valid filepath string.")

    folder = os.path.dirname(filepath)
    if folder and not os.path.exists(folder):
        os.makedirs(folder)

    data = {
        "faceCount": M.Faces.Count,
        "neighbors": neighbors
    }

    # Write JSON (compact + Unity-friendly)
    with open(filepath, "w") as f:
        json.dump(data, f)

    ok = True
    msg = "Saved adjacency for {} faces to:\n{}".format(M.Faces.Count, filepath)

except Exception as e:
    ok = False
    msg = "Error: {}".format(str(e))

Output file format (example)

{
  "faceCount": 12,
  "neighbors": [
    [1, 3, 4],
    [0, 2],
    ...
  ]
}

Each neighbors[i] is a list of face indices that share an edge with face i.

Unity C# reader snippet

using System.IO;
using UnityEngine;

[System.Serializable]
public class MeshAdjacency {
    public int faceCount;
    public int[][] neighbors;
}

public class LoadAdjacency : MonoBehaviour
{
    public string path;

    void Start()
    {
        var json = File.ReadAllText(path);
        var adj = JsonUtility.FromJson<MeshAdjacency>(json);

        Debug.Log($"Faces: {adj.faceCount}, neighbors[0].Length = {adj.neighbors[0].Length}");
    }
}

If you want, I can also modify the exporter to save:

edge IDs / half-edge style topology (better for traversal), or
per-face vertex indices + adjacency in one file (handy for rebuilding data structures in Unity).

Perfect — CSV is ideal if you want dead-simple parsing in Unity.

Below is a minimal, robust CSV export from Grasshopper Python that stores face–face adjacency.

CSV format (very simple)

One face per line

faceIndex,neighbor0,neighbor1,neighbor2,...

Example:

0,1,3,4
1,0,2
2,1
3,0,4
4,0,3

First value = face index
Remaining values = adjacent face indices
Empty neighbors → line is just the face index

Unity can parse this with Split(',') in one line of code.

GhPython component setup

Inputs

M → Mesh
filepath → str
Example: C:\temp\mesh_neighbors.csv

Outputs

neighbors
ok
msg

GhPython code (CSV exporter)

import Rhino
import os

# Inputs:
#   M : Rhino.Geometry.Mesh
#   filepath : str
# Outputs:
#   neighbors : list
#   ok : bool
#   msg : str

def face_vertex_indices(mesh, fi):
    f = mesh.Faces[fi]
    if f.IsQuad:
        return [f.A, f.B, f.C, f.D]
    else:
        return [f.A, f.B, f.C]

def face_edges(verts):
    n = len(verts)
    edges = []
    for i in range(n):
        a = verts[i]
        b = verts[(i + 1) % n]
        edges.append(tuple(sorted((a, b))))
    return edges

def build_face_neighbors(mesh):
    face_count = mesh.Faces.Count
    edge_to_faces = {}

    for fi in range(face_count):
        verts = face_vertex_indices(mesh, fi)
        for e in face_edges(verts):
            edge_to_faces.setdefault(e, []).append(fi)

    neighbors = [set() for _ in range(face_count)]

    for faces in edge_to_faces.values():
        if len(faces) > 1:
            for i in faces:
                for j in faces:
                    if i != j:
                        neighbors[i].add(j)

    return [sorted(list(n)) for n in neighbors]

ok = False
msg = ""
neighbors = []

try:
    if M is None:
        raise Exception("Mesh is None")

    neighbors = build_face_neighbors(M)

    if not filepath:
        raise Exception("Invalid filepath")

    folder = os.path.dirname(filepath)
    if folder and not os.path.exists(folder):
        os.makedirs(folder)

    with open(filepath, "w") as f:
        for i, nbrs in enumerate(neighbors):
            row = [str(i)] + [str(n) for n in nbrs]
            f.write(",".join(row) + "\n")

    ok = True
    msg = "CSV saved: {} faces".format(len(neighbors))

except Exception as e:
    msg = str(e)
    ok = False

Unity C# reader (minimal)

using System.IO;
using UnityEngine;
using System.Collections.Generic;

public class FaceAdjacencyLoader
{
    public static List<int>[] Load(string path)
    {
        var lines = File.ReadAllLines(path);
        var adj = new List<int>[lines.Length];

        for (int i = 0; i < lines.Length; i++)
        {
            var parts = lines[i].Split(',');
            adj[i] = new List<int>();

            for (int j = 1; j < parts.Length; j++)
                adj[i].Add(int.Parse(parts[j]));
        }

        return adj;
    }
}

Why this format works well

✔ Human-readable
✔ No headers
✔ No nesting
✔ No parsing libraries
✔ Perfect for runtime loading

If you want an even more compact format, I can also give you:

semicolon-separated neighbors only (index = line number)
edge list CSV (faceA,faceB)
binary-friendly format for very large meshes

Just tell me how “bare-metal” you want it.