### Unity/C# - Grids - Simple Grid Segment struct

This is a simple grid struct using Unity.Mathematics. It uses most of the concepts I presented before, but this time each instance can have an offset to the world. This allows different grids to have different offsets as half-planes.

using UnityEngine; using Unity.Mathematics; using System; [System.Serializable] public struct GridSeg { /// <summary> /// Grid right-vector in world space /// </summary> [SerializeField] private float2 rightVector; /// <summary> /// Grid up-vector in world space /// </summary> [SerializeField] private float2 upVector; /// <summary> /// Amount of cells in right and up direction /// </summary> [SerializeField] private int2 size; /// <summary> /// offset in world-space from origin (half-plane) /// </summary> [SerializeField] private float2 offset; /// <summary> /// Matrix to convert from grid-space to world-space /// </summary> public float3x3 GridToWorldMatrix => new float3x3( new float3(rightVector, 0), new float3(upVector, 0), new float3(offset, 1)); public float2 Right => rightVector; public float2 Up => upVector; public float2 Left => -rightVector; public float2 Down => -upVector; public int2 Size => size; public float2 Offset => offset; /// <summary> /// Global basic directions in grid-space /// </summary> public static readonly int2 GridRight = new int2(1, 0); public static readonly int2 GridLeft = new int2(-1, 0); public static readonly int2 GridUp = new int2(0, 1); public static readonly int2 GridDown = new int2(0, -1); /// <summary> /// Global digonal directions in grid-space /// Start at top right, moving counter-clockwise /// </summary> public static readonly int2[] Diagonals = new int2[] { GridRight + GridUp, GridLeft + GridUp, GridLeft + GridDown, GridRight+ GridDown }; /// <summary> /// linearize the 2d coord to 1d. First rows, then 2nd row, etc.. each gridcoord has a unique index /// </summary> /// <param name="gridCoord">coordinate in grid-space</param> /// <returns>linearized index</returns> public int Linearize(int2 gridCoord) => Contains(gridCoord) ? gridCoord.x + gridCoord.y * size.x : -1; /// <summary> /// Total amount of cells in the grid /// </summary> public int CellCount => size.x * size.y; /// <summary> /// Corner points in grid-space (cells at the end) /// Start at top right, moving counter-clockwise /// </summary> public int2[] GridCorners => new int2[] { new int2(size.x-1, size.y-1), new int2(0, size.y-1), new int2(0,0), new int2(size.x-1,0) }; /// <summary> /// world-space grid corners (world-corners of the grid-corner cells) /// Start at top right, moving counter-clockwise /// </summary> public float2[] GridWorldCorners => new float2[] { TransformPoint(GridCorners[0]) + TransformDirection(Diagonals[0]) * 0.5f, TransformPoint(GridCorners[1]) + TransformDirection(Diagonals[1]) * 0.5f, TransformPoint(GridCorners[2]) + TransformDirection(Diagonals[2]) * 0.5f, TransformPoint(GridCorners[3]) + TransformDirection(Diagonals[3]) * 0.5f }; /// <summary> /// Iterate through the world points (cell center), right them up /// </summary> public System.Collections.Generic.IEnumerable<float2> WorldPoints { get { foreach (var gridPoint in GridPoints) yield return TransformPoint(gridPoint); } } /// <summary> /// Iterate through the grid points, right them up /// </summary> public System.Collections.Generic.IEnumerable<int2> GridPoints { get { for (int i = 0; i < size.x; i++) for (int j = 0; j < size.y; j++) yield return new int2(i, j); } } /// <summary> /// Transform a direction from grids-pace to world-space /// </summary> /// <param name="gridDirection">grid-space direction</param> /// <returns>world-space direction</returns> public float2 TransformDirection(int2 gridDirection) => math.mul(GridToWorldMatrix, new float3(gridDirection.x, gridDirection.y, 0)).xy; /// <summary> /// Transform a point from grids-pace to world-space /// </summary> /// <param name="gridPoint">grid-space point</param> /// <returns>world-space point</returns> public float2 TransformPoint(int2 gridPoint) => math.mul(GridToWorldMatrix, new float3(gridPoint.x, gridPoint.y, 1)).xy; /// <summary> /// Transform a direction from world-space to grid-space /// </summary> /// <param name="worldDirection">world-space direction</param> /// <returns>grid-space direction</returns> public int2 TransformDirection(float2 worldDirection) => new int2(math.round(math.mul(math.inverse(GridToWorldMatrix), new float3(worldDirection, 0)).xy)); /// <summary> /// Transform a point from world-pace to grids-space /// </summary> /// <param name="worldPoint">world-space point</param> /// <returns>grids-space point</returns> public int2 TransformPoint(float2 worldPoint) => new int2(math.round(math.mul(math.inverse(GridToWorldMatrix), new float3(worldPoint, 1)).xy)); /// <summary> /// Check if a world-point is inside the grid /// </summary> /// <param name="worldPoint">the point in world-space</param> /// <returns>true if the point is within grid boundaries</returns> public bool Contains(float2 worldPoint) { return Contains(TransformPoint(worldPoint)); } /// <summary> /// Check if a grid-point is inside the grid bounds /// </summary> /// <param name="gridPoint">the point in grid-space</param> /// <returns>true if the point is within grid boundaries</returns> public bool Contains(int2 gridPoint) { return gridPoint.x >= 0 && gridPoint.y >= 0 && gridPoint.x < size.x && gridPoint.y < size.y; } /// <summary> /// Return world corners for a certain grid point /// </summary> /// <param name="gridPoint">tthe grid-space point</param> /// <returns>world-space corner points</returns> public float2[] WorldCornersForGridPoint(int2 gridPoint) { var center = TransformPoint(gridPoint); return new float2[] { center + TransformDirection(Diagonals[0]) * 0.5f, center + TransformDirection(Diagonals[1]) * 0.5f, center + TransformDirection(Diagonals[2]) * 0.5f, center + TransformDirection(Diagonals[3]) * 0.5f }; } public static implicit operator RectInt(GridSeg seg) { return new RectInt(0, 0, seg.size.x, seg.size.y); } }

The picture shows in red the grid points, blue grid point corners and green grid corners. These 2 half-plane grid segments exist in the same continuous 2D space. It also provides functions to transform from world-space to grid-space and grid-space to world-space by using matrices (float2 is considered world-space and int2 grid-space).

If you want the closest grid-point to a world-point, just transform from world to grid.

Now, following the MVC pattern, let's make a View for the GridSeg Model.

using Unity.Mathematics; using UnityEngine; public class GridGizmos : MonoBehaviour { public GridSeg gridSeg; private void OnDrawGizmos() { Gizmos.color = Color.red; foreach (var graphVertex in gridSeg.WorldPoints) { Gizmos.DrawWireSphere(new Vector2(graphVertex.x, graphVertex.y), 0.1f); } Gizmos.color = Color.blue; foreach (var gridPoint in gridSeg.GridPoints) { foreach (var corner in gridSeg.WorldCornersForGridPoint(gridPoint)) Gizmos.DrawWireSphere(new Vector2(corner.x, corner.y), 0.1f); } Gizmos.color = Color.green; foreach (var worldPoint in gridSeg.GridWorldCorners) { Gizmos.DrawWireSphere(new Vector2(worldPoint.x, worldPoint.y), 0.1f); } var pos = new float2(transform.position.x, transform.position.y); if (!gridSeg.Contains(pos)) Gizmos.color = Color.white; else Gizmos.color = Color.magenta; Gizmos.DrawWireSphere(transform.position, 0.1f); var snappedToGrid = gridSeg.TransformPoint(pos); var snappedCenter = gridSeg.TransformPoint(snappedToGrid); Gizmos.color = Color.cyan; Gizmos.DrawLine(new Vector3(pos.x,pos.y), new Vector3(snappedCenter.x, snappedCenter.y)); } }

GridSeg is the model. The variable gridSeg is the data and the class GridGizmos is the view.

Why a struct? Well, 2 grid segments, with the same offset, same vectors and same size are essentially the same.

## Comments

## Post a Comment