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);
    }
}


2 instances of grid segments

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));
    }
}


Simple grid gizmos draw

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

Popular posts from this blog

Unity3D/C# - Asynchronous Programming - Coroutines vs await/async

First, let me talk a little about Asynchronous Programming. Async programming is basically to run program logic independently of the main thread. This means that if your logic running asynchronously get stuck into a loop or processing something it won't freeze the main thread.

Async programming is mainly used with multithreading. In many languages, you have native high-level ways to represent a separate thread from the main thread and send some work for it to do.

What does it have to do with Coroutines in Unity?

Well, Coroutines are a workaround that Unity made in order to allow people to easily write async code. But keep in mind, Coroutines are not multithreaded.

Now let's look a little into the Coroutine API.

public IEnumerator SomeCoroutine() { //... do something yield return null; yield break; } Well, coroutines are basically methods that return an IEnumerator. So, in order to explain better how Unity's Coroutines work we need to take a loot into IEnumerator.

…
Read more

C# - Simple Graph Interfaces and a MeshGraph

In a previous post about grids, I declared some interfaces to deal with graphs in an effort to explain how the grid segment could be treated as a graph.
Now I'm going to step further and define some generic graph interfaces as well as a MeshGraph that implements it based on the Mesh data structure from Unity3D.

To start, a vertex in a graph can be anything. So it will be an open type parameter for all interfaces.

An edge is a connection between 2 vertices, and as such, it can be defined as:

/// <summary> /// An edge is simply a conection between 2 vertexes /// </summary> /// <typeparam name="TVertex">Vertex Type</typeparam> public interface IGraphEdge<TVertex> : IEquatable<IGraphEdge<TVertex>> { TVertex VertexA { get; } TVertex VertexB { get; } }
Now, let's move to the graph. Starting with a read-only graph.

/// <summary> /// A read-only graph is a collection of vertices with methods to get the edges /// </sum…
Read more

Tools and Property Drawers

Image
Hi :)

I think there 2 kinds of tools that help development. Tools that speed up processes and tools that help visualize data. For the first type, most of the time they specific to a given project and they are usually reused or adapted for similar projects. The second type is more generic, they are specific for some data but different projects deal with a common data format.

In Unity3D we have Custom Editors and Property Drawers. Custom Editors are more commonly used for the first type of tools. They include new windows, custom inspectors are custom Scene GUIs. Property drawers are more of the second type, they are just some fancy way to show certain data.

Well, I think visualization is power and that everyone should know how to use Property Drawers since they are easy, fast and helps you and others understand whats is going on in the game.

Let's start with a simple Interval struct. Most games make use of some kind of interval for many variables, usually referred as resources (e.g.…
Read more