Two access tracks (see LICENSE.md). Internal Evaluation License: 90-day
internal evaluation, no publication or release obligation, no deployment or production use; delete or
convert at the end. Full dataset / commercial: production training and deployment rights per agreement
with Origin Lab. No redistribution of the data in any form.

Origin Lab Game World Scans v2.1.0

Origin Lab Game World Scans v2.1.0 is a multi-view RGB-D dataset of frozen game worlds for 3D reconstruction, novel view synthesis, camera-controlled video generation and metric depth and normal estimation: 106.7 hours of free-camera sweeps through 17 licensed games, recorded inside the game engine at 60 FPS, mostly at 1920×1080, with world time stopped and the player hidden, with engine depth, world-space surface normals, camera pose and intrinsics on one shared frame clock.

Previews and per-game statistics: app.originlab.ai/data.

Four worlds, side by side. Each tile is one session's mosaic: clean RGB, post-HUD RGB, world-space normals and depth as quadrants of a single decoded video, so within a tile the streams cannot drift.


Sessions	139
Hours	106.7
Games	17, anonymized as Game 1 to Game 17
Frames	23.1 million on the shared clock
Size	≈4.16 TB (≈39 GB per hour)
Capture	60 FPS constant, in-engine SDK, one shared frame clock; RGB 1920×1080 in 114 sessions, 2560×1440 in 15
Camera	free camera, player hidden, world time stopped

Dataset summary

Recorded inside the engine, not captured from the screen, with the camera detached from the player and the world paused. What ships is the ground truth of each flight, not a reconstruction of it: the pose the engine rendered each frame with, the depth buffer it computed, the surface normals it shaded with and the intrinsics it projected through, all on the frame index of the pixels. Frame k of the RGB is frame k of the depth, normals, pose and frame table, so the frame index is the join key. Ticks that any stream failed to capture are dropped from all of them before delivery; every session in this release certifies on that frame accounting.

Against other datasets

Game datasets offer engine depth for dynamic gameplay with estimated or missing pose; rendered and simulated datasets offer full ground truth for scenes built for the purpose; real captures estimate pose with structure from motion. This release has engine depth, pose and normals for frozen commercial game worlds, across 17 titles, on one frame clock.

Dataset	Source	Sequences	FPS	Resolution	Frames	Depth	Camera pose	Surface normals	Static scene
Game World Scans v2.1.0 (ours)	17 commercial titles, engine hooks, world time stopped	139 sessions	60	1920×1080 (114 sessions); up to 2560×1440	23.1M	✅ engine, 10-bit log code	✅ engine	✅ engine, world space	✅
OmniWorld-Game (2025) [1]	game environments, ReShade capture	96K clips (214 h)	24	1280×720	18.5M	✅ render buffer via ReShade	🟡	❌	❌
Generative World Renderer (2026) [2]	2 commercial titles, ReShade capture	?	30	720p	4M	✅ render buffer via ReShade	❌	🟡 from depth	❌
MVS-Synth (CVPR 2018) [3]	1 commercial title (GTA V)	120	?	1920×1080 (also 1280×720, 960×540)	12K (120 × 100)	✅	✅	❌	?
MatrixCity (ICCV 2023) [4]	Unreal Engine 5 city sample, 2 cities	?	?	1080p	519K	✅	✅	✅	?
TartanAir V2 [5]	65 simulated environments	?	10	640×640	?	✅	✅	❌	?
Hypersim (ICCV 2021) [6]	461 artist-made indoor scenes, V-Ray	774 trajectories	stills	1024×768	77K	✅ ray distance	✅	✅	✅
DL3DV-10K (CVPR 2024) [7]	consumer phones and drones, real scenes	10,510	60 or 30	3840×2160	51.2M	❌	🟡 structure from motion	❌	mostly
ScanNet++ (ICCV 2023) [8]	laser scanner, DSLR and iPhone, real indoor	460 scenes	60 (iPhone)	1920×1440 (iPhone)	over 3.7M (iPhone)	✅ laser scan; iPhone LiDAR 256×192	🟡 COLMAP registered to the scan	❌ per frame	?
RealEstate10K (SIGGRAPH 2018) [9]	YouTube property videos	≈80K clips	?	?	≈10M	❌	🟡 SLAM and bundle adjustment	❌	mostly

✅ ground truth (engine, renderer or sensor) · 🟡 estimated by a model or by structure from motion · ❌ absent · ? not stated. Figures from each dataset's paper or official page, read 2026-10-14.

Supported tasks

