public class HexMesh
{
    public List<Point3d> Nodes { get; private set; }
    public List<HexElement> Elements { get; private set; }

    /*
    some constructors, properties and methods
    */

}

public class HexElement
{
    public int[] NodeIndices { get; }
    public int this[int index] => NodeIndices[index];

    /*
    some constructors, properties and methods
    */
}

public class GH_HexMesh : GH_Goo<HexMesh>
{
    public GH_HexMesh()
    {
    }

    public GH_HexMesh(HexMesh internal_data) : base(internal_data)
    {
    }

    public GH_HexMesh(GH_Goo<HexMesh> other) : base(other)
    {
    }

    public override string TypeName => "GH_HexMesh";

    public override string TypeDescription => "Goo for HexMesh class.";

    public override bool IsValid => Value != null && Value.IsValid;

    public override IGH_Goo Duplicate()
    {
        return new GH_HexMesh(new HexMesh(Value));
    }

    public override string ToString()
    {
        return Value.ToString();
    }
}

public class Param_HexMesh : GH_Param<GH_HexMesh>
{
    public Param_HexMesh() : base("HexMesh", "HM", "", "Demo", "0_Params", GH_ParamAccess.tree)
    {
    }
    public Param_HexMesh(IGH_InstanceDescription tag) : base(tag)
    {
    }

    public Param_HexMesh(IGH_InstanceDescription tag, GH_ParamAccess access) : base(tag, access)
    {
    }

    public Param_HexMesh(string name, string nickname, string description, GH_ParamAccess access) : base(name, nickname, description, "Demo", "Mesh", access)
    {
    }

    public override Guid ComponentGuid => new Guid("10f558b7-e786-482b-b0c2-de589b284bfd");
}

public class HexMeshFromSurfaceOffset : GH_Component
{
    public HexMeshFromSurfaceOffset() : base("HexMeshFromSurfaceOffset", "HexMeshFromSrfOffset", "Define HexMesh from offset of Surface.", "Demo", "1_Mesh")
    {
    }

    public override Guid ComponentGuid => new Guid("14b945cc-c4bd-4c88-854b-d5b4308616a6");

    protected override void RegisterInputParams(GH_InputParamManager pManager)
    {
        pManager.AddSurfaceParameter("Surface", "S", "Untrimmed Surface to generate HexMesh.", GH_ParamAccess.item);
        pManager.AddNumberParameter("Offset", "O", "Offset distance", GH_ParamAccess.item, 1);
        pManager.AddIntegerParameter("UDivision", "U", "Division along U-direction", GH_ParamAccess.item, 10);
        pManager.AddIntegerParameter("VDivision", "V", "Division along V-direction", GH_ParamAccess.item, 10);
        pManager.AddIntegerParameter("WDivision", "W", "Division along W-direction", GH_ParamAccess.item, 1);
    }

    protected override void RegisterOutputParams(GH_OutputParamManager pManager)
    {
        pManager.AddParameter(new Param_HexMesh_Geometric("HesMesh", "HM", "Generated HexMesh", GH_ParamAccess.item));
    }

    protected override void SolveInstance(IGH_DataAccess DA)
    {
        /*
        入力を取得しHexMeshを定義し出力に渡す処理
        */
    }
}

public class GH_HexMesh : GH_Goo<HexMesh>, IGH_PreviewData
{
    /*
    省略
    */

    private Line[] _previewLines;

    public BoundingBox ClippingBox => new BoundingBox(Value.Nodes);

    private void UpdatePreviewGeometries()
    {
        if (Value == null) return;
        var nodes = Value.Nodes;

        var edges = Value.GetIndexSetOfEdges();
        _previewLines = edges.Select(edge => new Line(nodes[edge.OrderedIndices[0]], nodes[edge.OrderedIndices[1]])).ToArray();
    }

    public void DrawViewportWires(GH_PreviewWireArgs args)
    {
        args.Pipeline.DrawLines(_previewLines, args.Color);
    }

    public void DrawViewportMeshes(GH_PreviewMeshArgs args)
    {
    }
}

public class Param_HexMesh : GH_Param<GH_HexMesh>, IGH_PreviewObject
{
    /*
    省略
    */

    public bool Hidden { get; set; }

    public bool IsPreviewCapable => true;

