feat(vrm): 바디 애니 스트리밍 + idle 클립 미동봉 (Mixamo 라이선스)

10_vrm_live_streaming(청킹+바디), tools/fbx_to_clip(FBX→클립 추출). 09/10 --idle 선택화 + rest-pose fallback. avatar_vrm/idle.npz 삭제 — Mixamo 모션 데이터 raw 재배포 불가, 사용자가 직접 준비. 데모 영상은 바디 idle 포함(완성품 embed 는 무관). submodule 718ff68.

.gitignore

@@ -1,4 +1,13 @@
+# Python
 __pycache__/
-*.pyc
-.cache/
-*.tmp.wav
+*.py[cod]
+*$py.class
+*.so
+
+# Editor / OS
+.DS_Store
+.vscode/
+.idea/
+
+# Body animation clips — user-supplied (Mixamo 등, 재배포 금지). tools/fbx_to_clip.py 로 생성.
+example/avatar_vrm/*.npz

README_lipsync.md

@@ -100,6 +100,26 @@ python 08_vrm_video.py --backend numpy           # no-GPU fallback
 > to map your own character's blendshapes (9 or more) — see
 > [README_bs2d.md](./README_bs2d.md).**
 
+## Body animation (optional)
+
+`09_vrm_live.py` and `10_vrm_live_streaming.py` add a skeletal **body idle**
+on top of lipsync — GPU skinning via `raster_gles_skinned`. It needs a body
+**clip** (`--idle clip.npz`); **without one the body stays at rest pose**
+(lipsync and video still render fine).
+
+Make a clip from any FBX skeletal animation with `tools/fbx_to_clip.py`
+(needs `bpy` — `pip install bpy`):
+
+```bash
+python tools/fbx_to_clip.py  idle.fbx  avatar_vrm/idle.npz
+python 09_vrm_live.py --idle avatar_vrm/idle.npz
+```
+
+The clip is **not bundled** — animation assets such as Mixamo are
+royalty-free to embed in your rendered output, but their raw motion data is
+generally not redistributable, so supply your own. `BodyClipPlayer` assumes
+a loop-authored clip; `fbx_to_clip.py` drops the duplicate loop endpoint.
+
 ## Quick start
 
 ```python
@@ -181,7 +201,8 @@ body** (GPU skinning + body idle animation — `09_vrm_live.py`).
 | **E2E**                | **5580 ms · RTF 0.77**   |
 
 > Reproduce: `cd example && python bench_vrm.py --backend gles --model-dir ..`
-> (lipsync only) — add `--body avatar_vrm/idle.npz` for lipsync + body.
+> (lipsync only) — add `--body <clip.npz>` for lipsync + body (see
+> *Body animation* above for making a clip).
 >
 > **lipsync only** sits at **RTF ≈ 0.6**, **lipsync + body** at
 > **RTF ≈ 0.77** — both comfortably faster than realtime. Body animation
@@ -215,10 +236,11 @@ body** (GPU skinning + body idle animation — `09_vrm_live.py`).
   anim_body (skeleton) / raster (numpy + egl/moderngl + gles + gles_skinned).
 - **bs2d mapping detail**: [README_bs2d.md](./README_bs2d.md)
 - **Examples**: `07_avatar_video.py` (atlas) · `08_vrm_video.py` (blendshape)
-  · `09_vrm_live.py` (blendshape + body animation)
-  · `06_streaming_with_lipsync.py` · `bench_lipsync.py` (atlas) · `bench_vrm.py` (blendshape)
-- **Sample assets**: `example/avatar/` (2D) · `example/avatar_vrm/` (3D VRM
-  + `idle.npz` body clip)
+  · `09_vrm_live.py` (blendshape + body) · `10_vrm_live_streaming.py`
+  (streaming + body) · `06_streaming_with_lipsync.py`
+  · `bench_lipsync.py` (atlas) · `bench_vrm.py` (blendshape)
+- **Body-clip tool**: `example/tools/fbx_to_clip.py` — FBX → `.npz` body clip
+- **Sample assets**: `example/avatar/` (2D) · `example/avatar_vrm/` (3D VRM)
 
 ## License
 

README_lipsync_ko.md

@@ -95,6 +95,26 @@ python 08_vrm_video.py --backend numpy           # GPU 없는 환경
 > 만든 캐릭터의 blendshape(9개 이상) 매핑법은
 > [README_bs2d_ko.md](./README_bs2d_ko.md) 참고.**
 
+## 바디 애니메이션 (선택)
+
+`09_vrm_live.py` · `10_vrm_live_streaming.py` 는 립싱크에 스켈레톤 **바디
+idle** 을 더한다 — `raster_gles_skinned` GPU skinning. 바디 **클립**
+(`--idle clip.npz`) 이 필요하며, **클립이 없으면 바디는 rest pose 로** 렌더
+된다 (립싱크·영상은 정상).
+
+클립은 FBX 스켈레톤 애니메이션에서 `tools/fbx_to_clip.py` 로 만든다
+(`bpy` 필요 — `pip install bpy`):
+
+```bash
+python tools/fbx_to_clip.py  idle.fbx  avatar_vrm/idle.npz
+python 09_vrm_live.py --idle avatar_vrm/idle.npz
+```
+
+클립은 **동봉하지 않는다** — Mixamo 등 애니메이션 에셋은 렌더 결과물에
+embed 하는 건 royalty-free 이나 원본 모션 데이터의 재배포는 일반적으로
+불가하므로 각자 준비할 것. `BodyClipPlayer` 는 loop-authored 클립을
+가정하며, `fbx_to_clip.py` 가 loop endpoint 복제 프레임을 제거한다.
+
 ## 빠른 시작
 
 ```python
@@ -176,7 +196,8 @@ end-to-end (TTS + lipsync + 눈 깜박임 + morph + 렌더, 512×768, ffmpeg
 | **E2E**               | **5580 ms · RTF 0.77**   |
 
 > 재현: `cd example && python bench_vrm.py --backend gles --model-dir ..`
-> (lipsync only) — `--body avatar_vrm/idle.npz` 추가 시 lipsync + body.
+> (lipsync only) — `--body <clip.npz>` 추가 시 lipsync + body (클립 만드는
+> 법은 위 *바디 애니메이션* 참고).
 >
 > **lipsync only** 은 **RTF ≈ 0.6**, **lipsync + body** 는 **RTF ≈ 0.77**
 > — 둘 다 realtime 보다 여유 있게 빠름. 바디 애니메이션은 CPU **FK +
@@ -209,10 +230,11 @@ end-to-end (TTS + lipsync + 눈 깜박임 + morph + 렌더, 512×768, ffmpeg
   anim_body (스켈레톤) / raster (numpy + egl/moderngl + gles + gles_skinned).
 - **bs2d 매핑 상세**: [README_bs2d_ko.md](./README_bs2d_ko.md)
 - **예제**: `07_avatar_video.py` (atlas) · `08_vrm_video.py` (blendshape)
-  · `09_vrm_live.py` (blendshape + 바디 애니메이션)
-  · `06_streaming_with_lipsync.py` · `bench_lipsync.py` (atlas) · `bench_vrm.py` (blendshape)
-- **샘플 자산**: `example/avatar/` (2D) · `example/avatar_vrm/` (3D VRM
-  + `idle.npz` 바디 클립)
+  · `09_vrm_live.py` (blendshape + 바디) · `10_vrm_live_streaming.py`
+  (스트리밍 + 바디) · `06_streaming_with_lipsync.py`
+  · `bench_lipsync.py` (atlas) · `bench_vrm.py` (blendshape)
+- **바디 클립 도구**: `example/tools/fbx_to_clip.py` — FBX → `.npz` 바디 클립
+- **샘플 자산**: `example/avatar/` (2D) · `example/avatar_vrm/` (3D VRM)
 
 ## 라이선스
 

example/09_vrm_live.py

@@ -44,13 +44,17 @@ DEFAULT_TEXT = (
 )
 
 
-def live_portrait(model, width, height):
-    """상반신 portrait — 말하기 + 바디 idle 둘 다 보이는 카메라 (정면 -Z)."""
+def bust_portrait(model, width, height):
+    """얼굴 위주 버스트샷 카메라 (08_vrm_video.py 와 동일, 정면 -Z).
+
+    talking-head 라이브 에이전트 — 얼굴 중심. 바디 애니메이션은 머리/어깨/
+    목의 미세한 idle 로 화면에 드러난다 (팔 등은 프레임 밖).
+    """
     head = head_position(model)
-    target = head + np.array([0.0, -0.32, 0.0])
-    eye = target + np.array([0.0, 0.04, -1.55])
+    target = head + np.array([0.0, -0.03, 0.0])
+    eye = target + np.array([0.0, 0.05, -1.20])
     view = look_at(eye, target)
-    proj = perspective(30.0, width / height, 0.05, 20.0)
+    proj = perspective(26.0, width / height, 0.05, 20.0)
     return view, proj
 
 
@@ -110,13 +114,19 @@ def main():
     wav_dur = len(wav) / 22050
     print(f"  wav {wav_dur:.2f}s · lipsync {n} frames · TTS {tts_sec*1000:.0f} ms")
 
-    # --- 2. VRM 로드 + 골격 + 바디 클립 ---
+    # --- 2. VRM 로드 + 골격 + 바디 클립 (선택) ---
     model = load_vrm(args.vrm)
     skel = VRMSkeleton(model)
-    player = BodyClipPlayer(args.idle, skel)
-    view, proj = live_portrait(model, W, H)
-    print(f"  body idle: {player.n_frames} frames @ {player.fps:.0f}fps "
-          f"({player.duration:.1f}s, loop)")
+    view, proj = bust_portrait(model, W, H)
+    rest_jm = skel.rest_joint_matrices()          # 클립 없을 때 fallback
+    player = None
+    if args.idle and os.path.isfile(args.idle):
+        player = BodyClipPlayer(args.idle, skel)
+        print(f"  body idle: {player.n_frames} frames @ {player.fps:.0f}fps "
+              f"({player.duration:.1f}s, loop)")
+    else:
+        print(f"  body idle 클립 없음 ('{args.idle}') — rest pose 로 렌더 "
+              f"(바디 애니메이션 비활성, 립싱크·영상은 정상)")
 
     # 얼굴 morph (lipsync) — LOCAL 공간
     face_pos, face_morphs = face_local_baked(model)
@@ -133,9 +143,11 @@ def main():
     def frame_fn(i):
         nonlocal t_pose, t_morph
         a = time.perf_counter()
-        # 바디 idle — 발화 시간축에 맞춰 재생 (loop, slerp 보간)
-        world = skel.fk(player.pose_at(i / args.fps))
-        joint_mats = skel.joint_matrices(world)
+        # 바디 idle — 클립 있으면 시간축 재생(loop, slerp), 없으면 rest pose
+        if player is not None:
+            joint_mats = skel.joint_matrices(skel.fk(player.pose_at(i / args.fps)))
+        else:
+            joint_mats = rest_jm
         b = time.perf_counter()
         # 얼굴 morph (lipsync) — LOCAL
         face_local = A.morph_face(face_pos, face_morphs, weights[i])
@@ -144,9 +156,9 @@ def main():
         t_morph += c - b
         return renderer.render(joint_mats, view, proj, face_local=face_local)
 
-    renderer.render(skel.joint_matrices(skel.fk(player.pose_at(0))),
-                    view, proj)                       # warmup
-    print(f"[render] GPU skinning (lipsync + body) → {args.out}")
+    renderer.render(rest_jm, view, proj)                  # warmup
+    mode = "lipsync + body" if player else "lipsync (body=rest pose)"
+    print(f"[render] GPU skinning ({mode}) → {args.out}")
     rsec = encode_video(frame_fn, n, W, H, args.fps, wav_path, args.out)
 
     # --- 벤치마크 ---

example/10_vrm_live_streaming.py

@@ -0,0 +1,178 @@
+"""
+10_vrm_live_streaming.py — VRM 립싱크 + 바디 (스트리밍 / 청킹)
+
+09_vrm_live.py 의 스트리밍 버전. `StreamingTTS` 가 LLM 토큰 스트림을 받아
+강한 구두점마다 (wav, lipsync) 청크를 emit → 청크가 도착하는 대로 렌더한다.
+
+핵심 — **바디 idle 은 전역 anim 시계로 구동**:
+    각 청크의 얼굴 morph 는 그 청크의 lipsync 로,
+    바디 pose 는 청크를 가로지르는 전역 프레임 카운터 g 로 `pose_at(g/fps)`.
+    → 청크 경계에서 바디가 리셋되지 않고 연속 재생·loop 된다.
+    (청크별 0 부터 다시 재생하면 청크마다 idle 이 튄다 — 반드시 전역 시계.)
+
+카메라는 얼굴 위주(bust). 라이브 에이전트 talking-head 용.
+
+사용:
+    python 10_vrm_live_streaming.py
+    python 10_vrm_live_streaming.py --text "..." --out live.mp4
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import tempfile
+import time
+
+import numpy as np
+import soundfile as sf
+
+from ppaso_tts import PpasoTTS, StreamingTTS
+from ppaso_lipsync import generate_blink_timeline
+from ppaso_vrm import (load_vrm, look_at, perspective, head_position,
+                       vrm_anim as A, face_local_baked,
+                       VRMSkeleton, BodyClipPlayer, SkinnedGLRenderer)
+
+
+DEFAULT_TEXT = (
+    "엣지디바이스용 경량화 립싱크 애니메이션 기능이 추가되었습니다. "
+    "애니메이션은 커브로 구성되어 있어, 스프라이트 기반의 애니메이션 뿐만 아니라, "
+    "블렌드쉐입 기반의 3D 애니메이션에서도 적용 가능합니다."
+)
+
+
+def bust_portrait(model, width, height):
+    """얼굴 위주 버스트샷 카메라 (08_vrm_video.py 와 동일, 정면 -Z)."""
+    head = head_position(model)
+    target = head + np.array([0.0, -0.03, 0.0])
+    eye = target + np.array([0.0, 0.05, -1.20])
+    view = look_at(eye, target)
+    proj = perspective(26.0, width / height, 0.05, 20.0)
+    return view, proj
+
+
+def fake_token_stream(text, chunk=3):
+    """LLM 토큰 스트림 시뮬레이션 — 텍스트를 chunk 글자씩 흘린다."""
+    for i in range(0, len(text), chunk):
+        yield text[i:i + chunk]
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--text", default=DEFAULT_TEXT)
+    ap.add_argument("--vrm", default="./avatar_vrm/AvatarSample_F.vrm")
+    ap.add_argument("--idle", default="./avatar_vrm/idle.npz")
+    ap.add_argument("--model-dir", default="..")
+    ap.add_argument("--out", default="vrm_live_streaming.mp4")
+    ap.add_argument("--fps", type=int, default=30)
+    ap.add_argument("--width", type=int, default=512)
+    ap.add_argument("--height", type=int, default=768)
+    ap.add_argument("--seed", type=int, default=42)
+    args = ap.parse_args()
+    W, H = args.width, args.height
+
+    # --- 셋업 ---
+    print(f"[setup] '{args.text}'")
+    tts = PpasoTTS(args.model_dir, backend="onnx")
+    stream = StreamingTTS(tts)
+    model = load_vrm(args.vrm)
+    skel = VRMSkeleton(model)
+    face_pos, face_morphs = face_local_baked(model)
+    view, proj = bust_portrait(model, W, H)
+    renderer = SkinnedGLRenderer(model, W, H)
+    rest_jm = skel.rest_joint_matrices()          # 클립 없을 때 fallback
+    player = None
+    if args.idle and os.path.isfile(args.idle):
+        player = BodyClipPlayer(args.idle, skel)
+        print(f"  body idle: {player.n_frames} frames @ {player.fps:.0f}fps "
+              f"({player.duration:.1f}s loop)")
+    else:
+        print(f"  body idle 클립 없음 ('{args.idle}') — rest pose 로 렌더 "
+              f"(바디 애니메이션 비활성)")
+
+    # --- 비디오 파이프 (영상만; 오디오는 청크 wav 모아 마지막에 mux) ---
+    vid_tmp = os.path.join(tempfile.gettempdir(), "_vrm_live_vid.mp4")
+    proc = subprocess.Popen(
+        ["ffmpeg", "-y", "-loglevel", "error", "-f", "rawvideo",
+         "-pix_fmt", "rgba", "-s", f"{W}x{H}", "-r", str(args.fps), "-i", "-",
+         "-c:v", "libx264", "-pix_fmt", "yuv420p", "-crf", "20", vid_tmp],
+        stdin=subprocess.PIPE)
+
+    g = 0                       # 전역 프레임 카운터 = 바디 anim 시계
+    chunk_idx = 0
+    all_wavs = []
+    t_tts = t_render = 0.0
+
+    def render_chunk(wav, lip):
+        """청크 1개 — 얼굴 morph(청크 lipsync) + 바디 pose(전역시계) 렌더."""
+        nonlocal g, chunk_idx, t_render
+        blink = generate_blink_timeline(duration=lip.duration, fps=args.fps,
+                                        seed=args.seed + chunk_idx)
+        weights = A.morph_weight_timeline(lip.xy_timeline, model,
+                                          blink.curve_timeline)
+        for i in range(len(weights)):
+            t0 = time.perf_counter()
+            face_local = A.morph_face(face_pos, face_morphs, weights[i])
+            # 바디 — 클립 있으면 전역 시계 재생(청크 경계 무관 연속), 없으면 rest
+            if player is not None:
+                joint_mats = skel.joint_matrices(skel.fk(player.pose_at(g / args.fps)))
+            else:
+                joint_mats = rest_jm
+            img = renderer.render(joint_mats, view, proj, face_local=face_local)
+            t_render += time.perf_counter() - t0     # ffmpeg write 제외
+            try:
+                proc.stdin.write(np.ascontiguousarray(img, np.uint8).tobytes())
+            except BrokenPipeError:
+                break
+            g += 1
+        all_wavs.append(wav)
+        chunk_idx += 1
+        print(f"  chunk {chunk_idx:2d}: {len(wav)/22050:5.2f}s wav, "
+              f"{len(weights):3d} frames  (g={g})")
+
+    # warmup
+    renderer.render(rest_jm, view, proj)
+
+    # --- 토큰 스트림 → 청크 합성 → 렌더 ---
+    print("[stream] 토큰 흘리는 중 — 강한 구두점마다 청크 emit")
+    for tok in fake_token_stream(args.text):
+        t0 = time.perf_counter()
+        chunks = list(stream.feed_with_lipsync(tok, fps=args.fps))
+        t_tts += time.perf_counter() - t0
+        for wav, lip in chunks:
+            render_chunk(wav, lip)
+    t0 = time.perf_counter()
+    tail = list(stream.flush_with_lipsync(fps=args.fps))
+    t_tts += time.perf_counter() - t0
+    for wav, lip in tail:
+        render_chunk(wav, lip)
+
+    proc.stdin.close()
+    proc.wait()
+
+    # --- 오디오 mux ---
+    joined = np.concatenate(all_wavs)
+    wav_path = os.path.join(tempfile.gettempdir(), "_vrm_live_audio.wav")
+    sf.write(wav_path, joined, 22050)
+    subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-i", vid_tmp,
+                    "-i", wav_path, "-c:v", "copy", "-c:a", "aac",
+                    "-b:a", "128k", "-shortest", args.out], check=True)
+    os.remove(vid_tmp)
+
+    # --- 벤치마크 ---
+    wav_dur = len(joined) / 22050
+    e2e = t_tts + t_render
+    print("=" * 60)
+    print(f"스트리밍 — {chunk_idx} chunks, {g} frames, wav {wav_dur:.2f}s")
+    print(f"  TTS+lipsync (청크 누적) : {t_tts*1000:8.0f} ms")
+    print(f"  render (청크 누적)      : {t_render*1000:8.0f} ms  "
+          f"({t_render/g*1000:.1f} ms/frame)")
+    print(f"  ── E2E                  : {e2e:.2f}s   RTF {e2e/wav_dur:.3f}")
+    print(f"  → {args.out}")
+    print("=" * 60)
+    renderer.release()
+
+
+if __name__ == "__main__":
+    main()

example/avatar_vrm/idle.npz

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6c21987154052c47303975b0f18c2b1476ce77bf3e9bcfa70115de8fccb8a1ed
-size 747115

example/ppaso_vrm/vrm_anim_body.py

@@ -219,7 +219,14 @@ def retarget(clip, skeleton: VRMSkeleton):
 class BodyClipPlayer:
     """리타게팅된 바디 클립을 시간 기반으로 재생. loop + slerp 보간.
 
-    pose_at(t)  — 임의 시각(초) 의 포즈 (렌더 fps ≠ 클립 fps 대응).
+    **loop-authored 클립을 가정한다** — 첫↔마지막 프레임이 이어지도록
+    제작된 idle/loop 애니메이션. `pose_at` 은 `% n_frames` 로 감싸 무한
+    반복한다. 비-loop 클립이면 wrap 지점에서 pop 이 보인다 (그 경우 클립
+    자체를 loop-authored 로 교체).
+
+    pose_at(t)  — 임의 시각(초) 의 포즈. 스트리밍/청킹에서는 청크별로
+                  리셋하지 말고 **전역 anim 시계**(start_anim_time + 경과)
+                  를 넘기면 청크 경계와 무관하게 연속 재생된다.
     frame_pose(i) — 정수 클립 프레임 (보간 없음, 클립 fps 고정 영상용).
     """
 

example/tools/fbx_to_clip.py

@@ -0,0 +1,85 @@
+"""
+fbx_to_clip.py — FBX 스켈레톤 애니메이션 → BodyClipPlayer 용 .npz 클립
+
+오프라인 도구. Mixamo 등에서 받은 FBX 애니메이션을 `ppaso_vrm.BodyClipPlayer`
+가 읽는 .npz (골격 rest + 프레임별 armature-space 행렬) 로 변환한다.
+디바이스 런타임에는 불필요 — 바디 애니메이션 클립 준비용.
+
+요구: `bpy` (Blender Python 모듈). `pip install bpy` 로 PyPI 에서 설치
+가능 (Blender 설치와 무관). FBX 파싱은 Blender 의 FBX importer 를 쓴다.
+
+사용:
+    python fbx_to_clip.py  input.fbx  output.npz
+
+  그 다음 09_vrm_live.py / 10_vrm_live_streaming.py 에 --idle output.npz.
+
+핵심:
+  - action.frame_range (실제 키프레임 범위) 로 추출 — Blender scene 기본
+    범위(1..250)가 아님. 이걸 안 맞추면 클립이 잘리거나 늘어난다.
+  - Mixamo loop endpoint (마지막 = 첫 프레임 복제) 자동 drop → seamless.
+  - 출력 npz: bones / parents / rest(B,4,4) / anim(F,B,4,4) / fps / nframes.
+
+리타게팅(→ VRM humanoid)은 런타임 BodyClipPlayer 가 로드 시 수행한다.
+
+⚠ 애니메이션 라이선스 — Mixamo 등 외부 클립은 각 제공처 약관 확인.
+   Mixamo: 완성품(렌더 영상 등)에 embed 는 royalty-free 이나, 애니메이션
+   데이터 자체의 독립 재배포는 금지 — 변환한 .npz 를 공개 배포하지 말 것.
+   각자 받은 클립을 각자 프로젝트에서 쓰는 용도.
+"""
+import sys
+
+import numpy as np
+import bpy
+
+
+def main():
+    if len(sys.argv) < 3:
+        sys.exit("usage: python fbx_to_clip.py  input.fbx  output.npz")
+    fbx, out = sys.argv[1], sys.argv[2]
+
+    bpy.ops.wm.read_factory_settings(use_empty=True)
+    bpy.ops.import_scene.fbx(filepath=fbx)
+    arm = next((o for o in bpy.data.objects if o.type == "ARMATURE"), None)
+    if arm is None:
+        sys.exit("ERROR: FBX 안에 armature 없음")
+    scene = bpy.context.scene
+
+    act = arm.animation_data.action if arm.animation_data else None
+    if act is None:
+        sys.exit("ERROR: armature 에 action(애니메이션) 없음")
+    f0, f1 = (int(round(x)) for x in act.frame_range)
+    nframes = f1 - f0 + 1
+    print(f"action '{act.name}'  frame_range {f0}..{f1} = {nframes} frames")
+
+    posebones = list(arm.pose.bones)
+    bones = [pb.name for pb in posebones]
+    idx = {n: i for i, n in enumerate(bones)}
+    parents = np.array(
+        [idx.get(pb.parent.name, -1) if pb.parent else -1 for pb in posebones])
+    rest = np.stack(
+        [np.array(arm.data.bones[n].matrix_local, np.float64) for n in bones])
+    anim = np.zeros((nframes, len(bones), 4, 4), np.float64)
+    for fi, frame in enumerate(range(f0, f1 + 1)):
+        scene.frame_set(frame)
+        for bi, pb in enumerate(posebones):
+            anim[fi, bi] = np.array(pb.matrix, np.float64)
+
+    # Mixamo loop endpoint — 마지막 프레임이 첫 프레임 복제면 drop
+    R = anim[:, :, :3, :3]
+    typ = float(np.median([np.abs(R[i + 1] - R[i]).mean()
+                           for i in range(nframes - 1)]))
+    if nframes > 2 and float(np.abs(R[-1] - R[0]).mean()) < typ * 0.3:
+        anim = anim[:-1]
+        nframes -= 1
+        print(f"loop endpoint 복제본 drop → {nframes} frames")
+
+    fps = scene.render.fps / scene.render.fps_base
+    np.savez_compressed(
+        out, bones=np.array(bones), parents=parents,
+        rest=rest.astype(np.float32), anim=anim.astype(np.float32),
+        fps=np.float64(fps), nframes=np.int64(nframes))
+    print(f"saved: {out}  ({nframes} frames @ {fps:.0f}fps)")
+
+
+if __name__ == "__main__":
+    main()

samples/08_vrm_lipsync.mp4

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:139507c912191d8f7af19196699e2f1a7f39e86f218e375d7cea4733f1fd22b9
-size 2839263
+oid sha256:97b302dd6eaab444b13333a122850399da97c1dd3b197fdf5acfc838efc1da24
+size 2541608