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 Scenes: Posed RGB-D Flythroughs of Game Worlds

Every frame carries the camera that rendered it and the depth the engine computed for it. Ten game worlds, with the camera released from the player for 60% of the footage: metric depth, world-space normals, 4x4 pose, and per-frame intrinsics on one frame index, plus hundreds of full in-place turns and long stretches in which the world is frozen and only the camera moves. Two trajectories per world and one whole world are held out, so sparse-view reconstruction and camera-controlled generation can be scored against exact novel views rather than estimated ones. Nothing here was reconstructed after the fact.

For sparse-view 3D reconstruction, novel view synthesis, camera-conditioned world models, and real-to-sim scene priors. Static spans are flagged; dynamic-object masks ship with the next modality drop.

Version 1.1.0

One session, four synchronized streams as quadrants of a single decoded video: clean RGB, post-HUD RGB, world-space normals, and depth. The camera is off the character, circling a building at walking height while the world holds still.

The same frames, twice: the clean RGB on the left, the engine's depth on the right. One decode, and one join through depth_meta.jsonl. The balconies read as overhangs, the roof line separates from the trees behind it, and the sky returns nothing because the engine had no surface to report.

	Published here	Full corpus
Sessions	18	186
Hours	16.6	166
Worlds	9, anonymized as Game 1 to Game 9	10
Size	511 GB	about 5 TB

What you can download here is a sample. This repository carries 18 complete sessions, 511 GB of them, every stream intact, plus 50 clips cut from their flythrough spans and the metadata for the set. Those 18 sessions are themselves drawn from a corpus of 186 sessions and 166 hours, and every distribution below is measured across that full corpus. To request the full dataset, write to hello@originlab.ai.


Capture	1920x1080, 60 FPS constant, in-engine SDK, one shared frame clock
Camera pose	read out of the engine, present on 98.9% of frames
Depth	metric, engine G-buffer, never re-encoded
Delivery	whole sessions, no archives to unpack

Dataset summary

This is game footage recorded from inside the engine with the camera detached from the player. An operator flies the camera through the world while the simulation is frozen, then hands it back; the recorder marks every span the camera is off the character. What ships is not a reconstruction of that flight but its ground truth: the pose the engine used to render each frame, the depth buffer it computed, the surface normals it shaded with, and the intrinsics it projected through, all on the same frame index as the pixels.

Two properties make it usable as supervision rather than as reference footage. Alignment: RGB, normals, telemetry and the per-frame tables share one frame clock and join on the frame index. Depth is the exception and needs its one-line join: the depth encoder drops frames under load, so depth/depth.hevc holds fewer frames than the RGB stream, and depth/depth_meta.jsonl records the camera frame each depth frame was captured against. Pair through that mapping, never by position — the drops are scattered rather than trailing, so zipping the two streams walks depth steadily out of step with the picture. Per-session depth coverage is in the table below. Ground truth, not estimation: no pose was solved, no scale was fitted, and no depth was inferred from pixels, which is what lets a reconstruction or a camera-conditioned generator be scored against this data rather than merely trained on it.

Supported tasks

Task	Why this dataset
Sparse-view 3D reconstruction	Exact per-frame extrinsics and intrinsics with metric depth, and a held-out split of whole trajectories and one whole world for scoring against real novel views.
Novel view synthesis	Released-camera frames sit a typical 94.2 m from the character, with 92% past 10 m: viewpoints and baselines a third-person rig never produces.
Camera-conditioned generation and world models	Dense posed frames over long continuous flights, hour-long sessions with the camera off the character for most of their length.
Monocular and metric depth	Engine G-buffer depth on every frame, never re-encoded, with the near plane and intrinsics written per session in the decode contract.
Static-scene capture	Spans in which the simulation is frozen and only the camera moves, flagged span by span in `metadata/static_spans.parquet` (9.7 hours in the published sample).

What the camera does

Where the camera sits, frame by frame. On the character it stays inside a third-person rig at a typical 1.5 m; released it sits at a typical 94.2 m, and 92% of released frames are past 10 m, further than any third-person camera reaches. That gap is the dataset: viewpoints a player's camera never occupies.


_{What the footage is of. 69% of frames are outdoors, spread across desert, forest, alpine, grassland, urban, industrial, cave and interior, with no single terrain past a fifth of the corpus.}	_{Lighting and weather, over outdoor frames only so indoor scenes are not miscounted as night: 59.6% daylight, with night, fog, overcast, rain and dusk all represented.}

