Hawkdev.games

How To – Building a Modular Minimap in Unreal Engine

· ·

What you’re building & why

This guide walks through a modular minimap architecture built around a Child Actor Component, where: – The minimap camera logic lives in its own Actor – Any character can opt into having a minimap – UI is owned by the HUD / PlayerController layer – Core behavior is data-driven and configurable

The goal isn’t just to “get a minimap working”, but to build one that holds up as your project grows.

Architecture Overview

Before jumping into step-by-step setup, it’s important to understand the overall structure.

At a high level, the system is split into three responsibilities:

Visually, it looks like this:

With this structure in mind, the implementation steps that follow should feel deliberate rather than arbitrary.

Step-by-Step Implementation

The rest of the post proceeds in a strict, practical order:

  1. Create the Render Target
  2. Build the Minimap Actor (camera + capture)
  3. Create the Minimap Widget
  4. Attach the Minimap Actor to a Character via Child Actor Component
  5. Add the Widget through the HUD / PlayerController
  6. Expose tuning variables for iteration
  7. Handle common pitfalls and edge cases

Each step builds directly on the previous one, and no character-specific logic is introduced until the very end.

The remainder of this post walks through the full implementation end to end.

1. Create the Render Target

The minimap camera needs somewhere to render its output. In Unreal, that intermediary is a Render Target.

  1. In the Content Browser, right-click → Texture → Render Target.
  2. Name it RT_Minimap.
  3. Open the Render Target and set:
    1. Size X / Size Y: 512 x 512
    1. Format: RGBA8 (default)

This texture will be written to by the minimap camera and later displayed in the UI. You can increase the resolution later if you want a sharper image, but starting small keeps iteration fast.

2. Build the Minimap Actor

This Actor owns all minimap camera behavior. Characters will never directly manage a SceneCapture.

2.1 Create the Actor

  1. Content Browser → Right-click → Blueprint Class → Actor.
  2. Name it BP_MinimapActor.

This Blueprint will be reused across characters and potentially across projects.

2.2 Add Components

Open BP_MinimapActor and add the following components:

Hierarchy:

2.3 Configure the Spring Arm

Select MinimapSpringArm and configure:

The Spring Arm handles camera height and orientation. Rotating the arm instead of the capture makes zooming and tuning much easier.

2.4 Configure the Scene Capture

Select MinimapCapture and set:

Do not rotate the SceneCapture itself; it inherits rotation from the Spring Arm.

3. Create the Minimap Widget

The UI portion of the minimap is intentionally simple: it only displays the Render Target.

  1. Content Browser → Right-click → User Interface → Widget Blueprint.
  2. Name it W_Minimap.
  3. Open the widget and add an Image to a Canvas Panel.
  4. Set the Image Brush to RT_Minimap.
  5. Anchor and size the Image as required

No gameplay logic belongs in this widget.

4. Attach the Minimap Actor to a Character

Instead of spawning or managing the minimap from the character, we attach it using a Child Actor Component.

  1. Open your character Blueprint.
  2. Add Child Actor Component → rename to MinimapActorComponent.
  3. Set Child Actor Class to BP_MinimapActor.

Important: Orthographic Height Offset

Set the Child Actor Component Relative Location to 0, 0, 500. Orthographic captures have a finite depth volume. Lifting the minimap actor slightly prevents tall geometry from being clipped when the player changes elevation.

5. Add the Minimap to the HUD Layer

The minimap widget should be created by the PlayerController or HUD, never by the character.

5.1 Simple Setup (PlayerController – acceptable for small projects)

This approach is fine for prototypes or very small games.

  1. Create a PlayerController Blueprint if you do not already have one.
  2. Open the PlayerController and, on BeginPlay:
  3. Create Widget → W_Minimap
  4. **Add to Viewport`
  5. Assign this PlayerController in your GameMode and verify the level is using it.

This keeps UI out of the character, but it does not scale well once you have multiple HUD elements.

5.2 Scalable Setup (HUD + Root Widget)

This is the recommended approach for any project that expects to grow beyond a single HUD element.

The core idea is:

5.2.1 Create a Root HUD Widget

  1. Content Browser → Right-click → User Interface → Widget Blueprint.
  2. Name it W_Root.
  3. Open W_Root and ensure it contains a Canvas Panel as the root.

W_Root represents the full-screen HUD container.

5.2.2 Add the Minimap to the Root Widget

Inside W_Root:

  1. Add W_Minimap as a child widget of the Canvas Panel.
  2. Position and anchor the minimap appropriately (for example, bottom-right corner).
  3. Apply padding, scaling, or safe-zone adjustments as needed.

At this point, the minimap is just another composable UI element inside the HUD.

5.2.3 Create a HUD Blueprint

  1. Content Browser → Right-click → Blueprint Class.
  2. Search for HUD.
  3. Name it HUD_Minimap.

The HUD Blueprint exists solely to bootstrap the UI.

5.2.4 Spawn the Root Widget from the HUD

Open HUD_Minimap and, on BeginPlay:

  1. Create Widget → Class: W_Root
  2. Add to Viewport

The HUD now owns the entire UI tree.

5.2.5 Assign the HUD in the GameMode

  1. Open your GameMode Blueprint.
  2. Set HUD Class = BP_HUD.
  3. Confirm your level uses this GameMode (World Settings).

From this point forward, all HUD elements — including the minimap — are created automatically and consistently.

5.2.6 Why This Setup Is Preferred

Expose Tuning Variables

To make the minimap designer-friendly, expose key settings as variables on BP_MinimapActor:

Apply these in the Construction Script.

Because the minimap is a Child Actor Component, these variables appear under Child Actor Template on the character, allowing per-character tuning without modifying logic.

Common Pitfalls and Fixes

Most minimap issues stem from orthographic depth assumptions or ownership confusion; this architecture avoids both.

Closing Thoughts

This approach trades a small amount of upfront structure for long-term clarity and reuse. Once stabilized, this minimap system is an excellent candidate for packaging as an Unreal Engine plugin, allowing you to drop it into future projects with minimal setup.

The key takeaway isn’t the minimap itself — it’s designing systems that scale past the first prototype.