smerkd/c4d-scenes

C4D procedural compact scenes

Procedurally generated 4D geometry for multiview reconstruction, camera inference, surface/interior/air trajectories, normals and feature supervision. Generation target: 6,000 accepted physical scenes. This is an incremental release. Read index.json for the actual verified scene count and available shards; the target is not a claim that generation has finished. Only indexed shards are ready.

The release contains original procedural assets, losslessly compressed authoritative motion state, camera/appearance recipes, and 768-dimensional procedural feature programs. It does not persist every dense image, projected feature tensor or query trajectory. Replay renders RGB, metric depth/range, geometric normals and observed synthetic feature tokens; it samples fresh queries and derives targets from the same decoded state. These tokens are synthetic, not frozen DINO/VGGT encoder outputs. An RGB encoder can be trained using the RGB and geometric targets.

Interactive scene viewer

Open the C4D Scene Explorer

Browse the uploaded index and inspect six verified production scenes with a timeline, six camera views, surface tracks, and reference-frame normals. Interactive previews show sampled decoded GT geometry with body colors, including hidden surfaces; they are not RGB/depth renders or training query sets. Separate, labeled development videos show RGB/depth/normals/features and pointmaps. The viewer runs entirely in your browser; no GPU or shard download is needed for the prepared previews. Other episodes link to their checksummed full shards.

Scene mix and scope

The initial release uses the S5 composition configuration with 32 authoritative ticks, six stored camera views, and 224×224 observation recipes. The code retains the earlier S0–S5 curriculum. Final requested world quotas are 25% outdoor, 20% indoor, 20% mixed, 15% orbital, 10% deep space, and 10% abstract. Independent quotas span six metric scale bands, sparse through very crowded configurations, and natural/abstract/adversarial appearance. Each physical scene has independent geometry, motion and appearance draws; there are no imported Kubric assets. The pilot covers the six worlds at sparse/moderate densities; it is not a random population benchmark. Accepted composition and rejection metrics accompany each scene.

Rigid, articulated, deforming, water and particle configurations are supported. Full fluid simulation remains optional (5% candidate probability in this release, subject to admission); do not assume every scene contains fluid or that all procedural animation is a physically accurate simulation. Failed candidates are recorded; attempts never relax camera clearance, shared-object or 5px observability rules. Category quotas survive retries. The final accepted mix of non-quota attributes can be conditioned by admission.

Storage, splits and integrity

index.json lists tar shard paths, SHA256 hashes, byte sizes, scene IDs and splits. Each scene contains archive/manifest.json, its COMPLETE checksum, compressed blobs, config.yaml and accepted.json. The archive reader uses an allowlisted data schema, not pickle. Source and environment provenance are in releases/r18_6000/source.zip and provenance.json.

Train/validation assignment is deterministic by physical scene identity (about 95%/5%). All regenerated camera/query/appearance variants of a scene keep its split. This split does not establish held-out topology-family generalization. The first uploaded shard is fully downloaded, checksummed, safely extracted and replayed through a real PyTorch DataLoader before the controller expands. Subsequent payloads are checked against Hub content hashes before index commits.

Loading

Extract the release's source.zip and use its pinned source. Follow its README and provenance package versions to install the CUDA/Torch/Warp/nvdiffrast stack; also install huggingface_hub. Source hashes must match—do not disable validation to work around an incompatible generator. Replay currently requires a supported CUDA environment; CPU-only archive inspection is supported. CPU-readable blobs are not a claim of a CPU renderer.

From the source directory, download one bounded shard:

python scripts/download_scene_shard.py --repo smerkd/c4d-scenes --shard 0 --cache outputs/hf_scene_cache

Use returned archive paths from one split:

from scripts.download_scene_shard import download
from procedural4d.data.windows import ReplayWindowDataset, collate_windows
from torch.utils.data import DataLoader

archives = [path for path, split in download(
    'smerkd/c4d-scenes', 0, 'outputs/hf_scene_cache') if split == 'train']