What the depth and the poses rebuild together

A full 359 degree turn in place, fused into one surface. Every depth sample is placed in the world with the pose the engine recorded for its own frame and integrated into a signed distance field; a surface is drawn only where several frames agree. No registration, no bundle adjustment, no scale fitting, no model in the loop. Vaulted ceilings, door frames, window reveals and furniture are what the recorded geometry already contains.

The footage it was built from: clean RGB on the left, the engine's depth for the same frames on the right.

This reconstruction comes from an earlier capture run on the same pipeline. The published sample alone holds 405 full in-place turns across 17 of its 18 sessions, listed per session in metadata/scenes.parquet; the full corpus holds proportionally more, and fused panoramas ship to access holders.

Composition of the published sample

Measured per session over the delivered pose tracks, and reported here so the sample can be checked against the corpus distributions above. metadata/scenes.parquet holds the full table.

	Across the 18 published sessions
Median session	60.0 minutes, unbroken
Flythrough share	60% of footage, every session releases the camera
Frozen-world footage	9.7 hours, flagged as 248 spans in `metadata/static_spans.parquet`
Full in-place turns	405, across 17 of the 18 sessions
Pose coverage	98.8% of frames, never below 94.8% in a session
Depth coverage	92% of RGB frames carry a depth frame; per session 76% to 100%

Scene identity is anonymized: map_name in metadata/scenes.parquet carries the engine's own level name where the capture exposes one (11 of 18 sessions), which separates distinct worlds within a title without naming the title.

Dataset structure

One folder per session, grouped by modality, no archives to unpack. A one-hour session measures about 30 GB: roughly 18 GB of video renditions, 2.3 GB of depth, and 200 MB of telemetry and tables.