    public BoundingBox ClippingBox => Preview_ComputeClippingBox();

    public void DrawViewportMeshes(IGH_PreviewArgs args)
    {
        Preview_DrawMeshes(args);
    }

    public void DrawViewportWires(IGH_PreviewArgs args)
    {
        Preview_DrawWires(args);
    }
}

public class GH_HexMesh : GH_Goo<HexMesh>, IGH_PreviewData
{
    /*
    省略
    */

    public override bool CastFrom(object source)
    {
        if (source is HexMesh hexMesh)
        {
            Value = hexMesh.DeepCopy();
            UpdatePreviewGeometries();
            return true;
        }
        else
        {
            return false;
        }
    }

    public override bool CastTo<Q>(ref Q target)
    {
        target = default;
        if (typeof(Q).IsAssignableFrom(typeof(HexMesh)))
        {
            target = (Q)(object)Value;
            return true;
        }
        else if (typeof(Q).IsAssignableFrom(typeof(GH_Mesh)))
        {
            target = (Q)(object)new GH_Mesh(Value.ToSurfaceMesh());
            return true;
        }
        else
        {
            return false;
        }
    }
}

public class GH_HexMesh : GH_GeometricGoo<HexMesh>, IGH_PreviewData
{
    /*
    省略
    */

    public override BoundingBox Boundingbox => new BoundingBox(Value.Nodes);
    public BoundingBox ClippingBox => Boundingbox;

    public override IGH_GeometricGoo DuplicateGeometry()
    {
        return new GH_HexMesh(new HexMesh(Value));
    }

    public override BoundingBox GetBoundingBox(Transform xform)
    {
        var bbox = Boundingbox;
        bbox.Transform(xform);
        return bbox;
    }

    public override IGH_GeometricGoo Transform(Transform xform)
    {
        var mesh = Value.DeepCopy();

        for (int i = 0; i < mesh.NodeCount; i++)
        {
            var node = mesh.Nodes[i];
            node.Transform(xform);
            mesh.Nodes[i] = node;
        }
        return new GH_HexMesh(mesh);
    }
    public override IGH_GeometricGoo Morph(SpaceMorph xmorph)
    {
        var mesh = Value.DeepCopy();

        var morphedPts = mesh.Nodes.Select(node => xmorph.MorphPoint(node)).ToArray();
        mesh.Nodes.Clear();
        mesh.Nodes.AddRange(morphedPts);

        return new GH_HexMesh(mesh);
    }
}

Introduction

As mentioned in the previous chapter, Grasshopper allows you to add your own Goo, Param, and Component components.

For simple applications, adding Component is sufficient, but if you want to incorporate your own shape representation classes into Grasshopper, you will be required to add Goo and Param.

In this chapter, we will introduce the Goo and Param implementation with code instead of the Component implementation, for which there are tons of tutorials and articles.

There are many explanations of development environments such as C# and VisualStudio, use of official project templates, debugging methods, etc., so please refer to them. I will write this article assuming that you have such knowledge.

Corresponding repository

https://gitlab.com/nature_architects/ghaddondemo

Data structure to be handled

This time, as an example, we will prepare a class that represents a hexahedral mesh used in the finite element method, etc., on our own and try to handle it in Grasshopper.

A hexahedral mesh is

