Grasshopper data types.

Grasshopper is an application that deals with a lot of different types of data. These data types can come from 6 different sources and some of them will not be known when Grasshopper is written and compiled. The six potential sources are:

1. Primitive types such as Booleans, Integers, Colors, Strings, etc. Grasshopper uses these types itself a lot.
2. Other .NET Framework types such as System.Drawing.PointF or System.Collections.Generic.HashSet<T>. Grasshopper does not use these types to during component <-> component communication, but someone else might.
3. RhinoCommon types such as Point3d, Circle, Plane, Brep, Curve etc. Many of these are used natively, but certainly not all of them.
4. Types defined in Grasshopper itself.
5. Types defined in plug-ins for Grasshopper.
6. Types defined in VB/C#/Python scripts that run inside Grasshopper.

Although clearly some of these are known to the developer during the time of writing, not all of them can be. Yet Grasshopper still needs to be able to interpret and use types it may know nothing about. Some of the things Grasshopper needs to be able to do with data of any type are:

1. Convert it to text so tooltips and panels can be populated with useful descriptions of data.
2. Convert it to and from other types.
3. Duplicate data so we can change it without affecting the original.
4. Test data for validity.
5. Save types to *.gh files and load them back in. (note: this works especially poorly at the moment.)
6. Preview geometric types in the viewport.
7. Bake geometric types to the Rhino document.
8. Transform geometric types.
9. Calculate bounding boxes of geometric types.
10. Be able to store null states of each type.

To overcome the problem of (A) needing to do so many things while (B) knowing nothing about the types in advance an interface is defined in the Grasshopper SDK and all data which is stored inside parameters must implement this interface. This allows GH to do the things from the second list to all the types from the first list.

The IGH_Goo interface is is usually nothing more than a wrapper around the actual data which provides a bunch of functionality for whatever it wraps. For example take the primitive Boolean (or bool in C#). It's a structure so it can never be null, and it can only exist in either a true or a false state.

GH uses booleans a lot so it provides an IGH_Goo implementation for Boolean. This wrapper class tells GH that a boolean value can be converted into an integer (false -> 0, true -> 1), into a colour (false -> black, true -> white), into a string (false -> "false", true -> "true) and so on. The wrapper class also knows how to write and read boolean values to and from *.gh files, and because we're now dealing with a wrapper class we can have null instances in a collection of boolean values. The wrapper doesn't tell GH how to preview or bake booleans, because booleans are not a geometric type of data.

Because so many data types are not in any way geometric, there is a second interface called IGH_GeometricGoo which extends IGH_Goo with stuff like transforming, bounding-boxing etc.

Almost always component developers and scripters can ignore any of the IGH_Goo types, because they are mostly used for internal bookkeeping. However sometimes a developer will either want to access the functionality that goo provides or they wish to inject a new, previously unknown type of data into a Grasshopper file. In these cases some knowledge of IGH_Goo and its derived interface and classes is required.