File	Purpose
`video/prehud.mp4`	1080p H.264, 60 FPS CFR, HUD removed, with game audio
`video/posthud.mp4`	The frame as the player saw it, HUD included, same clock
`video/normals.mp4`	Per-pixel surface orientation in the world frame
`video/mosaic.mp4`	The four visual streams as quadrants of one video, a playable sync proof
`depth/depth.hevc`	10-bit HEVC elementary stream, log-encoded planar Z; pair to RGB through `depth_meta.jsonl`
`depth/depth_meta.jsonl`	Per-frame depth parameters
`depth/decode_contract.json`	Near plane (makes depth metric), pinhole intrinsics, frame accounting, world frame
`telemetry/camera.jsonl`	Camera pose by frame index and QPC, position and pitch/yaw/roll
`telemetry/input.jsonl`	Keyboard, mouse deltas, scroll, and window focus, frame-indexed
`telemetry/events.jsonl`	In-engine action events with the engine's own label, frame-indexed
`telemetry/state.jsonl`	Sampled game state, field, unit, and value per sample
`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, event flags
`tables/events.parquet`	One row per in-engine event with resolved labels
`session.json`	Manifest: files and sizes, fps, the shared-clock alignment statement, sync audit

Complete packages sit under sessions/<uuid>/, one folder per session with the file tree above. Alongside them: metadata/sessions.parquet (the session index the viewer renders), metadata/frames.parquet (3.6 M rows, every frame of the sample with pose and action columns), metadata/scenes.parquet, metadata/static_spans.parquet, metadata/splits.parquet, and previews/ (50 clips cut from flythrough spans). The remaining 168 sessions of the corpus are delivered on request.

Held-out split

metadata/splits.parquet marks flythrough trajectories per world plus every session of one whole world as held out, so sparse-view reconstruction and camera-conditioned generation can be scored on views no training run saw.

Split	Rows	What it is
`train`	31	flythrough spans free to train on
`heldout_traj`	15	two trajectories per world, withheld; one world contributes a single trajectory
`heldout_title`	6	every span of one whole world, withheld

How to use it

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

REPO = "originlab/game-scenes-posed-rgbd"

# the session index, and the per-frame table for the whole sample
frames = pq.read_table(hf_hub_download(REPO, "metadata/frames.parquet", repo_type="dataset"))
print(frames.num_rows, frames.schema.names)   # pose and action columns, one row per frame

# one complete session, about 30 GB
snapshot_download(REPO, repo_type="dataset", local_dir="./game-scenes",
                  allow_patterns=["metadata/*", "sessions/<uuid>/*"])

Depth ships as a plain HEVC elementary stream read with ffmpeg as gray16le. Each session carries its own depth/decode_contract.json (intrinsics, near plane, transform constants) and depth/depth_meta.jsonl, which maps every depth frame to the camera frame it was captured against; use that mapping rather than assuming the two indices coincide. The decode reference for this release ships to access holders alongside the loader.

Depth coverage is per session, and depth is joined through `depth_meta.jsonl`

The depth encoder drops frames when the GPU is saturated, so a session's depth stream is shorter than its RGB stream. The drops are scattered across the session rather than trailing it, which means pairing the two streams by position walks depth progressively out of step with the picture. depth/depth_meta.jsonl carries camera_frame for every depth frame; that mapping is the join and it stays correct however many frames went missing.

import json
# depth.hevc frame n shows the RGB frame named by row n of depth_meta.jsonl
rows = [json.loads(l) for l in open("depth/depth_meta.jsonl") if '"camera_frame"' in l]
rgb_index_for_depth_frame = [r["camera_frame"] for r in rows]

Coverage below is depth frames delivered against frames captured. Pose, RGB, normals and telemetry are unaffected; only the depth lane is short.

Session	Depth frames	RGB frames	Depth coverage
`94d74912`	164,196	216,058	76.0%
`a0dbd93a`	166,142	216,037	76.9%
`f7279a8d`	12,684	16,164	78.5%
`f1af73ee`	182,026	216,042	84.3%
`dda671f2`	186,560	215,826	86.4%
`687b72c1`	130,881	144,229	90.7%
`28d6ced3`	199,595	216,018	92.4%
`024176ad`	200,141	216,021	92.6%
`17ad8467`	167,259	179,525	93.2%
`5b65fd0f`	202,979	216,035	94.0%
`23bf1dae`	203,200	216,065	94.0%
`563be68e`	204,202	216,067	94.5%
`254ed3ec`	210,178	215,987	97.3%
`9947a048`	215,315	216,017	99.7%
`0a197859`	215,957	215,958	100.0%
`fdd6c063`	216,028	216,029	100.0%
`075729c9`	216,008	216,008	100.0%
`9dc876f2`	216,049	216,049	100.0%

Two sessions of one world were withdrawn from this release because their camera_frame mapping itself drifts, and one because its RGB stream is largely absent. See the release notes at the end of this card.

Depth resolution is per session, and not always the RGB grid

RGB is 1920x1080 in every session. Depth is captured at the title's internal render resolution, which on upscaled titles is smaller and not an integer fraction of the RGB grid. Read width and height from depth/decode_contract.json per session and reproject through the intrinsics in that same file; do not assume a single isotropic resize.

Depth grid	Sessions	Scale against 1920x1080
1920x1080	12	1:1
1440x812	2	0.7500 wide, 0.7519 high, anisotropic
1288x724	2	0.6708 wide, 0.6704 high, anisotropic
960x540	2	exactly one half in both axes

The two anisotropic grids differ between axes by about 0.2% and 0.07%. Resampling with one scale factor shears the depth map by roughly a pixel at the frame edges.

The depth_raw block in the decode contract describes the lossless R16 sidecar the SDK can emit, and records the settings this session was captured under. The sidecar itself is not part of this release; it ships to access holders on request.

Baselines

Pointmap AbsRel and pose error on the held-out split, measured against VGGT, Pi3, MapAnything, and Depth Anything 3, are in preparation and ship to access holders.

Duplicate frames are counted, and some sessions are mostly duplicates

The capture grid is constant-rate. When a tick has no fresh frame the encoder repeats the previous one, so a share of every stream is literal repeats rather than new content. That share is already recorded per session and per stream, in depth/decode_contract.json under frame_accounting.<stream>.dup_count beside frame_count.

It is not evenly spread, so it is worth reading before you train on hours rather than on content:

Stream	Median share of frames that are duplicates	Worst session
depth	0.0%	20.5%
pre-HUD RGB	0.0%	18.9%

Deduplication is repeatedly the highest-return filter in the training-data literature, and an unlabelled duplicate is worse than a dropped one: the model sees the same target several times and weights it accordingly. Filter or downweight on dup_count rather than assuming every frame is fresh.

Considerations for using the data

Flythrough spans are frozen-world capture: the simulation is paused, so the geometry in a static span does not move. Spans outside those flags are ordinary dynamic play; dynamic-object masks ship with optical flow and segmentation in the next modality drop.
Depth comes from the engine's depth buffer, so translucent effects such as fog, glass, and particles follow how the engine renders them. Which point in the frame the buffer is read at is elected per title and can change within a session, so the treatment of translucent surfaces is not uniform across the release. Per-session provenance for that election is being added.
Two sessions of one title (9dc876f2 and fdd6c063) originally shipped a near plane of 10.0 cm that the engine read never confirmed; both are the only sessions in the release with no world_to_meters recorded. Their metric scale was 11.76x too far. Both decode contracts are now corrected to 0.85 cm, measured by cross-view reprojection against a control session of the same title whose engine read did resolve. If you downloaded either session before this correction, multiply its metric depth by 0.085. Relative depth, pose and intrinsics were never affected.
Pose is present on 98.9% of frames across the release and on at least 94.8% in every session; cam_valid in the frames table marks the gaps rather than interpolating them.
Depth and normals ship as HEVC and MP4 lanes. Per-frame EXR conversion is lossless from the delivered stream through the decode contract and is available under agreement.
Object counts, material passes, and mesh exports are not part of this release. Depth-fused point clouds per scene and PBR passes where the engine exposes them are available under agreement.
Worlds are anonymized as Game N in the public metadata; real titles are disclosed under the full-dataset agreement.
Personal and sensitive information: audio is game audio from the title process, no microphone or player voice is captured, and no personally identifying information about the players ships in any stream or metadata file.

Requesting the full dataset

Write to hello@originlab.ai with what you need. What ships is considerably larger than what you can download here:

	Downloadable here	Full dataset
Sessions	18	186
Hours	16.6	166
Size	511 GB	about 5 TB
Worlds	9	10
Form	every session whole, all modalities	the same, across the corpus

Each full session is an unbroken hour at 1920x1080 and 60 FPS with every stream on one frame clock: clean RGB, post-HUD RGB, world-space normals, metric depth, per-frame camera pose and intrinsics, keyboard and mouse input, in-engine events and game state, the 4-up verification mosaic, and per-frame training tables. A one-hour session measures roughly 30 GB.

Useful things to say in the mail:

Which slice. By world, by scene type (open sky, enclosed, mixed), by camera behaviour (flythrough spans, frozen-world spans, in-place turns), or the whole corpus.
Which modalities. Take the full set or only what you train on; depth and pose alone are a fraction of the bytes.
How you want it. A signed download manifest for any parallel downloader, or direct in-cloud access on AWS for the fastest transfer.
Which access track. Internal evaluation or commercial, as set out below.

Delivery is by manifest rather than browser download: a signed list of every file in your selection, valid for seven days, resumable and multi-connection. A single session lands in minutes on a gigabit line, a large selection overnight.

Licensing

All gameplay is recorded under exclusive licenses with the rights holders and captured by consenting, compensated players. 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.

The full corpus, 186 sessions and 166 hours, is delivered once access is granted; the sample in this repository is there so the format and the quality can be checked first. Request it at hello@originlab.ai.

Release notes

1.1.0 — Three sessions were withdrawn after an audit of stream completeness, taking the release from 21 sessions to 18 and from ten worlds to nine.

Two sessions of one world shipped a camera_frame mapping that drifts by up to 17,021 frames and returns. Depth cannot be paired to RGB on those sessions by any method, so they were removed rather than documented.
One session delivered 6,572 RGB frames against 216,011 captured — under two minutes of picture for an hour of capture — while its depth arrived nearly whole. Removed.
The alignment statement in this card previously said every stream joins on the frame index. That holds for RGB, normals, telemetry and the frame tables, and it does not hold for depth. The card now documents the depth_meta.jsonl join and publishes per-session depth coverage.
metadata/*.parquet and previews/ were regenerated for the remaining 18 sessions.

One session (f7279a8d) ships its full package but has no row in the metadata tables and runs 4.5 minutes rather than the hour the rest of the release holds. It is the source of the header video. A metadata row for it ships in the next revision.

Sessions withdrawn in this revision remain available to full-dataset holders on request, with their defects documented.

Citation

@misc{originlab2026gamescenes,
  title  = {Origin Lab Game Scenes: Posed RGB-D Flythroughs of Game Worlds},
  author = {Origin Lab},
  year   = {2026},
  url    = {https://huggingface.co/datasets/originlab/game-scenes-posed-rgbd}
}

Related datasets from Origin Lab

game-recordings-v3, 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.
lotus-game-depth, a depth model trained on Origin Lab data.

Downloads last month: 244

Total file size:

511 GB

Request access to Origin Lab Game Scenes