• A list of nodes
• HexElement (a hexahedron defined by connecting nodes. The HexMesh class consists of a list of HexElements (a hexahedron defined by connecting nodes, defined by the pairs of indices of the nodes it contains)

The HexMesh class consists of a HexElement (a hexahedron defined by connecting nodes.

Various abstractions and additional information are required to actually use this class in the finite element method, but we will leave it as an example here.

GHAddonDemo/Core/HexMesh.cs

public class HexMesh
{
    public List Nodes { get; private set; }
    public List Elements { get; private set; }

    /*
    some constructors, properties and methods
    */

}

GHAddonDemo/Core/HexElement.cs

public class HexElement
{
    public int[] NodeIndices { get; }
    public int this[int index] => NodeIndices[index];

    /*
    some constructors, properties and methods
    */
}

Minimal implementation of Goo, Param, and Cmp

Goo is a wrapper class for handling data in Grasshopper as described in the previous chapter, Param is a class for holding and passing Goo, and Component is a class that receives Goo from input Param, executes processing, and passes Goo to output Param.

We will now implement the Goo and Param of the HexMesh class we wish to handle and, as an example, a Component that defines a HexMesh from a Surface.

Implementation of GH_Goo<HexMesh>

As the most basic example, let's implement GH_HexMesh, which inherits from GH_Goo (the linked code is the completed version, so it is partially different).

In a class inheriting from GH_Goo, the following implementation is required

• Constructor
• TypeName
  property that returns a string that serves as the name of the type
• TypeDescription
  property that returns a string that serves as a summary of the type
• IsValid
  property that returns whether the information stored in the Goo is Valid
• Duplicate()
  method that returns a deep copy of itself
• ToString()
  method that returns information about itself as a string

GHAddonDemo/GH/GH_HexMesh.cs

public class GH_HexMesh : GH_Goo
{
    public GH_HexMesh()
    {
    }

    public GH_HexMesh(HexMesh internal_data) : base(internal_data)
    {
    }

    public GH_HexMesh(GH_Goo other) : base(other)
    {
    }

    public override string TypeName => "GH_HexMesh"; }

    public override string TypeDescription => "Goo for HexMesh class.";

    public override bool IsValid => Value ! = null && Value.IsValid;

    public override IGH_Goo Duplicate().
    {
        return new GH_HexMesh(new HexMesh(Value)); }
    }

    public override string ToString()
    {
        return Value.ToString(); }
    }
}

Implementing GH_Param<GH_HexMesh>

Furthermore, let's implement Param by inheriting GH_Param.

Here, in addition to the constructor, implementation of the ComponentGuid property is required. This is necessary when the property is set to "Floating" and handled in the UI like a component, so there is no problem if it does not overlap with other Param and Component properties.

Also, as a side note, if you define a constructor with no arguments here, the Floating parameter will be available (it seems that the component is loaded from the assembly in the traversal folder using Reflection when GH is launched, and this is where the branch is located). (It seems that this is a branch of the component.)

GHAddonDemo/GH/Param_HexMesh.cs

public class Param_HexMesh : GH_Param
{
    public Param_HexMesh() : base("HexMesh", "HM", "", "Demo", "0_Params", GH_ParamAccess.tree)
    {
    }
    public Param_HexMesh(IGH_InstanceDescription tag) : base(tag)
    {
    }

    public Param_HexMesh(IGH_InstanceDescription tag, GH_ParamAccess access) : base(tag, access)
    {
    }

    public Param_HexMesh(string name, string nickname, string description, GH_ParamAccess access) : base(name, nickname, description, "Demo", "Mesh ", access)
    {
    }

    public override Guid ComponentGuid => new Guid("10f558b7-e786-482b-b0c2-de589b284bfd"); }
}

Implementing GH_Component using Param as input/output

We will leave the implementation of the component to other contents, but define a class by inheriting from the GH_Component class.

As a trial, let's write a component that defines a HexMesh in the form of a UVW grid using the normal direction of the Surface as inputs for the Surface (a surface defined by NURBS), the offset amount, the number of divisions in each UVW direction, and whether the offset direction is inverted or not. See the repository for details.

[GHAddonDemo/GH/HexMeshFromSurfaceOffset.cs](https://gitlab.com/nature_architects/ghaddondemo/-/blob/master/GHAddonDemo/GH/ HexMeshFromSurfaceOffset.cs)

public class HexMeshFromSurfaceOffset : GH_Component
{
    public HexMeshFromSurfaceOffset() : base("HexMeshFromSurfaceOffset", "HexMeshFromSrfOffset", "Define HexMesh from offset of Surface.", "Demo ", "1_Mesh")
    {
    }

    public override Guid ComponentGuid => new Guid("14b945cc-c4bd-4c88-854b-d5b4308616a6");

    protected override void RegisterInputParams(GH_InputParamManager pManager)
    {
        pManager.AddSurfaceParameter("Surface", "S", "Untrimmed Surface to generate HexMesh.", GH_ParamAccess.item);
        AddNumberParameter("Offset", "O", "Offset distance", GH_ParamAccess.item, 1); pManager.
        AddIntegerParameter("UDivision", "U", "Division along U-direction", GH_ParamAccess.item, 10); pManager.
        AddIntegerParameter("VDivision", "V", "Division along V-direction", GH_ParamAccess.item, 10); pManager.
        AddIntegerParameter("WDivision", "W", "Division along W-direction", GH_ParamAccess.item, 1); pManager.
    }

    protected override void RegisterOutputParams(GH_OutputParamManager pManager)
    {
        pManager.AddParameter(new Param_HexMesh_Geometric("HexMesh", "HM", "Generated HexMesh", GH_ParamAccess.item)); }
    }

    protected override void SolveInstance(IGH_DataAccess DA)
    {
        /*
        Get input, define HexMesh and pass it to output.
        */
    }
}

