teawhite/GameCrafter-Parkour

GameCrafter Rooftop Parkour

First-person rooftop parkour captured in Unreal Engine 5.8, made to train a whitebox → RGB video-to-video world model: the model takes a cheap, engine-free whitebox render of the scene as its control video and acts as the renderer.

The whitebox is not rendered by Unreal. The courses are procedurally generated by a small Python package (pk, included under code/pk) that only uses boxes, cylinders and capsules. The same package renders the whitebox control frames with a lightweight OpenGL renderer, both for this dataset and at inference time. That lets you generate new worlds and control videos in milliseconds per frame without a game engine. Unreal is only used here to produce the paired RGB frames and semantic maps from the same course and the same camera.

Each frame stores:

• the RGB frame rendered by Unreal;
• the whitebox control frame rendered by pk, pixel-aligned with the RGB;
• a pixel-aligned semantic id map from Unreal;
• the player's 7 keys (W, A, S, D, jump, crouch, sprint) and mouse yaw / pitch deltas;
• the camera pose and projection, the current parkour move, and 22 body joints.

It is a sibling of GameCrafter-Data-v4 and uses the same 10 Unreal scenes, but with a first-person camera on procedurally built rooftops instead of an isometric camera in the authored levels.

At a glance

Scenes	10 UE 5.8 scenes, each with its own architectural style
Runs	80 runs of 5 min (4,800 frames each), 8 per scene
Frames	384,000 at 16 fps (6.67 h)
Resolution	1280 × 704, first-person perspective, horizontal FOV 84–100°
Episodes	653 procedurally generated courses, about 30–50 s each
Ready-made 81-frame clips	4,455, none crossing an episode
Appearances	7 (default, golden, night, overcast, snow, autumn, palette)
Parkour moves	14 (run, turn, vault, slide, climb, wall run, balance, gap jump, long jump, drop, safety roll, land, stand, look around)
Whitebox ↔ Unreal alignment	97.75% mean per-pixel agreement of the semantic classes; camera error 0 cm
Label check	0 invalid semantic pixels across the whole set
Size	85 GB

previews/parkour_preview_80runs.mp4 shows 5 seconds of every run, RGB on the left and whitebox on the right.

How the data is made

1. Course generation (pk, pure Python). Each episode seed builds a rooftop course out of boxes and cylinders, in Unreal units (cm, Z up). It contains a route across flush-facade buildings with parapets or railings and obstacles placed on the route: AC units, crates, low walls and ledges to vault, pipes, beams, ducts and signs to slide under, planks and beams to balance on, gaps to jump, walls to climb or run along. Around the route it adds architectural dressing in the scene's style (windows with frames, sills, shutters, balconies and AC boxes; roof equipment such as stair houses, water tanks, vents, solar panels and dishes; setback towers, gable roofs, billboards) and a city of filler buildings.
2. Motion (pk). A timeline of parkour moves is simulated at 48 Hz. It produces the feet position, body rotation, a smoothed first-person camera with look-around noise and step bob, the keys held, and the joints of a procedural capsule body (the arm and leg FK sits on the UE mannequin skeleton).
3. RGB capture (Unreal). A UE player reads the same episode file. It builds the primitives as instanced meshes, dresses them with the scene's tiling materials plus CC0 PBR textures, aims the mannequin's limbs at the pk joints, and renders RGB and semantic ids from the logged camera. One frame is kept every 3 simulation steps, giving 16 fps.
4. Whitebox render (pk). pk.render_run re-renders every frame from the episode file and checks it against Unreal's semantic map.

Because the control video comes from the episode file and not from Unreal, any course you generate with pk gets exactly the same kind of control video as the training data.

Scenes and styles

Scene	pk style	Runs	Episodes	Clips	Whitebox agreement
01 Sunlit Mediterranean Courtyard	mediterranean	8	66	442	97.56%
02 Autumn Woodland Shrine	woodland	8	64	444	97.84%
03 Desert Caravanserai	desert	8	63	453	97.83%
04 Snowbound Mountain Outpost	snow	8	66	447	97.89%
05 Japanese Spring Sanctuary	japanese	8	66	449	97.63%
06 Overgrown Tropical Water Temple	tropical	8	66	444	97.72%
07 Steampunk Foundry District	industrial	8	65	441	97.73%
08 Gothic Cathedral Quarter	gothic	8	67	442	97.74%
09 Dense Cyberpunk Neon District	cyberpunk	8	66	447	97.59%
10 Underwater Research Habitat	habitat	8	64	446	98.02%

