FrameCapture - Screen Capture and Video Recorder

Scenes that need clean stills, playable recordings, or interface-aware output tend to run into the same problem: the camera view, the game window, and the UI layer do not always need to be treated the same way. FrameCapture - Screen Capture and Video Recorder is a C++ based library that addresses those jobs directly. It lets you take snapshots of your game viewport at a desired resolution, record your in-game screen, adjust camera depth of field settings for more photographic images, include the UI screen in snapshot or video output, convert the game screen into a texture for UMG image display, and load image files from a hard disc as textures.

That mix makes it more than a simple screenshot button. The library sits at the point where capture, presentation, and interface work overlap. One part is about getting images and video out of a running scene. Another part is about deciding whether the visible result should come only from the viewport or from the entire game window. A third part pushes the captured result back into the project as a texture that can be shown as a UMG image.

FrameCapture and the difference between viewport output and full window capture

The most concrete part of the package is its ability to take a snapshot of the game viewport at a desired resolution. That makes resolution a deliberate choice rather than an afterthought, which is useful when a scene needs a controlled still image instead of whatever happens to be on screen at the current display size. Alongside snapshots, FrameCapture can also record the in-game screen, giving the same workflow a moving-image side instead of limiting the toolset to still capture alone.

The UI option changes the meaning of the capture in an important way. When the UI screen is enabled, the result captures the entire game window. That means the output can include content that is not directly rendered by the game viewport. This is a very specific distinction, and it affects how the tool can be used. If a project needs a pure viewport image, the capture can stay focused on the rendered scene. If it needs menus, overlays, or other visible interface elements in the final still or recording, the UI-enabled route shifts the output to the whole game window.

That split makes FrameCapture useful in more than one production context. A scene artist or developer may want a clean image of the environment itself at a selected resolution. A UI-heavy project may instead need the visible game window exactly as a player sees it, including interface elements. The library supports both approaches without turning them into the same capture mode.

Depth of field in FrameCapture for more photographic images

FrameCapture does not stop at copying what is already on screen. It also gives you a way to adjust camera depth of field settings to create more photographic images. That matters for teams or solo creators who want stills that feel composed rather than merely extracted. A game viewport can contain all the right assets and lighting while still looking flat if the camera treatment is not part of the output process. By exposing depth of field adjustment as part of the capture workflow, the library connects technical output with image presentation.

This is especially relevant for scenes that benefit from selective focus. Character setups, close object views, prop presentation, environmental details, and mood shots all gain something from depth separation. The description does not turn this into a broad camera system; it keeps the promise narrower and more concrete. You can adjust the camera’s depth of field settings so the captured image can lean toward a photographic look. That is a focused but practical enhancement for anyone producing stills from in-engine content.

There is also a workflow advantage in keeping these image decisions close to capture instead of treating them as a separate concern. If the goal is to produce polished viewport snapshots, having resolution control and depth of field adjustment in the same general toolset creates a more direct path from active scene to finished image.

Recording the in-game screen when motion matters more than a single frame

Some projects need more than still output. FrameCapture records your in-game screen, which makes it relevant for scenes whose value only becomes clear in motion. Animation timing, character movement, effects passes, interface behavior, and interactive moments are all better represented through video than through isolated screenshots. The library’s recording role places it in workflows where a static capture would miss the point.

The UI capture option also affects recorded output in the same way it affects snapshots. With UI enabled, the recording captures the entire game window and can show content beyond what is directly rendered by the viewport. That creates two distinct types of recordings. One can emphasize the rendered scene itself. The other can preserve the broader player-facing presentation, including visible interface layers. Depending on the project, either mode could be the more useful one.

Because the feature set explicitly includes both snapshot and video output, the tool can support a consistent capture approach across image and motion work. A creator documenting a level, presenting a feature, testing visible interface flow, or assembling project media would not have to switch between unrelated tools just to move from a still frame to a recorded sequence.

From game screen to texture and UMG image

One of the more interesting parts of FrameCapture is that it does not treat captured output as something that only leaves the project. It also offers a way to convert the game screen into a texture and display it as a UMG image format. That changes the role of capture from external output to internal content. Instead of only saving a result for viewing elsewhere, the screen itself can become material for widgets and interface display inside the project.

This opens up practical interface uses without needing to invent features beyond what is stated. If a project needs the game screen represented inside a widget, this screen-to-texture path is the direct reason FrameCapture stands out. The tags around Widget, Texture, UMG, Blueprint, Camera, Screen, Plugin, and CodePlugin all point toward that intersection between rendering and interface work. The library is not limited to camera output alone; it also helps move screen content into UI presentation.

The same section of functionality includes loading image files from a hard disc as textures. Paired with the screen-to-texture workflow, that creates a simple but useful bridge between live captured imagery and externally stored image content. Inside a project, one side of the library can generate visual output from the game screen, while another side can bring image files in as textures for use inside the project.

Where the UMG and texture workflow fits best

This part of FrameCapture is most relevant when a project needs to show captured visuals inside its own interface. Any scene or toolset that benefits from displaying the game screen as an image in UMG can make use of that conversion path. The ability to load image files from a hard disc as textures adds another layer of flexibility for interface-driven presentation, galleries, previews, or image display workflows that need texture-ready content rather than standalone files.

Who benefits most from FrameCapture - Screen Capture and Video Recorder

FrameCapture is a strong fit for developers and creators who need direct control over how game visuals are captured and presented. Its core audience includes anyone who wants viewport snapshots at a chosen resolution, anyone who needs to record the in-game screen, and anyone whose output may or may not need the UI layer included. It is also relevant for projects where captured visuals are not the endpoint but part of the interface itself, thanks to the option to convert the game screen into a texture and display it as a UMG image.

The library is especially practical when a project crosses between scene presentation and UI work. A clean viewport still, a more photographic shot shaped by depth of field, a full game-window capture with interface visible, and a captured screen reused as a texture all belong to different stages of production, yet they are closely related here. For teams or solo creators working in that overlap, FrameCapture is most useful when the goal is not just to capture a scene, but to decide exactly what layer of the experience should be captured and where that result should appear next.

Related Resources Worth Checking

• Ultimate Engine CoPilot (formerly Ultimate Blueprint Generator)
• MSC Screen & Camera Recorder
• Compiler Booster
• PSD2UMG
• Screen Space Fog Scattering