codepawl/100style-glb

100STYLE locomotion as GLB

810 motion capture clips from 100STYLE: 100 styles, 4,055,978 frames (18.8 hours) at 60 fps. Every clip is retargeted onto one free character and also ships as the bare source skeleton. Credit: The 100STYLE Dataset - Ian Mason.

Viewer, pick a style and watch it (works on a phone): https://huggingface.co/spaces/codepawl/100style-viewer

Files

Folder	Size	What	For
objects/	813.1 MB	character + clip, meshopt geometry and animation (16-bit quaternions), WebP textures, 60 fps	three.js, Babylon.js, web games
mobile/	574.4 MB	50 % of the triangles, textures at most 512 px in KTX2, clip at 30 fps	phones and light laptops
engine/	6.85 GB	no meshopt, no quantization, PNG textures, 60 fps	Godot, Blender, desktop engines
skeleton/	1.57 GB	the source 23-joint skeleton alone, original rotations, root motion, no mesh	retargeting onto your own rig

Each file holds one clip named after its id, <Style>_<Movement>: FW/BW forwards and backwards walk, FR/BR run, SW/SR sidestep walk and run, ID idle, TR1-3 transitions. The root bone carries the ground path (root motion); pelvis carries the rest of the hips motion. metadata.jsonl has one line per clip: style, its description, movement, frames, seconds and every file with its size.

The character uses the UE mannequin bone names (root, pelvis, spine_01, thigh_l, ...), so the engine/ clips retarget in Unreal and Godot like any mannequin animation. Fingers are not in the capture and stay at rest.

For web games and WebGPU

Use objects/ on desktop and mobile/ on phones. meshopt keeps the animation small (16-bit quaternions, keys a straight line already gives removed), and three.js decodes it with the same MeshoptDecoder as the mesh.

Measured on 12 clips. Phone page: 390x844 at 3x, pixel ratio capped at 2, CPU throttled 4x, network at Chrome's Fast 4G (150 ms, 9 Mbit/s), so phone load includes the download. The GPU is a desktop RTX 3060 and is not throttled: frame time shows the CPU side (skinning the clip included), a real phone GPU is slower.

Tier	File (median)	VRAM (median)	Triangles	Phone load (4G)	Frame time	WebGPU load (local)
web (12)	1.0 MB	27.6 MiB	14,318	1030 ms	1.0 ms	20 ms
mobile (12)	0.7 MB	1.5 MiB	7,157	778 ms	1.0 ms	8 ms

three.js (WebGPU):

import * as THREE from 'three';
import { WebGPURenderer } from 'three/webgpu';
import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
import { KTX2Loader } from 'three/addons/loaders/KTX2Loader.js';
import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';

const renderer = new WebGPURenderer({ antialias: true });
await renderer.init();
const ktx2 = new KTX2Loader().setTranscoderPath('https://cdn.jsdelivr.net/npm/three@0.187.0/examples/jsm/libs/basis/').detectSupport(renderer);
const loader = new GLTFLoader().setKTX2Loader(ktx2).setMeshoptDecoder(MeshoptDecoder);
const gltf = await loader.loadAsync('https://huggingface.co/datasets/codepawl/100style-glb/resolve/main/objects/Neutral_FW/Neutral_FW.glb');
scene.add(gltf.scene);
const mixer = new THREE.AnimationMixer(gltf.scene);
mixer.clipAction(gltf.animations[0]).play();
// every frame: mixer.update(deltaSeconds)

The clips share one skeleton, so a clip from one file plays on the character of another: load one character, then only the animations of the rest.

Use it in 67js

67js plays these clips with its skeleton pose layers:

npm install 67js@npm:@codepawlhq/67js meshoptimizer

import { Renderer67 } from '67js';
import { loadGltf } from '67js/addons/gltf';
import { clipFromGltfAnimation, createAssetPose } from '67js/addons/skeleton-pose';
import { MeshoptDecoder } from 'meshoptimizer';

const character = await loadGltf('https://huggingface.co/datasets/codepawl/100style-glb/resolve/main/objects/Neutral_FW/Neutral_FW.glb', { decoders: { meshopt: MeshoptDecoder } });
const pose = createAssetPose(character, { layers: [{ clip: clipFromGltfAnimation(character.animations[0], { loop: true }) }] });
const renderer = new Renderer67(document.querySelector('canvas'), character.parts, { ground: true });
function frame(milliseconds) {
  pose.apply(milliseconds / 1000);
  renderer.updateParts(character.parts);
  const hips = pose.jointWorld('pelvis').position;
  renderer.render({ eye: [hips[0] + 2.5, 1.6, hips[2] + 3.5], target: hips });
  requestAnimationFrame(frame);
}
requestAnimationFrame(frame);

Retarget quality

Each rig bone takes the world rotation change of its source joint, lined up once between the source T-pose and the character's rest pose. The ground path is scaled by the leg length ratio, then a two-bone leg IK puts the ball of each foot where the source's was, lowering the pelvis a few centimetres where the character's shorter foot needs it.

Every clip was played back from its engine/ file and compared with the source BVH (810/810 passed):

Check	Source	Retargeted
Ball of the foot sliding while planted (median)	0.041 m/s	0.041 m/s
Ankle sliding while planted (median)	0.063 m/s	0.051 m/s
Worst clip, sliding beyond the source		0.019 m/s
Frames with a knee bent backwards that the source does not have		0
Root path, largest gap from the scaled source path		0.0 mm

Planted means within 3 cm of the foot's lowest point and under 0.25 m/s sideways in the source. Mocap feet slide a little on their own; the retarget may not add more than 2 cm/s.

Tested

Every file was loaded and its first clip played (some joint must move more than 1 cm at one of nine points through it), then drawn (drawn pixels counted), in three.js 0.187.0 and 67js 0.15.0, files from a local copy of this repository.

After upload, all 4,055 files on this repository matched the tested local files by sha256, and every tier of 24 items was loaded again from https://huggingface.co/datasets/codepawl/100style-glb/resolve/main: three.js WebGL 96/96, three.js WebGPU 96/96, 67js 72/96.

Tier	three.js WebGL	three.js WebGPU	67js
web	810/810	810/810	810/810
mobile	810/810	810/810	810/810
engine	810/810	810/810	810/810
skeleton	810/810	810/810	0/810 (67js loadGltf refuses a glTF with no mesh yet, codepawl/67.js#480)

Blender 5.2 import: engine 810/810, objects 810/810, skeleton 810/810. Godot 4.7.2 editor import, then the clip played: engine 12/12, skeleton 12/12.

Licence and credit

The 100STYLE Dataset - Ian Mason. Licence: CC-BY-4.0 (https://creativecommons.org/licenses/by/4.0/).

• Character (rig and mesh): Quaternius, Universal Base Characters, CC0-1.0 (https://quaternius.com/packs/universalbasecharacters.html)

Changes made: Trimmed with the dataset's Frame_Cuts.csv, converted from centimetres to metres, retargeted onto a CC0 Quaternius character with leg IK that keeps the source foot contacts, exported as glTF 2.0 with web, mobile and engine variants. The source skeleton clips keep the original joint rotations.

If you use the motion in research, cite the paper:

Ian Mason, Sebastian Starke, Taku Komura. Real-Time Style Modelling of Human Locomotion via Feature-Wise Transformations and Local Motion Phases. Proc. ACM Comput. Graph. Interact. Tech. 5(1), 2022. https://arxiv.org/abs/2201.04439

Source: https://www.ianxmason.com/100style/. Packed by CodePawl.