The style controls the facade dressing on the pk side (window layout, shutters, gables, towers, neon blades) and the material pools and colour palettes on the Unreal side. Every run uses a new set of course seeds.

Runs are named pk_<appearance>_s<run seed>, where run seed = scene × 1000 + round × 17. Round 1 is default for every scene; rounds 2–8 rotate through the other appearances.

Appearances

Appearance	Runs	Hours	What changes
default	20	1.67 h	the scene's own lighting
golden	10	0.83 h	low warm sun, long shadows, windows partly lit
night	10	0.83 h	moonlight and lit windows; exposure calibrated per scene so that mean brightness is about 45/255
overcast	10	0.83 h	dim diffuse light, denser fog
snow	10	0.83 h	snow on up-facing surfaces, cold grade
autumn	10	0.83 h	warm autumn colour grade
palette	10	0.83 h	random hue / saturation / brightness per semantic class

Window glass is emissive with a per-window random warm or cool colour. Its strength depends on the appearance: strong at night, medium at golden hour, faint in daylight.

RGB materials

• Every primitive has a material role (wall, roof, tiles, trim, frame, glass, glass_lit, shutter, concrete, metal, wood, ground, ad). Each scene draws each role from a style-specific pool of the scene's own tiling textures and 68 CC0 PBR texture sets from ambientCG (2K colour, normal, roughness and AO). code/ue_capture/cc0_textures.json lists them.
• Textures are box-mapped in each instance's local space at real-world scale. Each instance gets a random colour from the style's palette, plus fake edge AO, darkening at the bottom of walls, large-scale brightness variation and vertical rain streaks on walls.
• Walkable roofs only use calm concrete, asphalt and plaster in a mid-grey palette. Their normal map is weakened and their roughness is clamped, so the ground in front of the camera stays clean at grazing angles.

The whitebox

• Geometry is only boxes, cylinders and capsules, and the sky is black.
• Lighting is a fixed world-space light rig (key, fill and hemispheric ambient) that is independent of the RGB appearance. Faces with different orientations get different brightness, and far geometry is slightly darker.
• Dark contour lines are drawn at depth and normal discontinuities and fade out with distance. They separate faces that share an orientation but sit at different depths, such as an obstacle top against the roof or a window frame against the wall.
• The body is drawn as 16 capsules for the torso and limbs (upper arms, forearms, hands, thighs, shins, feet), slightly brighter than the scene. The head is not drawn because the camera is inside it.
• Rendering takes 3–6 ms per frame on a GPU with moderngl. Headless Linux works with backend="egl".

Alignment. For each run, pk also rendered semantic ids for 12 frames and compared them with Unreal's semantic map. Per-run mean agreement is 96.9–98.8% (97.75% overall), and the camera error is 0 cm everywhere. Mean IoU by class over all runs is sky 1.00, ground 0.95, roof 0.97, building 0.98 and obstacle 0.97. The player body class has a low IoU (0.45) because the capsules are deliberately simpler and thicker than the mannequin's silhouette; the joints themselves line up, and forearm and hand joints project onto Unreal's body pixels. Each run's numbers are in index/whitebox_render.json.

Per-frame contents

Each frame is one WebDataset sample inside a tar shard. The sample key is the 6-digit frame index within its run.

File in tar	Content
{frame}.jpg	RGB from Unreal, 1280×704, JPEG q85
{frame}.whitebox.jpg	Whitebox control frame from pk, 1280×704, JPEG q95
{frame}.ids.png	Semantic id map from Unreal, single-channel uint8, lossless, pixel-aligned
{frame}.json	Per-frame metadata from the capture (episode, step, move, camera pose, world_to_view, projection, world_to_clip, fov_x_deg, appearance, label_invalid_pixels)

Semantic classes

id	class	pixel share
0	sky	12.0%
1	ground (street level far below)	2.3%
2	roof surface (walkable tops)	38.0%
3	building / facade / window / parapet	39.7%
6	obstacle / prop	4.0%
10	player body	4.0%

The pixel shares were measured on 480 frames spread over all runs.

Index files per run

