README.md

---
license: cc-by-4.0
task_categories:
- image-to-image
tags:
- neural-rendering
- differentiable-rendering
- synthetic-data
- 3d
size_categories:
- 1M<n<10M
configs:
- config_name: main
  data_files:
  - split: train
    path: main/shard-*.tar
- config_name: zoom
  data_files:
  - split: train
    path: zoom/shard-*.tar
- config_name: validation
  data_files:
  - split: validation
    path: validation/shard-*.tar
- config_name: caustic
  data_files:
  - split: train
    path: caustic/shard-*.tar
- config_name: caustic_envmap
  data_files:
  - split: train
    path: caustic_envmap/shard-*.tar
- config_name: caustic_smooth
  data_files:
  - split: train
    path: caustic_smooth/shard-*.tar
- config_name: caustic_envmap_smooth
  data_files:
  - split: train
    path: caustic_envmap_smooth/shard-*.tar
- config_name: test
  data_files:
  - split: train
    path: test/shard-*.tar
- config_name: hybrid_1024_blender
  data_files:
  - split: train
    path: hybrid_1024_blender/shard-*.tar
---

# Procgen RenderFormer Dataset

Procedurally generated indoor scenes with ground-truth path-traced renders and
precomputed 3-slat VAE latents, built for training [RenderFormer]-style
neural renderers. Each sample is one scene observed from 14 camera poses along
an orbit.

## Configs

| Config | Scenes | Samples (scene x frame) | Notes |
|---|---|---|---|
| `main` | ~307,000 | ~4.3 M | primary training set |
| `zoom` | ~84,000 | ~1.2 M | tighter framing variant |
| `validation` | ~1,000 | ~14 K | held-out **assets**, not just held-out scenes |
| `caustic` | ~20,000 | ~62 K | **caustic dielectric dataset** (6,144 SPP Mitsuba GT + 4th material slat: `slat3`) |
| `caustic_envmap` | ~35,600 | ~180 K | **environment-map caustic dataset** (lit by 997 Poly Haven HDRIs with continuous orbit + Qwen-Image VAE latents) |
| `caustic_smooth` | ~20,000 | ~80 K | **curated smooth caustic dataset** (Tier 1 & Tier 2 Easy/Moderate glass pool with clean all-zero slat3 baseline) |
| `caustic_envmap_smooth` | ~20,000 | ~120 K | **curated smooth envmap caustic dataset** (curated smooth pool lit by 997 Poly Haven HDRIs + Qwen-Image VAE) |
| `test` | 997 | ~4 K | **non-caustic point-light test set** (1,024 SPP Mitsuba GT, 4 frames per scene; even split of Cornell box with a moving light, camera trajectory, dolly zoom and walkthrough; standard PBR assets only, `slat3` holds the non-caustic baseline) |

## Sample layout

This is a [WebDataset]. Each sample carries:

```
<key>.000.webp .. <key>.013.webp   GT renders, 512x512 uint8 sRGB, lossless WebP
<key>.latents.safetensors          coords + per-role feats for all 14 frames
<key>.json                         scene provenance, camera, lighting, materials
```

The latents hold three roles sharing one coordinate grid per frame (a unified-proxy
encode):

| Role | Meaning |
|---|---|
| `shape` | geometry |
| `slat1` | PBR: albedo / metallic / roughness / alpha |
| `slat2` | emissive / normal / occlusion + light flag |
| `slat3` | caustic: $\sigma_t$ (extinction) / IOR / $\xi$ (transmittance) / albedo (scattering) |

Frames are concatenated along the token axis with a `frame_offsets` index rather
than stored separately, so frame `i` is `coords[frame_offsets[i]:frame_offsets[i+1]]`.
Token count varies slightly per frame (~2750) because light proxies are voxelized
in per frame.

## Loading

```python
from datasets import load_dataset

ds = load_dataset("eternity304/procgen-renderformer", "validation", split="validation", streaming=True)
sample = next(iter(ds))
```

Fields arrive as raw bytes. Decode them with:

```python
import io, json
import numpy as np
from PIL import Image
from safetensors.torch import load as st_load

ROLES = ("shape", "slat1", "slat2", "slat3")

def decode(sample):
    frames = np.stack([
        np.array(Image.open(io.BytesIO(sample[k])).convert("RGB"))
        for k in sorted(k for k in sample if k.endswith(".webp"))
    ])                                              # uint8 [14, 512, 512, 3]
    tensors = st_load(sample["latents.safetensors"])
    return frames, tensors, json.loads(sample["json"])

def frame_latents(tensors, i):
    """coords [N,3] int32 and {role: feats [N,32] fp16} for frame i."""
    a, b = tensors["frame_offsets"][i], tensors["frame_offsets"][i + 1]
    return tensors["coords"][a:b], {r: tensors[f"{r}_feats"][a:b] for r in ROLES}
```

`coords` are integer latent-voxel indices in `[0, latent_grid)` where
`latent_grid = resolution // VAE_SPATIAL_DOWNSAMPLE`. Map them to `[-0.5, 0.5]`
centres at model time.

## Composed 3D scenes (`test`)

For benchmarking other renderers, `test_assets/` holds every mesh and texture the `test`
scenes use: 1,947 Objaverse GLBs (byte-identical to `allenai/objaverse`) and 624 texture
folders, 9.6 GB, with `manifest.json` listing each file's sha256 and the scenes using it.
Each sample's JSON references them relatively: `assets[].glb_rel` under
`test_assets/objaverse/`, `scene.surfaces[*].dir_rel` under `test_assets/texture_zoo/`.
Compose them with neural-rendering's `export_composed_scenes.py`:

```bash
hf download eternity304/procgen-renderformer --repo-type dataset \
    --include "test/*" "test_assets/*" --local-dir procgen
python scripts/objaverse/procgen_vae/export_composed_scenes.py \
    --shards 'procgen/test/shard-*.tar' --assets-root procgen/test_assets --out-dir composed
```

which writes, per sample:

- `composed/<key>/scene.glb`: the static world-space scene (room + posed assets, PBR
  materials, embedded textures), exactly the mesh the VAE encoder voxelized. It is glTF
  Y-up: the scene JSON's Z-up world mapped by `(x, y, z) -> (x, z, -y)`, which Blender's
  glTF importer undoes, so the per-frame cameras and point lights in the JSON `timeline`
  (Z-up) line up with it. Only cameras and lights move between frames.
- `composed/<key>/mitsuba/gtc.json` + meshes + textures (relative paths): the Mitsuba scene
  the GT frames were rendered from (`render_diamond_orbit.py --scene .../gtc.json`).

## Provenance

Scenes compose meshes from **Objaverse-LVIS** with PBR materials from
**PolyHaven**, **ambientCG**, and **cgbookcase** (all CC0). Every scene records
the source asset UIDs under `assets[].uid` in its JSON, so individual renders
remain traceable to their source meshes.

Renders are derivative works of the source meshes. Objaverse licenses are
per-asset and mixed; consult `assets[].uid` against the Objaverse annotations
for the terms covering any particular scene.

## Generation

Rendered at 64 spp, 512x512, 14 frames per scene at 12 fps, Blender/OpenGL camera
convention. Full generator configuration is embedded per scene under
`generator_config` and `_dataset`.

[RenderFormer]: https://arxiv.org/abs/2505.21925
[WebDataset]: https://github.com/webdataset/webdataset