When registering your own Param to the input/output, do as already described in the RegisterOutputParams method of the above code.

It may be easier to handle this by creating an extension method of the GH_Component class or defining an abstract class inheriting from GH_Component that has a method for adding your own params.

Now we have a minimum.

The wrapper is not much more than a wrapper, but it behaves as shown in the video below.

Nothing appears in the Rhino viewport yet, but the number of nodes and elements in the generated HexMesh indicates that the process is working.

Implementing the drawing function

The geometry that Grasshopper provides by default is drawn on the Rhino viewport because the corresponding Goo implements IGH_PreviewData and Param implements IGH_PreviewObject.

In Grasshopper, except for special components, the Param is the unit of rendering, and the defined Param that can be rendered is rendered in the viewport.

Let's implement interfaces to GH_HexMesh and Param_HexMesh so that HexMesh can be drawn in the Rhino world, respectively.

Implementing IGH_PreviewData in Goo

Here we try to draw the edges extracted from the HexMesh.

Since the DrawViewportWires and DrawViewportMeshes methods are called for each frame of Rhino viewport operations (pan, zoom, etc.), it is not recommended to include heavy processing here.

Here, edge extraction is performed only when defining or modifying the HexMesh, the geometry for drawing is kept in the _previewLines field, and only the drawing process is performed in the drawing method.

It is also required to implement the ClippingBox property, which is used to determine visibility in the viewport. It is required to return a BoundingBox that encompasses the entire geometry.

GHAddonDemo/GH/GH_HexMesh.cs

public class GH_HexMesh : GH_Goo, IGH_PreviewData
{
    /*
    Abbreviation.
    */

    private Line[] _previewLines;.

    public BoundingBox ClippingBox => new BoundingBox(Value.Nodes);

    private void UpdatePreviewGeometries().
    {
        if (Value == null) return;
        var nodes = Value.Nodes;

        GetIndexSetOfEdges(); var edges = Value.GetIndexSetOfEdges();
        _previewLines = edges.Select(edges => new Line(nodes[edge.OrderedIndices[0]], nodes[edge.OrderedIndices[1]])).ToArray(); }
    }

    public void DrawViewportWires(GH_PreviewWireArgs args)
    {
        args.Pipeline.DrawLines(_previewLines, args.Color); }
    }

    public void DrawViewportMeshes(GH_PreviewMeshArgs args)
    {
    }
}

Implementing IGH_PreviewObject in Param

Param requires the implementation of the properties and methods shown below, but it is rare to use anything other than this implementation method.

The Prevew_* method implemented in the GH_Param class will do the appropriate processing using the Goo in Param.

GHAddonDemo/GH/Param_HexMesh.cs

public class Param_HexMesh : GH_Param, IGH_PreviewObject
{
    /*
    Abbreviation.
    */

    public bool Hidden { get; set; }

    public bool IsPreviewCapable => true;

    public BoundingBox ClippingBox => Preview_ComputeClippingBox();

    public void DrawViewportMeshes(IGH_PreviewArgs args)
    {
        Preview_DrawMeshes(args); }
    }

    public void DrawViewportWires(IGH_PreviewArgs args)
    {
        Preview_DrawWires(args); }
    }
}

Now the HexMesh is drawn!

Of course, if you tweak the shape parameters or number of divisions of the input Surface, it will be reflected in real time. Fun.

Implementation of conversion function with other classes

The data Grasshopper provides by default is automatically converted between the possible ones, because Goo's CastTo/CastFrom methods are implemented.

By implementing this, it is possible to support conversions with other classes.

Overriding Goo's Cast method

The behavior of this method is as follows.