Task	Why this dataset
Sparse-view 3D reconstruction	Exact per-frame extrinsics and intrinsics with engine depth over a scene that holds still for the whole session.
Novel view synthesis	Many views of the same unchanging scene from a moving camera, each with its engine pose and intrinsics.
Camera-conditioned generation and world models	Dense posed frames over unbroken flights of up to an hour, with the camera path as the only thing that moves.
Monocular and metric depth, normal estimation	Engine depth and world-space normals on every frame, with the near plane and intrinsics written per session in the decode contract.

Games

Titles are anonymized for licensing: each game is called Game 1 to Game 17 throughout this card and in metadata/sessions.parquet, and real titles are disclosed under the full-dataset agreement. Game numbers are this release's own and do not match other Origin Lab releases.

Hours per game, one segment per session, from the session index (metadata/sessions.parquet).

Hours by genre. Each game has one genre, from its store listing.

Scenes gameplay does not reach

For each game also in Game Recordings v0.4.0 (16 of 17): the share of 1.6 s windows that land in scene cells (DINOv2 [10], fixed grid sized on the CS:GO footage of DIAMOND [11, 12]) that a random half of the game's v0.4.0 gameplay never visits, for the scans and for the game's other half of gameplay at the same number of windows. Top row: all 16 games pooled. Bars: 5–95% of 200 random halves. The v0.4.0 vectors are from its 2026-09-30 snapshot.

Across the 16 games, 7.0% of the scans' windows (5.7–8.4%) land in scene cells that half of the game's gameplay never visits, against 1.2% (0.5–2.1%) for the same number of further gameplay windows: between five and six times as often. The rate varies by game, from 42% in Game 16 and 16% in Game 6 to none in Games 1, 9, 12, 13 and 14, where the scans stay within scenes gameplay already shows.

Camera motion

Engine camera pose over 127,981 three-second windows, classified as on the Game Recordings v0.4.0 card. Left: share of windows in six bins of speed and turn rate (thresholds under each bin, set by hand). Right: median turn rate, 6.8°/s against 20.5 for v0.4.0 gameplay, 12.9 for OmniWorld-Game [1] and 4.5 for RealEstate10K [9]. The v0.4.0 bars are from its card (147 sessions as of 2026-09-30); the references use estimated poses, which inflates their rates.

The scans move the camera through the world rather than turning it: half of all windows translate at 0.6 m/s or more while turning under 25°/s, and the median turn rate is about a third of gameplay's. Median camera speed is 0.68 m/s, against 3.14 m/s in v0.4.0 gameplay.

Engine depth against monocular estimators

Free depth models miss engine depth by 5–17% per pixel, even after their overall scale is corrected. Left: per game, the best and the worst of four Depth Anything V2 Metric checkpoints [13] (Indoor and Outdoor, Large and Small), each the median over the game's sessions of the median error per pixel, on 40 frames per session from its first 3,000; dashed, the median of the best per game. Right: one frame of Game 6 and, below it, where the best checkpoint's scale-corrected depth departs from engine depth; grey, no engine depth.

Over all 139 sessions, the median error after scale correction is 10.2% for the Indoor Large checkpoint, 12.4% for Outdoor Large, 17.1% for Indoor Small and 18.3% for Outdoor Small. Error before the scale correction is not reported while the recorded metric scale of some sessions is under review (see Considerations).

Dataset structure

One folder per session under sessions/<uuid>/ (video/, depth/, telemetry/, tables/), no archives. About 39 GB per hour of footage.

No predefined splits: metadata/sessions.parquet indexes the sessions (game, duration, sync status, sizes) for cutting your own, and metadata/files.parquet lists every file with its size.

Measured over the delivered packages:

	Across the 139 sessions
Frames	23.1 million on the shared clock
Depth coverage	every RGB frame carries a depth frame
Pose coverage	at least 99.6% of frames in every session (the per-frame valid-pose flag in `tables/frames.parquet`)
Depth resolution	1920×1080 in 86 sessions; the title's internal render resolution in the other 53, from 960×540 to 2560×1440
Repeated frames	median 5% per stream, worst session 48%

Data files and fields

