Datasets:
|
Download README.md from hosamprns/simready-glb: direct link, hf CLI and curl.
- Browser
- Download file 11.9 kB
-
https://huggingface.co/datasets/hosamprns/simready-glb/resolve/main/README.md
- Command line
-
hf download hf://datasets/hosamprns/simready-glb/README.md
-
curl -L -o README.md https://huggingface.co/datasets/hosamprns/simready-glb/resolve/main/README.md
11.9 kB
| license: cc-by-4.0 | |
| pretty_name: SimReady GLB | |
| tags: | |
| - 3d | |
| - gltf | |
| - glb | |
| - web | |
| - three.js | |
| - simready | |
| - nvidia | |
| size_categories: | |
| - 1K<n<10K | |
| configs: | |
| - config_name: default | |
| data_files: | |
| - split: train | |
| path: | |
| - "thumbs/*.webp" | |
| - "thumbs/metadata.jsonl" | |
| # SimReady GLB | |
|  | |
| **[Open the 3D viewer](https://huggingface.co/spaces/codepawl/simready-glb-viewer)** to search all 2,595 models and | |
| orbit any of them in the browser. | |
| Web-ready glTF binary (`.glb`) copies of the 3D models in | |
| [nvidia/simready-assets](https://huggingface.co/datasets/nvidia/simready-assets). Each file loads directly in | |
| three.js, Babylon.js, model-viewer or any glTF 2.0 viewer. | |
| Models by NVIDIA SimReady, licensed CC BY 4.0. This dataset converts and compresses them. It does not change what | |
| they show. If you use these files, credit NVIDIA as the original author and link the source dataset. | |
| | | Blender export | This dataset | | |
| |---|---|---| | |
| | Assets | 2,595 | 2,595 | | |
| | Total size | 228.1 GB | 3.2 GB | | |
| | Triangles | 821M | 415M | | |
| | Largest texture edge | 4096 px | 1024 px | | |
| Example: the V8 engine (`engineAssembly_v8_engine_a01`) is an 888 MB glb out of Blender and | |
| 7.4 MB here. Its first frame in Chrome took 9.4 s before and 0.57 s after. | |
| ## What is in it | |
| - `glb/<asset>.glb`: one file per SimReady asset folder, named like the folder in the source dataset. | |
| - `thumbs/<asset>.webp`: a 512 px render of each glb, with `thumbs/metadata.jsonl` holding its category, size, | |
| triangles and draw calls. The Dataset Viewer above shows this table. | |
| - `manifest.jsonl`: one line per asset with size, triangles, draw calls and textures before and after optimization, | |
| plus the number of hulls, concave parts and drives. | |
| - `newton_loader/`: the loader for NVIDIA Newton. | |
| ## Download | |
| All files, about 3.2 GB: | |
| ```bash | |
| hf download codepawl/simready-glb --repo-type dataset --local-dir simready-glb | |
| ``` | |
| One category, for example every food model: | |
| ```bash | |
| hf download codepawl/simready-glb --repo-type dataset --include "glb/food_*" --local-dir simready-glb | |
| ``` | |
| One file from Python: | |
| ```python | |
| from huggingface_hub import hf_hub_download | |
| path = hf_hub_download("codepawl/simready-glb", "glb/engineAssembly_v8_engine_a01.glb", repo_type="dataset") | |
| ``` | |
| ## Loading in three.js | |
| The geometry uses `EXT_meshopt_compression` and the textures use `EXT_texture_webp`, so set the meshopt decoder: | |
| ```js | |
| import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js'; | |
| import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js'; | |
| const loader = new GLTFLoader(); | |
| loader.setMeshoptDecoder(MeshoptDecoder); | |
| loader.load('engineAssembly_v8_engine_a01.glb', (gltf) => scene.add(gltf.scene)); | |
| ``` | |
| ## Physics and moving parts | |
| 2,587 files carry the rigid bodies, mass and physics materials of their SimReady USD. 929 of | |
| them also carry joints, 5,550 in all: door hinges, drawer slides, buttons, wheels and lids. Each file holds | |
| this data in two forms: | |
| - `KHR_physics_rigid_bodies`, the Khronos glTF physics extension. Each part has a `motion` with its mass, center of | |
| mass and inertia. Each mesh has a convex hull `collider` with friction and restitution. Each joint has its limits. | |
| Loaders that do not read the extension ignore it. | |
| - Plain node extras, which three.js puts in `object.userData`. A moving part has | |
| `joints: [{ type, parent, pivot, axis, min, max, unit }]`, with the pivot and axis in model space at rest. | |
| Revolute limits are in degrees and prismatic limits are in meters. Parts also have `mass` in kg and `density` in | |
| kg/m³. | |
| Open a door or a drawer in three.js from its rest pose (the part's parent is at the model origin): | |
| ```js | |
| import * as THREE from 'three'; | |
| function movePart(part, value) { | |
| const { type, pivot, axis } = part.userData.joints[0]; | |
| const direction = new THREE.Vector3(...axis); | |
| if (type === 'prismatic') { | |
| part.position.addScaledVector(direction, value); | |
| return; | |
| } | |
| const turn = new THREE.Quaternion().setFromAxisAngle(direction, THREE.MathUtils.degToRad(value)); | |
| const center = new THREE.Vector3(...pivot); | |
| part.position.sub(center).applyQuaternion(turn).add(center); | |
| part.quaternion.premultiply(turn); | |
| } | |
| movePart(gltf.scene.getObjectByName('door_01_obj_00'), 90); | |
| ``` | |
| The 3D viewer shows a slider for each moving part. The files from before the physics data are kept at the `v1` tag: | |
| add `--revision v1` to the download command. | |
| ## Simulating in NVIDIA Newton | |
| Each file with physics data also carries the data that a simulator needs and a viewer does not: | |
| - 17,507 collision hulls in `extras.collisionHulls` of each body node. 2,852 of the 8,496 parts are concave. | |
| A concave part gets up to 8 hulls, so a cabinet or a bin stays hollow. A hull has at most 48 points, or 32 in a concave part. | |
| - 2,145 joint drives in 333 files, in the `drives` array of the joint in `KHR_physics_rigid_bodies`. | |
| - Inertia of 256 small parts in 67 files, which the earlier rounding had set to zero. | |
| These additions make the set 0.17% larger: 3,180.2 MB to 3,185.5 MB, with a median file of 0.416 MB. Meshes, materials and | |
| textures are byte-identical to the earlier files in all 2,595 files. The hulls sit after the old binary data, so | |
| existing loaders read the files as before. | |
| Half of the files have hulls within 3.9 mm of the part's own convex shape. The figure is 12 mm at the 95th percentile | |
| and 177 mm in the worst file. A hull side that is nearly flat along an axis is then made exactly flat, which moves its | |
| points outward by up to 2 cm. Newton's contact code turns an uneven bottom into false depth, which kicks the part upward. | |
| `newton_loader/simready_newton` adds a file to a Newton model. It needs Newton 1.7, SciPy and meshoptimizer. | |
| ```python | |
| import newton | |
| import newton.solvers | |
| from simready_newton import add_simready_glb | |
| builder = newton.ModelBuilder(up_axis=newton.Axis.Y) | |
| builder.add_ground_plane() | |
| add_simready_glb(builder, "glb/bin_waste_a01.glb", position=(0.0, 0.5, 0.0)) | |
| model = builder.finalize() | |
| solver = newton.solvers.SolverXPBD(model, iterations=8, joint_linear_relaxation=0.3, joint_angular_relaxation=0.2) | |
| ``` | |
| Use these two relaxation values with `SolverXPBD`. The default linear value of 0.7 went NaN on | |
| `scaffold_rolling_steel_a03` within a few frames. The default angular value of 0.4 went NaN on | |
| `climate_shopFan_pedestal_a01` when every joint was pushed at once. The loader read all 2,595 files with no failures. | |
| 8 files have no rigid bodies, so it adds nothing for them. | |
| In a file with joints, the loader raises any part's inertia below 1e-4 kg·m² to that value. A part's rotation is slower | |
| than the source says, and it no longer shakes or goes NaN. Set `jointed_part_inertia_floor` to change the value. Files | |
| with one rigid body use 1e-6 kg·m² (`inertia_floor`). | |
| 43 files across the categories were simulated at 60 fps with 8 substeps. 42 of them were compared with their SimReady USD: | |
| | Check | Result | | |
| | --- | --- | | |
| | Mass, center of mass, joint type, pivot, axis, limits, friction, restitution | Match | | |
| | Dropped from 20 cm stays finite | 43 of 43 | | |
| | Dropped from 20 cm is at rest after 3 s | 31 of 43 | | |
| | Dropped from 20 cm is at rest after 9 s (the 12 files left) | 10 of 12 | | |
| | Every joint pushed at once on a pinned base stays finite | 43 of 43 | | |
| At rest means under 0.05 m/s and 0.5 rad/s. The push test stops pushing a free axle above 200 rad/s. `conveyor_belt_a61` | |
| stayed finite at 400 rad/s and went NaN at 800 rad/s, so keep free axles below that at 480 substeps per second. | |
| ## How the files were made | |
| 1. Download `simready_usd/` from each asset folder. `source_assets/` is skipped because it holds a second copy of | |
| the textures for MDL shaders. | |
| 2. Check that `.metadata/LICENSE.txt` is CC BY 4.0. | |
| 3. Import the USD in Blender 5.2 and remove the collision, proxy and grasp helper prims. Export a glb with the | |
| original textures. | |
| 4. Optimize with glTF Transform 4.5. Remove the USD instance prototypes Blender brings in next to the placed parts, | |
| remove duplicate mesh instances, then dedup, prune and weld. | |
| 5. Resize textures to 1024 px as WebP. Compress geometry with meshopt at its high level | |
| (`EXT_meshopt_compression` with octahedral normals and quantized attributes). | |
| 6. Read the rigid bodies, mass, physics materials and joints from the USD layers and write them into the glb JSON. | |
| The USD is Z-up, so joint frames and axes are turned to the glb's Y-up. | |
| 7. Cut each concave part into convex pieces and keep the hull points that stick out most. Make nearly flat hull sides | |
| exactly flat. Read the drives and the full inertia from the USD. Append the hulls after the binary data. | |
| Assets with UDIM textures have each tile split into its own material before the export, with its UVs moved into 0-1. | |
| Blender's own UDIM handling in the glTF exporter drops the faces of some tiles. | |
| No mesh simplification is applied. The triangle drop comes from removed duplicates and helper geometry. | |
| The conversion scripts are in | |
| [codepawl/3d-builds](https://github.com/codepawl/3d-builds/tree/main/works/2026-10-28-simready-showcase/batch). | |
| ## Known gaps | |
| SimReady collides with signed distance fields built from each render mesh. The `collider` of each mesh in | |
| `KHR_physics_rigid_bodies` stays one convex hull, which every engine can build, so hollow parts collide as if filled | |
| there. Use `extras.collisionHulls` to keep them hollow. `KHR_physics_rigid_bodies` is still a Khronos review draft, so | |
| check that your engine reads it. The node extras work with any loader. USD simulation settings are not carried | |
| over. Materials are converted to glTF PBR, so MDL-only shader effects are lost. | |
| In Newton, parts of one file do not collide with each other, because SimReady's overlapping parts jam their hinges | |
| otherwise. Nothing latches a door or a drawer, so use a drive to hold them closed. Two sample files do not stay still: | |
| - `electrical_power_terminal_a01` is 5.1 m tall and 0.52 m deep, and it falls over when it stands free. Load it with | |
| `fixed_base=True`. | |
| - `paint_supplies_brush_a05`, a 44 g brush, still rocks after 9 s. With `rigid_contact_relaxation=0.2` it settles in 9 s. | |
| Inertia differs from the USD where the loader raises it to its floor. Only 43 of the 2,595 files had these simulation | |
| checks, so other files can have the same problems. | |
| Two joints in the USD are left out because they hold nothing: the fixed joint of | |
| `ladder_multiPurpose_aluminium_a05` points at a part with no rigid body, and one fixed joint of | |
| `serviceTool_brakeCaliper_pistonWindBackKit_a01` joins a body to itself. | |
| ## Changelog | |
| - 2026-11-01: Added collision hulls that keep concave parts hollow, joint drives and the inertia of small parts. | |
| Added a loader for NVIDIA Newton. The set grows by 0.17%. Meshes, materials and textures do not change. | |
| - 2026-10-29: Added physics from the USD files: rigid bodies, mass, physics materials and 5,550 joints, as | |
| `KHR_physics_rigid_bodies` and as node extras. The viewer shows a slider for each moving part. The files before this | |
| change are at the `v1` tag. | |
| - 2026-10-29: Geometry is encoded at meshopt's high level. The set went from 4.0 GB to 3.2 GB with the same | |
| triangles and no visible change in any of the 2,595 thumbnails. | |
| - 2026-10-29: 52 files with UDIM textures were missing geometry, because Blender's glTF exporter dropped | |
| the faces of some texture tiles (for example crate_plywood_b01 kept only its metal frame). They are exported again | |
| with the tiles split before the export. | |
| - 2026-10-29: 1,305 files carried a second copy of some parts at the origin, the USD instance prototypes | |
| Blender imports next to the placed parts (for example the eyeglasses showed two pairs of arms). Those copies are | |
| removed. Added thumbnails, the Dataset Viewer table and the 3D viewer Space. | |
| - 2026-10-28: first release. | |