UMG/Slate Coordinate Spaces

1. The Five Spaces

Each space has a different origin, unit size, and purpose. They nest from the outermost (the OS desktop) down to each individual widget. Sections 2–6 cover each space in detail.

2. Screen / Desktop Space

Screen space is the raw OS coordinate system. Its origin is the top-left corner of the primary monitor, and it spans the entire virtual desktop (all monitors combined). Units are device pixels — no DPI scaling applied. UE exposes it mainly for mouse position queries and for ingesting coordinates that come from a platform SDK or external tool.

Mouse position functions

Converting screen → widget

FVector2D ScreenPos = /* coord from platform SDK or OS input event */;
FVector2D LocalCoord;

// bIncludeWindowPosition: pass true in windowed mode, false in fullscreen
USlateBlueprintLibrary::ScreenToWidgetLocal(
    GetWorld(),
    MyWidget->GetCachedGeometry(),
    ScreenPos,
    LocalCoord,
    true   // <-- set correctly for windowed vs fullscreen!
);

3. Absolute / Window Space

"Absolute" in the Slate/UMG API means relative to the Slate root window's top-left corner — not the desktop, and not the game viewport. It is computed by accumulating layout transforms from the root widget down to the widget in question (FGeometry::AccumulatedLayoutTransform). Render transforms (rotation, scale, skew) are not included.

In a standalone game the Slate root window is the game window, so Absolute ≈ Window. In PIE the Slate root window is the entire editor window — absolute coordinates are therefore measured from the editor window's corner, not the game viewport panel's corner.

Key functions

4. Viewport Space (Pixel vs Scaled)

The game viewport is an SViewport Slate widget. Its top-left corner is the origin of viewport space. Crucially, the viewport does not have to fill the window:

• PIE (Play In Editor): the viewport is a panel embedded inside the editor window. The editor chrome — tabs, toolbar, content browser — surrounds it. The viewport's pixel origin is wherever that panel starts inside the editor window.
• Sub-viewport configurations: a game can render to a viewport that is smaller than the window (e.g. a picture-in-picture inset, or a split-screen sub-rect configured via UGameViewportClient).
• Standalone game: in the typical case the viewport fills the window and viewport pixel space equals absolute/window space.

Viewport space itself comes in two flavours that are always returned as a pair by conversion functions:

FVector2D PixelPos, ViewportPos;
USlateBlueprintLibrary::LocalToViewport(
    GetWorld(), MyWidget->GetCachedGeometry(),
    FVector2D(0.f, 0.f),  // local point (widget origin)
    PixelPos,             // OUT: raw device pixels
    ViewportPos           // OUT: Slate units (DPI-scaled)
);

// Relationship between the two:
float DPIScale = UWidgetLayoutLibrary::GetViewportScale(GetWorld());
// ViewportPos == PixelPos / DPIScale  (approximately)

// Viewport logical size (Slate units):
FVector2D LogicalSize = UWidgetLayoutLibrary::GetViewportSize(GetWorld());
// Physical pixel size = LogicalSize * DPIScale

5. Local Space

Local space is the coordinate system internal to a single widget. The origin (0, 0) is the widget's own top-left corner. The X axis grows right and Y grows down. The "size" of the space is the widget's FGeometry::Size — a local point at (Size.X, Size.Y) is exactly the bottom-right corner.

Points outside those bounds are perfectly valid values in local space — they just describe positions beyond the widget's edges. A point at (-10, 5) is 10 units to the left of the widget's left edge. You'll encounter these when you call AbsoluteToLocal on an absolute coordinate that isn't inside the widget, or when doing drag-offset math.

What are Slate units?

Slate units are resolution-independent layout units — the same concept as CSS pixels, iOS "points", or Android "dp/dip". One Slate unit always represents the same physical size on screen regardless of monitor resolution or pixel density. The DPI scale factor (FGeometry::Scale) bridges them to actual device pixels:

device_pixels = slate_units × FGeometry::Scale

// Examples:
//   1× DPI (standard 1080p):  100 Slate units = 100 device pixels
//   2× DPI (Retina / 4K HiDPI): 100 Slate units = 200 device pixels
//   1.5× DPI (some 1440p setups): 100 Slate units = 150 device pixels

So Slate units are not always 1:1 with device pixels — only at 1× DPI. However they are always 1:1 with Viewport Position (the scaled viewport coordinate from §4), because both use the same DPI-independent unit. The practical benefit: if you hardcode a widget position in Slate units (e.g. SetPositionInViewport(FVector2D(960, 540))), it will visually land at the same screen position on every DPI setting — the engine multiplies by the DPI scale to get the final pixel placement.