File	Content
frames.jsonl	One line per frame: episode, step (48 Hz simulation step), episode_start, episode_time_s, move, move_phase, speed_cm_s, feet_world_cm, body_pitch_yaw_roll, camera_world_cm, camera_pitch_yaw_roll, fov_x_deg, world_to_clip (row-major, world row vectors), action, mouse_deg
actions.npy	(N, 7) uint8 [w, a, s, d, jump, crouch, sprint], the keys held during the 3 simulation steps that end at the frame
mouse.npy	(N, 2) float32 [yaw_delta_deg, pitch_delta_deg] since the previous frame (0 on the first frame of an episode)
actions_block_0.25s.npy	(N/4, 7) uint8, keys OR-ed over 4-frame blocks
episodes.npy	(N,) int32 episode index
joints_world.npy	(N, 22, 3) float32 joints of the capsule body in world cm (names in the episode files)
clips_81.json	81-frame clips (start, end, episode, frame count per move), stride 80, never crossing an episode
episodes/ep_XXX.json	The pk episode files: the course and the 48 Hz state table (see below)
meta.json	Run statistics: appearance, character, move and obstacle counts, speed, eye height, alignment
capture_result.json	Capture settings and counts
whitebox_render.json	Whitebox render time and alignment check

Episode files

Each ep_XXX.json (format string pk_episode_v2) holds one course and its motion:

• prims: one list per primitive, [shape, cx, cy, cz, sx, sy, sz, pitch, yaw, roll, class, mat]. shape is 0 for a unit box and 1 for a Z-axis cylinder. Units are cm, the rotation is an Unreal rotator in degrees, class is the semantic id, and mat indexes mats, the material role names.
• State table at sim_hz = 48 with steps rows. feet is (steps, 3). rot is the body pitch / yaw / roll, (steps, 3). cam is (steps, 7), holding x, y, z, pitch, yaw, roll, fov. joints is the body-space joints, (steps, 22, 3). Also move (index into move_names), phase, speed, and actions (steps, 7).
• segments: the move timeline (move, start time, duration, start and end positions, yaws, speed). obstacles: the obstacles placed. body: the character model and scale.

Moves and behaviour

Move	Share of frames
run	48.8%
balance	10.0%
climb	6.1%
turn	4.9%
slide	4.7%
gap_jump	4.5%
vault	4.2%
wall_run	4.1%
stand	2.8%
land	2.5%
long_jump	2.2%
drop	1.9%
look_around	1.9%
safety_roll	1.3%

Obstacles built: balance plank 461, AC unit 305, ledge 301, low wall 284, crates 284, duct 242, sign 241, pipe 241, balance beam 224, slide beam 215.

Keys held over the whole set: W 95.3%, sprint 23.8%, crouch 6.3%, jump 2.3%, no key 4.7%. A, S and D are never pressed: steering is done with the mouse (median |yaw delta| 0.17° per frame, p99 7.7°). Mean speed is 516 cm/s.

Characters. Each run uses UE Manny (47 runs) or Quinn (33 runs) at a random scale of 0.92–1.08 with a random material variant. The median eye height per run is 153–178 cm. Arms, hands and sometimes legs are visible in the RGB.

Repository layout

data/<scene>/<run>/frames-000000.tar     frames 0–1599 of the run (WebDataset shard)
data/<scene>/<run>/frames-001600.tar     frames 1600–3199
data/<scene>/<run>/frames-003200.tar     frames 3200–4799
data/<scene>/<run>/index/                frames.jsonl, actions.npy, mouse.npy, actions_block_0.25s.npy, episodes.npy,
                                         joints_world.npy, clips_81.json, meta.json, capture_result.json,
                                         whitebox_render.json, episodes/ep_XXX.json
summary_parkour.csv / .json              per-run statistics and totals
thumbs/                                  one thumbnail per run
previews/parkour_preview_80runs.mp4      5 s of every run, RGB | whitebox
code/pk/                                 engine-free course generator, motion, capsule rig and whitebox renderer
code/ue_capture/                         Unreal capture player (C++), material builder, style tables, run scripts
code/post/                               indexing / export, preview and QA scripts

Loading a clip

import io, json, tarfile
import numpy as np
from PIL import Image
from huggingface_hub import hf_hub_download

REPO = "teawhite/GameCrafter-Parkour"
scene, run = "05_Japanese_Spring_Sanctuary", "pk_night_s5085"
get = lambda p: hf_hub_download(REPO, f"data/{scene}/{run}/{p}", repo_type="dataset")

clips = json.load(open(get("index/clips_81.json")))
actions = np.load(get("index/actions.npy")); mouse = np.load(get("index/mouse.npy"))
c = clips[10]; s, e = c["start"], c["end"]              # 81 frames inside one episode

