GameObject go;
RectGrid grid = go.AddComponent<RectGrid>();
// Add a renderer for display
go.AddComponent<Parallelepiped>()

// Set up the grid for 2:1 dimetric graphics
grid.spacing  = new Vector3(2, 1, 1);
grid.shearing = new Vector6(-1/2, 0, 2, 0, 0, 0);
// Vector6 is a custom type, not part of the Unity API

All custom types reside in custom namespaces to protect from name collisions with your own types or possible future types from Unity. The namespace import was omitted for brevity.

With the grid set up in your scene you are ready to go. You now have access to a vast and rich API you can use for your own application.

This allows you to write your game logic thinking entirely in grid coordinates while the game plays out in world coordinates. Then just let Grid Framework convert the result back into world space and you're ready to go.

Let's say we wanted to move a unit from one point in the grid to another. If we know the grid coordinates we can compute the world coordinates and pass them to your movement function:

Vector3 origin      = grid.gridToWorld(originInGrid    );
Vector3 destination = grid.gridToWorld(desinationInGrid);
MoveUnit(from: origin, to: destination);

A common task is snapping things to a grid, for example when the player is trying to place building in a strategy game. This is where the AlignTransform extension method comes into play:

Transform t;
// Move the object the usual way with no snapping first
// And then correct its position by snapping
grid.AlignTransform(t);

Usually the AlignTransform method is smart enough to do what you want, but if you want more control you can use the lower-level methods to build your own rules.

In fact, the distance doesn't even impact our performance, all calculations always run at the same speed. Of course Grid Framework's infinity is limited to what Unity is capable of and there is no true infinity on computers, but Grid Framework can get as close to it as possible in Unity. Best of all, grids are in 3D and move and, being components, rotate with the object they are attached to; if you need a grid's rotation or position just get the information from the Transform component, like any other object in Unity.

// This works as you would expect
Quaternion gridRotation = grid.transform.rotation;

This keeps the performance impact to a minimum. It makes Grid Framework suitable for desktop devices as well as mobile phones and tablets where memory is more constrained than on desktop computers.

Redering is done using Renderer components and Unity's low-level rendering capabilities, so it is blazing fast even on mobile devices. Keep in mind though, that while the rendering is cheap, getting points for large and very dense grids might not be. If your grids are exceptionally large you will be glad to know that Grid Framework can compute points for use with the popular Vectrosity add-on.

// Set the rendering range and colour
renderer.From   = new Vector3( 0,  0, 0);
renderer.To     = new Vector3(10, 10, 5);
renderer.ColorX = Color.black;

Using Vectrosity on its own would require you to compute all end points yourself and then order them in the proper way so they appear in the right order; Grid Framework can do the job for you by just calling the built in method. For more information on Vectrosity please visit Vectrosity's web site. Vectrosity and Grid Framework are entirely unrelated products and I am in no way affiliated with the author of Vectrosity.

// Grid Framework gets the points and then Vectrosity takes over
var points = grid.GetVectrosityPoints();
gridLine = new Vectrosity.VectorLine("My lines", points, lineColors, lineMaterial, lineWidth);

The entire API, except for a few instances, is available as Playmaker actions. You can use these action as building blocks in your state machines to get and set properties and call methods. Due to technical reasons any properties that rely on types not built into Unity cannot be set or gotten; they will be added if Playmaker becomes capable of handling custom types.

The grid classes have their own custom inspector and you can create grids from scratch, add a grid component to any of your Game Objects or browse the documentation right from you menu bar, just like any other component in Unity.