How to Implement a Performant VR Weapon Scope in Unreal Engine

The Problem: Scopes Kill VR Frame Rates

Every VR shooter needs weapon scopes. But the standard Unreal Engine approach - SceneCaptureComponent2D - renders the entire scene a second time every frame. In VR, where you already render two eyes at 90 Hz, that extra scene render can easily push you over budget and cause reprojection.

Common workarounds all have tradeoffs:

The Solution: RVR Scope API

RVR's Scope View is a purpose-built rendering pipeline for weapon optics. Instead of capturing the full scene at full quality every frame, it renders a lean, low-resolution view at a controlled frame rate with aggressive performance defaults.

Quick Start: Blueprint

The minimal setup is a single Blueprint node. Attach a CameraComponent to your weapon scope mesh, set a narrow FOV (10-20 degrees for magnification), then call StartScopeView.

// In your weapon Blueprint (e.g. BeginPlay or ADS event):

1. Get RVR subsystem: Get Engine Subsystem -> Runtime Video Recorder
2. Call StartScopeView:
   - ScopeCamera: your scope CameraComponent (FOV = 12 for 6x magnification)
   - Width: 512
   - Height: 512
   - CaptureFPS: 20
   - ScreenPercentage: 50.0
3. Take the returned Render Target
4. Set it as a texture parameter on your scope lens material:
   - Create Dynamic Material Instance (scope lens mesh)
   - Set Texture Parameter Value ("ScopeTexture", returned RT)

When the player exits ADS or holsters the weapon, call StopScopeView to release the render target and stop the extra renders.

C++ Implementation

Full C++ setup for a VR sniper rifle scope:

// WeaponScope.h
UPROPERTY(VisibleAnywhere)
UCameraComponent* ScopeCamera;

UPROPERTY()
UMaterialInstanceDynamic* ScopeLensMaterial;

void ActivateScope();
void DeactivateScope();

// WeaponScope.cpp
void AWeaponScope::ActivateScope()
{
    auto* RVR = GEngine->GetEngineSubsystem<URuntimeVideoRecorder>();
    if (!RVR) return;

    FRuntimeScopeRenderSettings RenderSettings;
    RenderSettings.MaxScopeDistance = 80000.f;  // 800m for a sniper
    RenderSettings.bEnableDynamicShadows = true;
    RenderSettings.bEnableFog = true;
    RenderSettings.bEnableAtmosphere = true;
    // Everything else defaults to OFF

    UTextureRenderTarget2D* ScopeRT = RVR->StartScopeView(
        ScopeCamera,
        512,    // Width
        512,    // Height
        20,     // CaptureFPS
        50.0f,  // ScreenPercentage
        FRuntimeSelectiveRenderingSettings(),
        nullptr, // No custom post-process
        RenderSettings
    );

    if (ScopeRT && ScopeLensMaterial)
    {
        ScopeLensMaterial->SetTextureParameterValue(
            TEXT("ScopeTexture"), ScopeRT);
    }
}

void AWeaponScope::DeactivateScope()
{
    auto* RVR = GEngine->GetEngineSubsystem<URuntimeVideoRecorder>();
    if (RVR) RVR->StopScopeView();
}

StartScopeView API Reference

Returns a UTextureRenderTarget2D* that you assign to your scope mesh material. Only one scope view can be active at a time; calling again stops the previous one.

FRuntimeScopeRenderSettings - What's On and Off

Every feature defaults to OFF for maximum VR performance. Enable only what you need:

Performance Under the Hood

Here's what the Scope API does behind the scenes to keep costs minimal:

Custom Post-Process: Crosshair, Night Vision, Thermal

Pass a CustomPostProcessMaterial to overlay a crosshair reticle, add a vignette, or build a full night-vision/thermal scope. When a custom material is provided, the view mode switches to Unlit with FinalColorLDR capture, and your material receives the scene as input.

// Create a night-vision post-process material in your asset pipeline,
// then pass it to StartScopeView:

UMaterialInterface* NightVisionMat = LoadObject<UMaterialInterface>(
    nullptr, TEXT("/Game/Materials/MI_NightVision"));

RVR->StartScopeView(
    ScopeCamera, 512, 512, 20, 50.0f,
    FRuntimeSelectiveRenderingSettings(),
    NightVisionMat,  // Applied as post-process
    FRuntimeScopeRenderSettings()
);

The material gets the full scope scene as a texture input. Use it to add green tint + noise for night vision, or remap colors for a thermal overlay.

Selective Rendering: Hide or Show Specific Actors

Use FRuntimeSelectiveRenderingSettings to control what the scope sees. This is useful for:

• - Hiding the player's own weapon mesh from the scope view
• - Showing only tagged "enemy" actors for a wall-hack scope power-up
• - Filtering out UI/HUD elements

FRuntimeSelectiveRenderingSettings Selective;
Selective.HiddenActors.Add(PlayerWeaponActor);
Selective.HiddenActors.Add(PlayerHandsActor);

RVR->StartScopeView(
    ScopeCamera, 512, 512, 20, 50.0f,
    Selective,
    nullptr,
    FRuntimeScopeRenderSettings()
);

Events and Delegates

RVR broadcasts two delegates for scope lifecycle:

Bind to these to show/hide a scope overlay widget, play an ADS animation, or switch the crosshair style.

Helper Methods

The scope is automatically stopped on EndPlay and Deinitialize, so you don't need to manually clean up when the level ends.

Tuning Guide: Quest vs PCVR

Tip: Start with the defaults (512, 20 FPS, 50%) and profile with stat gpu. The scope render should cost under 1ms on PCVR and under 2ms on Quest 3.