def frames(lo, hi):                                       # read frames [lo, hi) from the 1,600-frame shards
    out = {}
    for shard in range(lo // 1600 * 1600, hi, 1600):
        with tarfile.open(get(f"frames-{shard:06d}.tar")) as tf:
            for m in tf:
                key, ext = m.name.split(".", 1)
                if lo <= int(key) < hi:
                    out.setdefault(int(key), {})[ext] = tf.extractfile(m).read()
    return [out[i] for i in range(lo, hi)]

clip = frames(s, e)
rgb = np.stack([np.asarray(Image.open(io.BytesIO(f["jpg"]))) for f in clip])                 # (81,704,1280,3)
ctrl = np.stack([np.asarray(Image.open(io.BytesIO(f["whitebox.jpg"]))) for f in clip])       # (81,704,1280,3)
ids = np.stack([np.asarray(Image.open(io.BytesIO(f["ids.png"]))) for f in clip])             # (81,704,1280) uint8
keys, look = actions[s:e], mouse[s:e]                                                        # (81,7), (81,2)

Run names are listed in summary_parkour.csv.

Re-rendering the whitebox, or making new worlds without Unreal

code/pk needs numpy, pillow and moderngl. To re-render any frame of the dataset from its episode file:

import json, sys
from huggingface_hub import snapshot_download

scene, run = "05_Japanese_Spring_Sanctuary", "pk_night_s5085"
root = snapshot_download("teawhite/GameCrafter-Parkour", repo_type="dataset", allow_patterns=["code/*", f"data/{scene}/{run}/index/*"])
sys.path.insert(0, f"{root}/code")
from pk import episode as E
from pk.motion import joints_world
from pk.rig import capsules_world
from pk.render import WhiteboxRenderer

idx = f"{root}/data/{scene}/{run}/index"
frames = [json.loads(l) for l in open(f"{idx}/frames.jsonl")]
r = WhiteboxRenderer(1280, 704)                      # backend="egl" on a headless Linux GPU machine
f = frames[1000]
J = E.load(f"{idx}/episodes/ep_{f['episode']:03d}.json")
r.set_scene([(p[0], p[1:4], p[4:7], p[7:10], p[10], p[11]) for p in J["prims"]])
k = f["step"]
caps = capsules_world(joints_world(J, k), J["body"]["scale"])
img = r.render(J["cam"][k], caps)                    # (704,1280,3) uint8: the whitebox of frame 1000
ids = r.render(J["cam"][k], caps, mode="ids")        # semantic ids rendered by pk

To generate brand-new courses and their control video, run this from code/:

python -m pk.make_control_video --seed 123 --episodes 3 --style mediterranean --out ctrl --mp4

It writes the whitebox frames at 16 fps, the episode files (with the keys and camera that drive the world model) and an mp4. New obstacle or building types only need to be assembled from box() / prim() calls in world.py / dress.py; the renderer and the Unreal player read any primitive list.

Capture details

• Unreal Engine 5.8, fixed-timestep simulation at 48 Hz with every 3rd step kept, so the 16 fps of game time do not depend on wall-clock speed.
• Each run waits for shader and asset compilation to go idle and warms up before the first saved frame. Texture streaming is off and anisotropic filtering is 16×, so ground textures stay sharp at grazing angles.
• Night exposure is solved per scene from two probe captures. Scene 10 gets +2 EV for daylight appearances because its default exposure is very dark.
• 3 of the 80 runs hit a GPU device-lost at startup and were captured again automatically. None of the kept runs has invalid labels.

Known limitations

• No strafing or backing up. A, S and D are never pressed; all turning comes from the mouse.
• Rooftops only. The player never goes down to street level. The ground class is the street far below and covers 2.3% of pixels.
• Simplified body in the whitebox. The capsule body is thicker and simpler than the RGB mannequin, which gives the body class an IoU of about 0.45 between whitebox and RGB.
• Procedural architecture. Buildings are assembled from boxes and cylinders; there are no curved or organic shapes beyond cylinders, and no vegetation, vehicles or people.
• Whitebox details the RGB adds. Texture-level detail (bricks, stains, lit windows) exists only in the RGB, as intended. Small UE-only differences, such as material normal maps and soft shadows, are not represented in the whitebox.
• Dynamic objects. Nothing moves except the player; the courses are static within an episode.