dataset = ReplayWindowDataset(
    archives, schema='central-rays-v2', seed=17, epochs=1,
    examples_per_scene=64, n_queries=128, resolution=224,
    views=(1, 6), frames=(3, 32), augment=True)
loader = DataLoader(dataset, batch_size=1, num_workers=0,
                    collate_fn=collate_windows)
batch = next(iter(loader))
model_inputs = batch['inputs']
targets = batch['targets']
dense_targets = batch['dense_targets']

For multiprocessing, use a guarded if __name__ == '__main__' entry point, allow_cuda_workers=True, multiprocessing_context='spawn', and bounded prefetch (start at one). Each GPU worker holds a bank and renderer scratch; choose worker counts to fit available memory. More workers are not a guaranteed speedup. Rotate downloaded shards and evict unused files to bound disk usage. The download helper limits each extraction; it does not automatically evict older shards.

The loader samples 1–6 views with 3–32 observations per view, possibly asynchronous, and up to 128 real queries with explicit padding masks. Short windows can have fewer valid queries. Reusing 64 windows amortizes a render bank; these are not 64 new scenes or freshly rendered cameras. New camera banks are sampled during refill, subject to admission, which can reject a bank. Do not catch a rejection and silently lower coverage/size thresholds.

Coordinates and supervision

The central loader uses a fixed reference frame anchored to one camera at one observed time, with an identity offset approximately half the time and a sampled rigid offset otherwise. For metric world point x, anchor (R_a,c_a), offset (R_G,t_G), and one positive scale s (meters per example unit):

x_ref = R_G @ R_a.T @ (x_world - c_a) / s + t_G
n_ref = R_G @ R_a.T @ n_world

Camera centers, pointmaps and all target tracks obey the same transform at every time. Normals rotate only. meta.world_to_ref and its inverse are QC/target conversion metadata, not model inputs. Timestamps are seconds relative to the anchor; meta.anchor_time_seconds restores absolute clip time. Sampling uses stored authoritative ticks; no interpolation through unknown physics events.

inputs is explicitly allowlisted: RGB, observed tokens, times, query requests, and optionally masked camera/range information. Calibration, poses and range are each supplied independently with roughly 20% probability per view; absent inputs are zero with false masks. targets, dense_targets and private meta must not be fed to the encoder/decoder as observations. No owner/link/cell IDs, query classes, binding coordinates or future tracks enter deployable inputs.

Central cameras include pinhole, distortion, wide/fisheye and panorama models. Use ray distance (dense_targets.range_unit) and unit camera-local rays, not a pinhole K assumption for every lens. Dense pointmaps are available lazily with procedural4d.data.central.dense_xyz(example) for a single unbatched example (NumPy or Torch, including CUDA tensors). Reference normals are in dense_targets.normals_ref. Valid sky has infinite range and no surface/normal; out-of-sensor and temporal padding are separate masked invalid regions.

Track targets are targets.tracks_ref; use q_valid, trajectory_valid and resolution_valid together. Normal and feature supervision have their own masks. Air probes are stationary in world/reference coordinates even when occupied; interior material points follow their bound solid. Neither is an optical visibility negative. Bindings never change because an object crosses a probe.

The D-dimensional clean descriptor target is factorized into a base and optional time-dependent components. On CPU, data.pretrain.feature_at_times(targets) expands only the requested queries/times; then transfer that slice to the model's device. No dense Q×T×D cache is required. RGB/noise augmentations do not modify the geometric targets. The existing data.supervision.losses provides example masked losses for unbatched predictions; call per example for ragged batches.

Validation and limitations

The release pipeline runs CPU contract tests, real GPU replay and spawned-loader checks, coordinate/ray/depth/normal consistency audits, and a tiny RGB+feature network's finite-gradient optimizer smoke. The smoke verifies trainability of the interface; it is not a trained reconstruction model or an accuracy result. No 100 FPS claim is made for uncached rendering, generation, or model training. QC colors/videos can flicker because of sparse time sampling and deliberate observation corruption. Authoritative geometry and masks remain separate.