Getting a widget's geometry

// C++ — call from NativeTick, NOT from NativeConstruct
const FGeometry& Geom = MyWidget->GetCachedGeometry();

// The widget's size in Slate units
FVector2D WidgetSize = FVector2D(Geom.Size);

// Centre of the widget in local space
FVector2D Centre = WidgetSize * 0.5f;

// Blueprint — "Get Cached Geometry" node on any Widget reference

Converting local ↔ absolute

FVector2D LocalPt    = FVector2D(50.f, 20.f);
FVector2D AbsPoint   = Geom.LocalToAbsolute(LocalPt);    // local → window
FVector2D BackLocal  = Geom.AbsoluteToLocal(AbsPoint);   // window → local

// A point outside the widget — valid, just off the edge:
FVector2D OutsidePt  = FVector2D(-5.f, Geom.Size.Y + 10.f);  // above-left + below-right
FVector2D AbsOutside = Geom.LocalToAbsolute(OutsidePt);       // still works fine

6. Paint / Render Space

When you apply a render transform to a widget via SetRenderTransform, SetRenderTransformAngle, or SetRenderScale, you introduce a paint space that diverges from local/layout space. The widget looks rotated or scaled on screen, but the layout engine and hit-test system still use the original unmodified geometry. Render transforms are purely a rendering effect.

7. FGeometry Reference

FGeometry is the core struct that encodes a widget's position, size, and accumulated transforms. You retrieve it from GetCachedGeometry() and pass it into conversion functions.

8. Multiple Viewports & AddToPlayerScreen

Widgets can be added to the full game viewport or to a per-player screen area. In split-screen these are different regions of the window; in single-player they cover the same area but have different geometry origins.

9. Converting Between Spaces — C++

LocalToViewport — annotated example

// Call from NativeTick or a mouse-event handler
const FGeometry& Geom = MyWidget->GetCachedGeometry();
FVector2D LocalPt = FVector2D(Geom.Size) * 0.5f;  // widget centre in Slate units

FVector2D PixelPos;     // raw device pixels — use for render targets
FVector2D ViewportPos;  // DPI-scaled Slate units — use for SetPositionInViewport

USlateBlueprintLibrary::LocalToViewport(
    GetWorld(), Geom, LocalPt,
    PixelPos,    // OUT 1
    ViewportPos  // OUT 2
);

// Never pass PixelPos to SetPositionInViewport — wrong on HiDPI
MyOtherWidget->SetPositionInViewport(ViewportPos);

Scalar / vector helpers

When converting a distance or size (not a position) between spaces, use the scalar/vector variants — they avoid introducing any translation offset:

// Convert a 20-unit absolute offset to local-space units
float LocalOffset = USlateBlueprintLibrary::Scalar_AbsoluteToLocal(Geom, 20.f);

// Convert a local-space drag delta to absolute
FVector2D AbsDelta = USlateBlueprintLibrary::Vector_LocalToAbsolute(Geom, DragDelta);

10. Converting Between Spaces — Blueprint

All conversion functions are available as Blueprint nodes. The graphs below show each conversion pattern in a realistic context.

Local → Viewport (both pixel and scaled)

Use Get Cached Geometry on a widget reference, then feed it into Local to Viewport from the Slate Blueprint Library. The node has two output pins — Pixel Position and Viewport Position. Use Viewport Position for widget placement; Pixel Position for render targets or hardware cursor APIs.

Absolute → Viewport

Absolute to Viewport converts a window-space absolute coordinate to both viewport pixel and scaled positions. Useful when receiving an absolute coord from another system and needing it for widget placement.

Screen → Widget Local (with bIncludeWindowPosition)

Screen to Widget Local converts an OS screen coordinate into a specific widget's local space. Set Include Window Position to true in windowed mode to subtract the window's desktop offset.

Mouse position in viewport space

The simplest "where is the mouse in my viewport" pattern — Get Mouse Position on Viewport from Widget Layout Library returns a DPI-scaled Viewport Position directly, no geometry needed.

World 3D → Viewport (worldspace UI / nameplates)

Project World Location to Widget Position converts a 3D world position to a 2D viewport pixel position — the core of any worldspace nameplate or ping system. Enable Player Viewport Relative when using AddToPlayerScreen so the result is relative to the player's sub-rect in split-screen.

11. Common Gotchas