Origin Lab Game-Depth: RGB + Dense Z-Buffer Depth

Dense depth from game engines, as a scalable substitute for scarce real depth ground truth.

Depth is one of ten frame-locked modalities Origin Lab captures in-engine (pre- and post-HUD RGB, depth, surface normals, camera pose, keyboard/mouse inputs, in-engine events, game state, audio, and per-frame training tables) - this release isolates the depth channel; the full multimodal corpus is originlab/game-recordings-v3. All gameplay is captured under non-exclusive licenses with the rights holders by consenting, compensated players. The engine measures absolute geometry: this release ships relative log-nearness, and metric depth is the next release.

Website: originlab.ai

Data: this repo (load with load_dataset("originlab/game-depth")).
Models / checkpoints: originlab/lotus-game-depth.

Abstract

Dense depth ground truth is the bottleneck in monocular depth estimation. Real sensors are sparse, noisy, or indoor-only, and purpose-built synthetic datasets are expensive and narrow. Game engines already render a dense, exact z-buffer for every frame, for free. We ask whether that signal can stand in for real data. Training a depth model from scratch on ~17.8k game frames, roughly a quarter of the synthetic corpus behind the Lotus baseline, we find it transfers to real outdoor scenes better than that baseline (KITTI AbsRel 0.191 vs 0.224). The comparison is against the publicly released Lotus checkpoint, trained by its authors under their own schedule - a released-baseline comparison, not a controlled retrain. Indoor scenes remain this dataset's frontier. The reason is geometric rather than cosmetic: the game corpus teaches an outdoor ground-plane structure that real driving data shares, even though its pixels look nothing alike. We therefore position game z-buffers as a scalable pre-training substrate, a cheap geometric prior for initializing models before fine-tuning on limited real data, rather than a replacement for real data.

Dataset structure

Each example is one RGB frame paired with dense depth from the engine z-buffer:

• image : RGB frame (1080x1920), PNG.
• depth_nearness : relative log-nearness stored as a 16-bit PNG. Decode with nearness = numpy.array(x) / 65535.0 (in [0,1], near = 1). This is relative, not metric.
• valid : per-pixel validity mask (0 or 255). Game z-buffers are fully dense, so for this dataset every pixel is valid and the mask is all-255 (appears all-white in the Viewer). It is included only for format compatibility with real-sensor depth datasets, which have holes; you can ignore it here.
• game, session, frame, split : metadata.

Splits (48,615 frames total):

• train (17,799) : the session-capped, stride-sampled curated training split used in the results below.
• test (999) : session-disjoint held-out test set.
• extra (29,815) : the remaining frames. Do not evaluate on extra - it shares sessions with train. Released so you can build your own curation instead of ours.

Usage

from datasets import load_dataset
import numpy as np

ds = load_dataset("originlab/game-depth", split="train", streaming=True)
ex = next(iter(ds))
rgb      = ex["image"]                                          # PIL RGB
nearness = np.array(ex["depth_nearness"]).astype("float32") / 65535.0   # [0,1], near = 1 (relative)
valid    = np.array(ex["valid"]) > 0

1. Depth data is the bottleneck

Every monocular-depth model is limited by the depth labels it can learn from. LiDAR is sparse and costly; structured-light sensors are indoor-only and noisy; pseudo-labels inherit a teacher's blind spots. Synthetic datasets such as Hypersim and Virtual KITTI give dense, exact depth, which is why the strongest open diffusion-depth models train on them, but they are hand-authored, fixed in size, and narrow in domain (photoreal interiors, or a driving simulator).

Game engines sidestep the labeling problem entirely: the z-buffer that produces every rendered frame is dense per-pixel depth, available at capture time at no additional cost. Unlike a curated synthetic dataset, game capture is open-ended across any title, session, or environment, so the supply of dense depth grows with recording rather than with annotation budget. The question this card answers is whether depth learned from that source actually transfers to the real world.

2. A depth dataset from game engines

The dataset is 48,615 RGB frames (1080x1920) from 10 games across 98 sessions, each paired with dense per-pixel depth from the engine z-buffer (stored as log-nearness, near = 1 - luma/65535; relative, not metric). Splits are session-disjoint, so no scene leaks between train and test. Frames are stride-sampled to cut the temporal redundancy of contiguous gameplay (raw 3-fps extraction is about 21% near-duplicates; the sampled training split about 8%), and the training split is session-capped so no single session dominates. The composition is deliberately outdoor-heavy and 0% indoor, a fact that turns out to explain most of the results below. A per-game breakdown is in Section 8.

