Procedural Minimap

// (C) Matthew Inglis 2019
    
using NaughtyAttributes;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
    
public class MiniMap : MonoBehaviour
{
    #region ----CONFIG----
    [SerializeField, Required] protected RectTransform m_PlayerIcon;
    [SerializeField, Required] protected Transform m_PlayerCar;
    [SerializeField] protected float m_RotationOffset;

    [Space]
    [SerializeField, Required] protected RectTransform m_Background;

    [Space]
    [SerializeField] protected string m_RoadTag;

    [Space]
    [SerializeField] protected float m_Zoom = 1f;
    [SerializeField] protected float m_Margin = 20f;

    [SerializeField, ReorderableList] protected MiniMapElement[] m_MiniMapElements;

    [SerializeField, Required] protected Transform m_ObjectiveLocation;
    [SerializeField, Required] protected Image m_ObjectiveIcon;
    [SerializeField] protected Sprite m_ObjectiveIconInMinimap;
    [SerializeField, Required] protected Sprite m_ObjectiveIconOnEdge;
    [SerializeField] protected float m_ObjectiveMaxRadius;

    [System.Serializable]
    protected struct MiniMapElement
    {
        public string tag;
        public Sprite sprite;
        public Color color;
    }
    #endregion

    #region ----STATE----
    private Bounds m_Bounds;
    #endregion

    private void Start()
    {
        m_Bounds = CalculateWorldBounds();

        // Scale background to the same aspect ratio as the bounds.
        // Times 2 to go from half extents to size
        m_Background.sizeDelta = new Vector2(m_Bounds.extents.x * m_Zoom + m_Margin, m_Bounds.extents.z * m_Zoom + m_Margin) * 2f;

        for (int i = 0; i < m_MiniMapElements.Length; i++)
        {
            SpawnElements(m_MiniMapElements[i].tag, m_MiniMapElements[i].sprite, m_MiniMapElements[i].color);
        }
    }

    private void Update()
    {
        // Player icon rotation matches vehicle
        m_PlayerIcon.eulerAngles = new Vector3(0f, 0f, -m_PlayerCar.eulerAngles.y + m_RotationOffset);

        SetMapPosition(GetNormalizedPlayerPosition());
        SetObjectivePosition();
    }

    /// <summary>
    /// Calculates the bounds of all roads in the scene.
    /// </summary>
    private Bounds CalculateWorldBounds()
    {
        // TODO: include all elements

        // Find all roads
        GameObject[] roads = GameObject.FindGameObjectsWithTag(m_RoadTag);

        // Start from the first road.
        // This ensures the bounds center is contained in the bounds itself.
        Bounds bounds = new Bounds(roads[0].transform.position, Vector3.zero);
        for (int i = 0; i < roads.Length; i++)
        {
            // Calculate the bounds of these roads
            bounds.Encapsulate(roads[i].transform.position);
        }

        return bounds;
    }

    private void SpawnElements(string tag, Sprite sprite, Color color)
    {
        // Find all the elements.
        GameObject[] elements = GameObject.FindGameObjectsWithTag(tag);

        for (int i = 0; i < elements.Length; i++)
        {
            // Create a new element in the map.
            GameObject element = new GameObject($"{tag}-{i.ToString("00")}");
            element.transform.SetParent(m_Background);

            // Add the image.
            RectTransform rect = element.AddComponent<RectTransform>();
            Image image = element.AddComponent<Image>();

            image.color = color;
            image.sprite = sprite;

            // Find the bounds of this mesh
            Bounds bounds = GetMeshExtents(elements[i].transform);

            // Position the image.
            rect.anchoredPosition = WorldToMapPoint(bounds.center);

            // Rotate the image.
            float angle = Mathf.Repeat(elements[i].transform.rotation.eulerAngles.y, 360f);

            // Fix a weird issue where objects with euler angles (0, 90, 0) or (0, 270, 0) would
            // be flipped by 180 degrees. Not sure what causes this.
            const float THRESHOLD = 2f;
            if (Mathf.Abs(angle - 90f) < THRESHOLD || Mathf.Abs(angle - 270f) < THRESHOLD) angle += 180f;

            rect.localRotation = Quaternion.Euler(0f, 0f, angle);

            // Set scale
            rect.localScale = Vector3.one;
            rect.sizeDelta = WorldToMapDimensions(bounds.extents);
        }
    }

