VirtualTour Plugin

A high-performance 360-degree panoramic image capture plugin for Unreal Engine 5.6+.

Features

• 360° Panoramic Capture: Captures full 360-degree equirectangular images
• Pane-Based Rendering: Uses configurable horizontal/vertical panes for high-quality output
• Real-time & Single-Shot: Supports both continuous capture and single-shot async capture
• Lumen-Ready: Includes proper warmup for Lumen temporal accumulation
• Async Processing: Heavy CPU work (image blending) runs on background threads
• Editor API: Programmatic actor placement and batch rendering for editor workflows
• WebViewer Included: Standalone web-based 360° image viewer

Usage

Blueprint API

The plugin provides a UVirtualTourSubsystem accessible from blueprints:

// Start continuous 360 capture
bool StartCapture360(UCameraComponent* Camera, FVirtualTourSettings Settings);

// Stop continuous capture
void StopCapture360();

// Capture a single 360 image (async with warmup)
void CaptureSingle360Image(UCameraComponent* Camera, FVirtualTourSettings Settings, FString& OutFilePath);

// Check if capture is in progress
bool IsCapture360InProgress();

C++ API

#include "VirtualTourSubsystem.h"

// Get the subsystem
UVirtualTourSubsystem* VirtualTour = GEngine->GetEngineSubsystem<UVirtualTourSubsystem>();

// Configure capture settings
FVirtualTourSettings Settings;
Settings.EquirectWidth = 4096;
Settings.EquirectHeight = 2048;
Settings.NumHorizontalSteps = 4;  // 4 horizontal panes
Settings.NumVerticalSteps = 3;     // 3 vertical panes
Settings.OutputDirectory = TEXT("%auto%");  // ProjectDir/Saved/360Captures
Settings.BaseFilename = TEXT("360Capture");

// Start continuous capture
if (VirtualTour->StartCapture360(CameraComponent, Settings))
{
    // Capture started successfully
}

// Stop capture
VirtualTour->StopCapture360();

Editor API

For editor workflows like batch rendering and programmatic actor placement, see EDITOR_API.md for detailed documentation.

Quick example:

// Get the editor subsystem
UVirtualTourEditorSubsystem* EditorSubsystem = GEditor->GetEditorSubsystem<UVirtualTourEditorSubsystem>();

// Spawn a camera
ACameraActor* Camera = EditorSubsystem->SpawnCaptureCameraAt(FVector(0, 0, 200), FRotator::ZeroRotator);

// Configure and capture
FVirtualTourSettings Settings;
Settings.EquirectWidth = 4096;
Settings.EquirectHeight = 2048;

FString OutFilePath;
EditorSubsystem->CaptureFromCameraImmediate(Camera, Settings, OutFilePath);

Or perform batch captures from multiple locations:

TArray<FVirtualTourPoint> CapturePoints;
// ... configure capture points ...

EditorSubsystem->PerformBatchCaptures(CapturePoints, false);

Settings

• OutputDirectory: Output directory for images (use %auto% for default)
• BaseFilename: Base filename (frame numbers are appended)
• TargetFPS: Target capture rate (default: 30 FPS)
• EquirectWidth: Equirectangular output width (default: 4096)
• EquirectHeight: Equirectangular output height (default: 2048)
• NumHorizontalSteps: Number of horizontal panes (default: 4)
• NumVerticalSteps: Number of vertical panes (default: 3)
• bSavePanes: Save individual panes for debugging (default: false)

WebViewer

The plugin includes a standalone web-based 360° image viewer in the WebViewer folder.

Running the Viewer

1. Navigate to WebViewer folder
2. Install dependencies: npm install
3. Run dev server: npm run dev
4. Open browser to http://localhost:5173

Building for Production

npm run build

The built viewer will be in WebViewer/dist.

Technical Details

Rendering Pipeline

1. Pane Rendering: Renders multiple overlapping panes covering 360° × 110° (vertical)
2. Temporal Warmup: 64 frames for Lumen surface cache initialization
3. Equirectangular Conversion: CPU-based pane blending using MRQ panoramic algorithm
4. Background Processing: Image compression and disk I/O on background threads

Performance

• Game Thread: ~16ms for rendering all panes (4×3 grid)
• Background Thread: ~50-100ms for equirectangular blending and PNG compression
• Memory: ~100MB for 4096×2048 output with 4×3 panes

Requirements

• Unreal Engine 5.6+
• Windows, Linux, or Mac
• Modern GPU with Lumen support (optional but recommended)