The comparison that frames the rest of the card is with the data behind the Lotus baseline:

	Lotus training data	This dataset (ours)
Sources	Hypersim + Virtual KITTI (2 curated datasets)	10 commercial games, 98 sessions
Train size	about 74k (54k + 20k)	48,615 total; 17,799 used here
Origin	purpose-built renders / driving sim	off-the-shelf gameplay capture
Scenes	indoor + road	outdoor: forest, off-road, driving, FPS, party
Depth GT	metric	relative log-nearness
Scaling	fixed datasets	grows with capture, not labeling

Our model is trained from scratch on roughly 4x fewer frames, entirely from games. That the resulting model is competitive at all is the first hint that the signal is dense and clean enough to matter.

3. Game depth transfers to real outdoor scenes

The central test is zero-shot transfer to a real benchmark the model never saw. On KITTI (1000-image annotated validation set), evaluated in a single fixed harness, the game-trained model has the lowest error of the diffusion-family models:

Model (zero-shot)	AbsRel (lower better)	delta1 (higher better)
Ours (game, from scratch)	0.191	0.720
Lotus (released)	0.224	0.585
Marigold	0.244	0.570
Depth-Anything-V2 (real-data reference)	0.075	0.947

The gap is statistically clear, not noise: 95% bootstrap confidence intervals are [0.189, 0.194] for ours and [0.221, 0.226] for Lotus, which do not overlap. These intervals cover test-set sampling only, not run-to-run training variance; all results are single-seed. One confound should be named plainly: Lotus trains on 54k indoor frames plus 20k driving-sim frames while our training data is 0% indoor, so this result is equally consistent with "domain match wins" as with "game data wins" - the outdoor-only control (ours vs Virtual KITTI alone at matched size, Section 7) will settle which.

A model that has only ever seen rendered game frames predicts real outdoor depth more accurately than one trained on purpose-built synthetic data, and it does so on real photographs, which tells us synthetic-RGB fidelity is not the limiting factor. The advantage is not superficial: it is strongest exactly where outdoor scene understanding lives, on the receding ground plane and at long range, and it holds when noisy boundary pixels are removed, so it reflects structure the model understands rather than sensor noise it happens to fit. Depth-Anything-V2, a discriminative model trained on massive labeled real data, sits far ahead of all diffusion models; it is a reference ceiling, not a same-recipe competitor.

Zero-shot KITTI predictions across models (inverse-depth visualization; near bright, far dark; selected examples). The game-trained model recovers road geometry and vehicles cleanly, ahead of the other diffusion models on these frames. Depth-Anything-V2 (the real-data reference) remains strongest overall (Table above).

4. The mechanism: geometry, not appearance

Why would game frames transfer to real driving scenes? The intuitive guess, that the game RGB simply looks like KITTI, is wrong, and measuring it is what makes the real explanation clear.

Embedding every image with DINOv2 and comparing distributions, the game data is in fact closest in appearance to indoor NYU, not outdoor KITTI:

Pair	DINOv2 Frechet distance
game vs NYU	0.98
game vs KITTI	1.32

If appearance drove transfer, the model would do best on NYU, the opposite of what happens. What the game data actually shares with KITTI is 3-D structure. Measuring the ground-plane signature of each dataset, how strongly distance increases from the bottom of the image to the top, the game corpus looks outdoor: its per-image ground-plane strength (median rho) clusters near KITTI (-0.79 vs -0.82) and far from indoor NYU (-0.56).

A depth model learns geometry, not texture, so the game corpus hands it an outdoor ground-plane prior that happens to be exactly right for real driving scenes and exactly wrong for cluttered interiors. This single mechanism explains the whole pattern of results: the outdoor win, the indoor gap, and the value of the data as a prior. This is a correlation grounded in the mechanism a monocular depth model actually learns; a direct causal test (holding the game RGB fixed while destroying the depth geometry and measuring the drop in transfer) is described as future work in Section 7.

5. Indoor is the frontier

