README.md

---
license: other
license_name: originlab-noncommercial-research
license_link: LICENSE.md
task_categories:
- depth-estimation
- image-to-image
tags:
- depth
- monocular-depth
- rgbd
- game-engine
- dense-ground-truth
- pretraining
size_categories:
- 10K<n<100K
pretty_name: Origin Lab Game-Depth (RGB + Dense Z-Buffer)
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train-*.parquet
  - split: test
    path: data/test-*.parquet
  - split: extra
    path: data/extra-*.parquet
---

<p align="center">
  <img src="https://huggingface.co/datasets/originlab/game-depth/resolve/main/assets/logo.png" alt="OriginLab" width="320">
</p>

# 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`](https://huggingface.co/datasets/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](https://originlab.ai)

**Data:** this repo (load with `load_dataset("originlab/game-depth")`).<br>
**Models / checkpoints:** [`originlab/lotus-game-depth`](https://huggingface.co/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

```python
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.

![KITTI zero-shot, all models](figures/kitti_samples.png)

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).

![Per-image ground-plane strength](figures/geometry_profile.png)

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.)

![NYU: game pre-training then fine-tuning](figures/nyu_progression.png)

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, both models fine-tuned](figures/nyu_samples.png)

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`](results/game_distribution.json).

## Released models

Both models trained with this dataset are released (same license) in one repo: **[`originlab/lotus-game-depth`](https://huggingface.co/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`](METHODOLOGY.md); machine-readable metrics (including per-frame) in
[`results/`](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`](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

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