File	Purpose
`video/prehud.mp4`	RGB with the HUD removed, 60 FPS CFR, with game audio. 1920×1080 in most sessions; see Video resolution. Every stream starts at the shared frame 0
`video/posthud.mp4`	The frame as the screen showed it, HUD included, same clock
`video/normals.mp4`	Per-pixel surface orientation rendered by the engine, world frame, same clock
`video/mosaic.mp4`	The four visual streams as quadrants of one video, a playable sync proof, not extra data
`depth/depth.hevc`	10-bit HEVC elementary stream, log-encoded planar Z; frame k is RGB frame k
`depth/depth_meta.jsonl`	Per-frame depth parameters, keyed by `depth_frame`
`depth/decode_contract.json`	Depth encoding and its constants, near plane (makes depth metric), pinhole intrinsics, per-stream frame accounting (fps, repeat counts), world frame
`telemetry/camera.jsonl`	Camera pose by frame index and the Windows high-resolution timestamp (`qpc`): position, pitch/yaw/roll
`telemetry/pose_render.jsonl`	The pose each depth image was rendered with, where the SDK records it
`telemetry/input.jsonl`	Keyboard, mouse deltas, scroll and window focus: the operator's camera control
`telemetry/events.jsonl`, `telemetry/state.jsonl`	In-engine events and sampled game state (`state.jsonl` in 134 of 139 sessions)
`telemetry/present_ts.jsonl`	The game's frame-presentation events, each with its Windows high-resolution timestamp and wall-clock time
`telemetry/gameclock.jsonl`, `inventory.jsonl`, `ability.jsonl`, `quest.jsonl`	In-game clock, inventory, ability and quest changes, where the title exposes them (83 to 100 sessions)
`telemetry/world.json`	Engine, world-to-meters scale, handedness, gravity
`tables/frames.parquet`	One row per frame: pose, held-keys bitmask, mouse deltas, state columns, pre-joined on the frame index
`tables/events.parquet`	One row per in-engine event
`tables/conversion_manifest.json`	The rules used to build the tables
`session.json`	Manifest: files and sizes, fps, the alignment statement, frame accounting, sync audit

What is new against Game Scenes v1

	game-scenes-posed-rgbd (v1)	Game World Scans v2.1.0
Games	10	17
Sessions, hours (full dataset)	186, 166 h	139, 106.7 h
World state	gameplay with the camera released from the player for 60% of footage; frozen-world spans flagged within sessions (9.7 of 16.6 h in the public sample)	world time stopped for the whole session
Player model	on screen during ordinary play between flythrough spans	hidden throughout

How to use it

from huggingface_hub import hf_hub_download, snapshot_download
import pyarrow.parquet as pq

REPO = "originlab/game-recordings-free-camera-v2"
sessions = pq.read_table(hf_hub_download(REPO, "metadata/sessions.parquet", repo_type="dataset"))
snapshot_download(REPO, repo_type="dataset", local_dir="./game-world-scans",
                  allow_patterns=["metadata/*", "sessions/a6055c38-a796-458d-b635-2cef9a13021d/*"])

Depth ships as a plain HEVC stream. Read its luma with ffmpeg -f hevc -i depth.hevc -vf extractplanes=y -pix_fmt gray10le -f rawvideo -, which gives the exact codes 0–1023, then decode with the constants in that session's depth/decode_contract.json. Two encodings occur in this release (depth_transform: log_sentinel_v3 in 48 sessions, log_sentinel_v4 in 91); the same decode reads both, because the constants differ, not the curve:

import json
import numpy as np

contract = json.load(open("depth/decode_contract.json"))
tc = contract["transform_constants"]
K, far, sky_min = tc["K"], tc["far_plane_encode"], tc.get("sky_min_code10", 1022)
max_valid = tc.get("max_valid_code10", 1020)
near_cm = contract["near_plane_cm"]

def decode_depth_cm(code):                    # code: 10-bit luma (gray10le)
    q16 = np.where(code >= max_valid, max_valid * 64, code * 64 + 31.5)
    rel = ((1 + K) ** (q16 / 65535) - 1) / K  # in [0,1], proportional to distance
    cm = rel * far * near_cm                  # planar Z along the optical axis
    saturated = (code >= max_valid) & (code < sky_min)   # at or beyond the encodable range: a lower bound
    return np.where(code >= sky_min, np.nan, cm), saturated   # NaN = sky / far clip

What is in this repository

sessions/<uuid>/: one folder per session, in the delivery layout (139 sessions, 106.7 h).
metadata/sessions.parquet: the session index shown in the dataset viewer.
metadata/files.parquet: every file and its size, to check a download.
assets/previews/: the mosaic preview.

Considerations for using the data

Repeated frames. When a tick has no fresh frame the encoder repeats the previous one: median 5% per stream, worst session 48%. Counts per stream are in depth/decode_contract.json under frame_accounting.<stream>.dup_count; filter or downweight on them rather than assuming every frame is fresh.
Video resolution. RGB is 1920×1080 in 114 sessions. Two games record at 2560×1440 in some sessions (Game 10, 9 sessions; Game 14, 6 sessions), in all streams. In Game 16 (8 sessions) and 2 sessions of Game 13 the pre-HUD stream is at the title's render resolution (1440×810 and 1400×788) while post-HUD stays 1920×1080. Read each stream's size from the file.
Depth resolution. Depth is captured at the title's internal render resolution, which can be smaller or larger than the RGB (960×540 to 2560×1440); read width, height and the intrinsics from each session's decode contract rather than assuming one resize.
Depth scale. Metric scale depends on the near plane recorded in each session's decode contract. The recorded scale of some sessions is under review (Games 7, 12, 16 and 17); until that review is published, use depth in those games as relative, not metric.
Saturated depth. Depth codes from the highest valid code (max_valid_code10 in the decode contract) up to the first sky code (sky_min_code10) mean "at or beyond the farthest encodable distance", not a distance; mask them, as in the snippet above.
Frozen, not still. World time is stopped, but some titles keep animating particles, foliage or water; treat those regions as non-static.
Pre-HUD re-encodes. Eight sessions ship a pre-HUD stream that is a frame-for-frame H.264 re-encode (CRF 23) rather than the capture master; post-HUD, normals and depth in those sessions are original. session.json marks them under prehud_source.
Depth follows the engine's depth buffer, so fog, glass and particles follow how each engine renders them.
No microphone audio or operator-identifying information ships; real game titles are redacted from the text files. Media files are byte-identical to delivery.