The same prior that wins outdoors is a liability indoors. With no indoor frames in training, NYU is out of distribution, and the model loses zero-shot (AbsRel 0.149 vs Lotus 0.133). Fine-tuning on real NYU closes the gap. Under a matched learning-rate sweep (best checkpoint for each initialization), the game-pretrained model reaches AbsRel 0.116, statistically tied with the fine-tuned Lotus baseline (0.115), despite having no indoor data and roughly 4x less pre-training. We take the honest reading: indoor performance needs indoor data, and here game-pretraining matches, rather than beats, a curated-synthetic baseline. That parity is still a useful data-efficiency result, and it maps where the approach helps today (outdoor geometry) and where the next dataset version has to grow (indoor and more varied scenes).

Model	NYU AbsRel, zero-shot	NYU AbsRel, + NYU fine-tune
Ours (game, from scratch)	0.149	0.116
Lotus (released)	0.133	0.115
Marigold	0.197	not fine-tuned
Depth-Anything-V2 (real-data reference)	0.055	not fine-tuned

(654-image Eigen test, cap 10 m, lower is better. Fine-tuned numbers use the matched learning-rate sweep, best checkpoint per initialization; ours and Lotus are statistically tied.)

Game pre-training alone is weak indoors (third column, zero-shot: the outdoor prior is out of distribution for cluttered rooms), but it is a strong starting point. Fine-tuning on real NYU recovers the room layout and furniture (fourth column). Selected examples with the largest zero-shot-to-fine-tuned improvement.

An earlier comparison at a single higher learning rate had suggested a larger game-pretraining advantage; that turned out to be an under-tuned Lotus baseline, which the matched sweep corrects. We report the matched, fair numbers.

NYU predictions with both models fine-tuned on real NYU under an identical fine-tune recipe applied to both initializations (selected examples). The game-pretrained model produces indoor depth as close to the ground truth as the fine-tuned Lotus baseline, consistent with the tied metrics above.

6. What this is: a scalable pre-training substrate

Read together, the results describe a specific and useful role for game-engine depth. It is not a replacement for real data; Depth-Anything-V2, trained on real labels, is far more accurate on the real-world benchmarks. It is a cheap, scalable geometric prior: dense and exact, free at capture time, and, as the KITTI result shows, carrying structure that transfers to the real world. The natural use is to pre-train on game depth and then fine-tune on whatever small real dataset a task allows, getting the benefit of a strong prior without the cost of collecting real dense depth.

Two in-domain observations reinforce this. First, the pre-training learns genuine structure: on held-out game frames our model predicts depth well ahead of Lotus. Second, and more telling, the real-data model that dominates the benchmarks is the weakest on our frames, which means the data carries structure that existing models have not already absorbed.

Model on our game test set	SSI-MAE (lower better)	AbsRel
Ours (game)	0.029	0.050
Lotus	0.035	0.064
Marigold	0.041	0.074
Depth-Anything-V2 (real-data SOTA elsewhere)	0.055	0.098

7. Where this goes (v0.3.0)

• Data-scaling curve: accuracy across roughly 2k to 48.6k frames, step-matched - the direct test of whether accuracy is still climbing with capture.
• Outdoor-only synthetic control: ours vs Virtual KITTI alone at matched size, to separate "domain match wins" from "game data wins" on KITTI.
• Coverage: indoor and more varied scenes, to convert the indoor frontier into a strength.
• Causal test: a depth-corruption ablation (holding RGB fixed, destroying the depth geometry, and measuring the drop in transfer) to move the geometry mechanism from correlation to causation.
• Confidence: multi-seed variance and confidence intervals on every headline number.

8. Dataset composition

The training split (17,799 frames) spans 10 games; no single game dominates. The held-out game test set (999 frames) is session-disjoint and drawn from 5 of the games.

Game	Train frames	Train %	Test frames
Game1	1,600	9.0	0
Game2	2,000	11.2	200
Game3	1,600	9.0	0
Game4	2,000	11.2	200
Game5	800	4.5	200
Game6	1,400	7.9	200
Game8	2,000	11.2	200
Game9	2,800	15.7	0
Game10	1,800	10.1	0
Game11	1,800	10.1	0
Total	17,799	100	999

Full corpus before session-capping and the train split is 48,615 frames. Machine-readable counts in results/game_distribution.json.

Released models