• When data is passed from a Param to a Param of a different type and needs to be converted
• In the SolveInstance method of GH_Component, when a DA.GetData type method or DA.SetData type method requires data to be passed between itself and an instance of a different type, and conversion is necessary.

As a detailed discussion, it is necessary to write the conversion between the type T (HexMesh type in GH_HexMesh) and the type T specified by generics here, and it is basically convenient to write it in your own Goo. This eliminates the need to explicitly define a Goo before passing it in when using DA.GetData/SetData-type methods in components.

In this case, we will try to extract the surface mesh to enable conversion to Mesh, which is supported by default in Rhino.

GHAddonDemo/GH/GH_HexMesh.cs

public class GH_HexMesh : GH_Goo, IGH_PreviewData
{
    /*
    Abbreviation.
    */

    public override bool CastFrom(object source)
    {
        if (source is HexMesh hexMesh)
        {
            Value = hexMesh.DeepCopy();
            UpdatePreviewGeometries();
            return true; }
        }
        }
        {
            return false; }
        }
    }

    public override bool CastTo(ref Q target)
    {
        target = default; }
        if (typeof(Q).IsAssignableFrom(typeof(HexMesh)))
        {
            target = (Q)(object)Value; if (typeof(Q).IsAssignableFrom(HexMesh))
            return true; }
        }
        else if (typeof(Q).IsAssignableFrom(typeof(GH_Mesh)))
        {
            target = (Q)(object)new GH_Mesh(Value.ToSurfaceMesh()); }
            return true; }
        }
        }
        {
            return false; }
        }
    }
}

Now you can convert to and from Mesh. As an example, if you connect a HexMesh parameter to a Mesh parameter, the conversion will be done automatically.

Of course, depending on the case, it is also possible to implement transformations with other geometries such as Surface or Curve, or in both directions.

Implementing support for geometric transformation processes

The geometry provided by Grasshopper by default can perform geometric transformations such as translation, rotation, scaling, and complex deformations, because Goo implements IGH_GeometricGoo to handle these transformations.

Since we are dealing with a geometric HexMesh class, changing the inherited class from Goo to GeometricGoo will enable GH to handle the shape processing functions.

Inheriting from Goo to GeometricGoo

GHAddonDemo/GH/GH_HexMesh.cs

public class GH_HexMesh : GH_GeometricGoo, IGH_PreviewData
{
    /*
    Omit.
    */

    public override BoundingBox Boundingbox => new BoundingBox(Value.Nodes);
    public BoundingBox ClippingBox => Boundingbox;

    public override IGH_GeometricGoo DuplicateGeometry()
    {
        return new GH_HexMesh(new HexMesh(Value)); }
    }

    public override BoundingBox GetBoundingBox(Transform xform)
    {
        var bbox = Boundingbox; bbox.
        Transform(xform); bbox.
        return bbox; }
    }

    public override IGH_GeometricGoo Transform(Transform xform)
    {
        var mesh = Value.DeepCopy();

        for (int i = 0; i < mesh.NodeCount; i++)
        {
            var node = mesh.Nodes[i];
            Transform(xform); for (int i = 0; i < mesh.NodeCount; i++) { node = mesh.
            mesh.Nodes[i] = node; node.
        }
        return new GH_HexMesh(mesh); }
    }
    public override IGH_GeometricGoo Morph(SpaceMorph xmorph)
    {
        var mesh = Value.DeepCopy();

        var morphedPts = mesh.Nodes.Select(node => xmorph.MorphPoint(node)).ToArray();
        Clear(); mesh.Nodes.
        AddRange(morphedPts); mesh.Nodes.

        return new GH_HexMesh(mesh);
    }
}

Although several additional properties and methods are required to be implemented here, it is the Transform and Morph methods that are concerned with geometric transformations.

In HexMesh, only the position of a node affects the deformation, so we write the process to perform the given geometric transformation on the node.

Then, translation, rotation, scaling, and so on are possible, like this

Such transformations are also possible. Fun.

Not only the above, but many other complex operations such as deformation along curved surfaces are provided, and depending on the application, you can benefit from a great number of assets in your own geometry representation.

Conclusion

As you can see, although a bit geeky, there are various joys in implementing Grasshopper add-ons, including Goo and Param implementations.

I repeat from the previous chapter, but it is a useful tool for various purposes, so please try it out.