    /// <summary>
    /// Returns the player position from -1, 1 on X and Z axes.
    /// </summary>
    private Vector2 GetNormalizedPlayerPosition()
    {
        Vector3 position = m_PlayerCar.position - m_Bounds.center;

        float extentsX = Mathf.Max(m_Bounds.extents.x, 10f);
        float extentsZ = Mathf.Max(m_Bounds.extents.z, 10f);

        return new Vector2(position.x / extentsX, position.z / extentsZ);
    }

    /// <summary>
    /// Sets the position of the background.
    /// </summary>
    /// <param name="position">Must be normalized.</param>
    private void SetMapPosition(Vector2 position)
    {
        // Divide by 2 for half extents
        float backgroundX = m_Bounds.extents.x * m_Zoom;
        float backgroundY = m_Bounds.extents.z * m_Zoom;

        // Make sure it's not smaller than the width of a road.
        backgroundX = Mathf.Max(backgroundX, 10f * m_Zoom);
        backgroundY = Mathf.Max(backgroundY, 10f * m_Zoom);

        // Backgrounds moves opposite to car
        Vector3 playerDisplacementFromOrigin = new Vector3(-position.x * backgroundX, 0f, -position.y * backgroundY);
        Vector3 rotatedDisplacement = Quaternion.AngleAxis(-45f, Vector3.up) * playerDisplacementFromOrigin;

        m_Background.anchoredPosition = new Vector2(rotatedDisplacement.x, rotatedDisplacement.z);
    }

    private void SetObjectivePosition()
    {
        Vector3 positionRelativeToPlayer = m_ObjectiveLocation.position - m_PlayerCar.position;
        Vector2 mapSpacePosition = new Vector2(positionRelativeToPlayer.x, positionRelativeToPlayer.z) * m_Zoom;
        Vector2 rotatedPosition = Quaternion.AngleAxis(m_RotationOffset, Vector3.forward) * mapSpacePosition;

        // Change the icon when the objective is on the edge.
        if (rotatedPosition.magnitude > m_ObjectiveMaxRadius) m_ObjectiveIcon.sprite = m_ObjectiveIconOnEdge;
        else m_ObjectiveIcon.sprite = m_ObjectiveIconInMinimap;

        // Rotate towards the center
        float angle = Quaternion.FromToRotation(Vector3.right, -rotatedPosition).eulerAngles.z + 90f;
        m_ObjectiveIcon.rectTransform.eulerAngles = new Vector3(0f, 0f, angle);

        // Restrict it to the edge of the minimap.
        rotatedPosition = Vector2.ClampMagnitude(rotatedPosition, m_ObjectiveMaxRadius);

        m_ObjectiveIcon.rectTransform.anchoredPosition = rotatedPosition;
    }

    private Vector2 WorldToMapPoint(Vector3 worldPosition)
    {
        Vector3 positionRelativeToBoundsCenter = worldPosition - m_Bounds.center;
        return new Vector2(positionRelativeToBoundsCenter.x, positionRelativeToBoundsCenter.z) * m_Zoom;
    }

    private Vector2 WorldToMapDimensions(Vector3 meshExtents)
    {
        // x2 for half extents -> dimensions
        return new Vector2(meshExtents.x, meshExtents.z) * m_Zoom * 2f;
    }

    /// <summary>
    /// Get the mesh extents of the object including all child objects.
    /// </summary>
    private Bounds GetMeshExtents(Transform target)
    {
        // Look for all children
        Transform[] children = target.GetComponentsInChildren<Transform>();

        // Find all meshes in the children
        List<MeshRenderer> meshes = new List<MeshRenderer>();
        for (int i = 0; i < children.Length; i++)
        {
            MeshRenderer mesh = children[i].GetComponent<MeshRenderer>();
            if (mesh) meshes.Add(mesh);
        }

        // No meshes found - this object is empty.
        if (meshes.Count == 0) return default;

        // Initialize with the first mesh
        Bounds bounds = meshes[0].bounds;

        // Get the bounds of all meshes
        for (int i = 0; i < meshes.Count; i++)
        {
            bounds.Encapsulate(meshes[i].bounds);
        }

        return bounds;
    }
}