Both models trained with this dataset are released (same license) in one repo: originlab/lotus-game-depth - the game-pretrained checkpoint (pretrained/, zero-shot KITTI 0.191) and the NYU fine-tuned checkpoint (nyu-ft/, NYU 0.116). Load with UNet2DConditionModel.from_pretrained('originlab/lotus-game-depth', subfolder='pretrained/unet').

Methodology and scope

Full detail in METHODOLOGY.md; machine-readable metrics (including per-frame) in results/. In brief: all models run through one harness with per-model output conventions handled explicitly, and predictions aligned to ground truth by least-squares scale-shift. The harness is validated by Depth-Anything-V2 reproducing its published NYU number (about 0.055). KITTI is processed at native resolution for every model identically, because its roughly 3.4:1 frames are otherwise squashed and blurred. Ours shares the Lotus architecture and training recipe, but the headline comparison is against the publicly released Lotus checkpoint trained by its authors under their own schedule - we did not retrain Lotus, so this is a released-baseline comparison, not a controlled same-recipe experiment. Marigold and Depth-Anything-V2 are external checkpoints included as reference points, with inference settings disclosed. Depth only; normals are out of scope. Point estimates are single-seed; multi-seed variance is noted as future work in Section 7.

Training footprint: the trained component is the SD2-base UNet (about 0.87B trainable parameters; VAE and text encoder frozen), run for 6000 steps at effective batch 32, so roughly 192k images are seen, about 11 passes over the 17,799-frame split. Compute cost is a separate axis from data amount: under a step-matched budget it stays fixed as the data is scaled down, so the data-utilization question (whether accuracy keeps rising with more data) is answered by the data-scaling curve in Section 7, not by compute; the only coupling is that smaller fractions imply more passes over the data (a memorization caveat for those points).

License

Open access, two license tracks (LICENSE.md) - downloading constitutes acceptance:

• Internal Evaluation License: 90-day internal evaluation - no publication or release obligation, no deployment or production use. Built so a research team can test the signal quietly and convert commercially.
• Research License: non-commercial research with a model-release requirement (any model trained on this data must be publicly released with open weights and a model card).

No redistribution of the raw data without consent; commercial or production use requires a separate agreement (contact Origin Lab at https://app.originlab.ai). Access is open - downloading constitutes acceptance of the license; state your track when you contact us to convert.

References

1. N. Silberman, D. Hoiem, P. Kohli, R. Fergus. "Indoor Segmentation and Support Inference from RGBD Images." ECCV, 2012. (NYU Depth V2)
2. A. Geiger, P. Lenz, R. Urtasun. "Are We Ready for Autonomous Driving? The KITTI Vision Benchmark Suite." CVPR, 2012. A. Geiger, P. Lenz, C. Stiller, R. Urtasun. "Vision Meets Robotics: The KITTI Dataset." IJRR, 2013.
3. M. Roberts, J. Ramapuram, A. Ranjan, et al. "Hypersim: A Photorealistic Synthetic Dataset for Holistic Indoor Scene Understanding." ICCV, 2021.
4. A. Gaidon, Q. Wang, Y. Cabon, E. Vig. "Virtual Worlds as Proxy for Multi-Object Tracking Analysis." CVPR, 2016. Y. Cabon, N. Murray, M. Humenberger. "Virtual KITTI 2." arXiv:2001.10773, 2020.
5. J. He, H. Li, W. Yin, et al. "Lotus: Diffusion-based Visual Foundation Model for High-quality Dense Prediction." arXiv:2409.18124, 2024.
6. B. Ke, A. Obukhov, S. Huang, N. Metzger, R. C. Daudt, K. Schindler. "Repurposing Diffusion-Based Image Generators for Monocular Depth Estimation (Marigold)." CVPR, 2024.
7. L. Yang, B. Kang, Z. Huang, Z. Zhao, X. Xu, J. Feng, H. Zhao. "Depth Anything V2." NeurIPS, 2024. arXiv:2406.09414.
8. M. Oquab, T. Darcet, T. Moutakanni, et al. "DINOv2: Learning Robust Visual Features without Supervision." TMLR, 2023.

Citation

@misc{originlab2026gamedepth,
  title  = {Origin Lab Game-Depth: RGB + Dense Z-Buffer Depth},
  author = {Origin Lab},
  year   = {2026},
  url    = {https://app.originlab.ai}
}