Licensing

All footage is recorded under exclusive licenses with the rights holders and captured by consenting, compensated operators. Access is gated; request the track you need in the access form:

Internal Evaluation License: 90-day internal evaluation, train and evaluate models solely to assess the data's value. No publication or release obligation, no deployment or production use. At the end of the period, delete the data and evaluation weights, or convert to a commercial agreement.
Full dataset / commercial: production training and deployment rights defined per agreement. Contact Origin Lab to license.

No redistribution of the data in any form. See LICENSE.md for the complete terms.

Methods and references

Comparison table: each dataset's paper or official page [1–9]. Scene coverage: DINOv2 [10] on a grid sized with the CS:GO footage of DIAMOND [11, 12]. Camera references: OmniWorld-Game [1], RealEstate10K [9]. Depth comparison: Depth Anything V2 [13].

Y. Zhou, Y. Wang, J. Zhou, et al. OmniWorld: A multi-domain and multi-modal dataset for 4D world modeling. arXiv:2509.12201, 2025.
Z.-H. Huang, Z. Wang, J. Tan, et al. Generative World Renderer. arXiv:2604.02329, 2026.
P.-H. Huang, K. Matzen, J. Kopf, N. Ahuja, J.-B. Huang. DeepMVS: Learning multi-view stereopsis. CVPR, 2018. arXiv:1804.00650.
Y. Li, L. Jiang, L. Xu, et al. MatrixCity: A large-scale city dataset for city-scale neural rendering and beyond. ICCV, 2023. arXiv:2309.16553.
TartanAir V2. tartanair.org.
M. Roberts, J. Ramapuram, A. Ranjan, et al. Hypersim: A photorealistic synthetic dataset for holistic indoor scene understanding. ICCV, 2021. arXiv:2011.02523.
L. Ling, Y. Sheng, Z. Tu, et al. DL3DV-10K: A large-scale scene dataset for deep learning-based 3D vision. CVPR, 2024. arXiv:2312.16256.
C. Yeshwanth, Y.-C. Liu, M. Nießner, A. Dai. ScanNet++: A high-fidelity dataset of 3D indoor scenes. ICCV, 2023. arXiv:2308.11417.
T. Zhou, R. Tucker, J. Flynn, G. Fyffe, N. Snavely. Stereo magnification: Learning view synthesis using multiplane images. ACM Transactions on Graphics (SIGGRAPH), 2018. arXiv:1805.09817. Dataset figures: google.github.io/realestate10k.
M. Oquab, T. Darcet, T. Moutakanni, et al. DINOv2: Learning robust visual features without supervision. TMLR, 2024. arXiv:2304.07193.
E. Alonso, A. Jelley, V. Micheli, et al. Diffusion for world modeling: Visual details matter in Atari. NeurIPS, 2024. arXiv:2405.12399.
T. Pearce, J. Zhu. Counter-Strike deathmatch with large-scale behavioural cloning. IEEE Conference on Games, 2022. arXiv:2104.04258.
L. Yang, B. Kang, Z. Huang, et al. Depth Anything V2. NeurIPS, 2024. arXiv:2406.09414.

Citation

@misc{originlab2026gameworldscans,
  title  = {Origin Lab Game World Scans: Posed RGB-D Sweeps of Frozen Game Worlds},
  author = {Origin Lab},
  year   = {2026},
  url    = {https://huggingface.co/datasets/originlab/game-recordings-free-camera-v2}
}

Related datasets from Origin Lab

game-scenes-posed-rgbd, posed RGB-D flythroughs of game worlds, the first release of this capture.
game-recordings-v4, frame-synced RGB-D gameplay with actions, events and game state.
game-depth, RGB paired with the engine's dense depth buffer.
frame-synced-multiplayer, eight players on one frame clock.

Downloads last month: 569

Total file size:

4.16 TB

Papers for originlab/game-recordings-free-camera-v2