找回密码
 立即注册
搜索
查看: 235|回复: 0

【MMD】解析VMD格式读取

[复制链接]

986

主题

92

回帖

5万

积分

管理员

积分
55255
发表于 2022-6-30 08:28:08 | 显示全部楼层 |阅读模式
前言
2 d( @3 A* f  N2 |! d% I, z1 M. Z" T- k
  MikuMikuDance(简称MMD)是一款动画软件,早期视为Vocaload角色制作动画的软件,现在还经常能在B站等视频网站,或一些动画网站(某I站)看到MMD作品。
+ ~. T/ P! m/ @% e2 ]  我在高中也简单学过操作这款软件以及PE、水杉等软件,学会了简单k帧、套动作、调渲染、加后期、压缩等技术,这与我学习计算机专业有很大的关系(虽然学校学的和这个八竿子打不着,或许我应该学美术去),现在已经分不清很多东西了,封面静画就是杂七杂八过气MME一锅扔的成果,得益于G渲的强大,还能看出一点效果。
6 p- Q# `3 I  B  现在我想学一些3D的开发,包括用程序读取模型、动作等,很快我就想到之前用过的MMD。
: a" H2 z3 s! ~. `7 ^+ x& c/ b  一些3D姿势估计(3D pose estimate)或许能得到骨骼位置以及PAF(骨骼间关系),但我需要知道3D动画是如何储存动作数据的,才能想到怎样将姿势估计得到的数据转化为动作数据。4 c7 S# Z5 m1 _5 R; K$ o
  因此我找了一些资料解析MMD的动作数据VMD(Vocaload Mation Data)文件,并写下这篇记录。& {# ?6 U( f8 e9 H* a- i, A! {

6 E% _8 l- C( c  根据MMD的规矩,上借物表:8 c% V5 i) h+ B9 ]( I- A9 H
名称 来源
MikuMikuDanceE_v803 圝龙龍龖龘圝
八重樱 神帝宇

! s; g. p  ]' I9 D9 X  e
, o; H: Q8 V( H3 b! y; h9 x( I, {封面静画:
" Y$ X1 d, s0 q' i) {
名称 类别\来源
LightBloom 背光
AutoLuminousBasic 自发光特效
HgSAO 阴影
SoftLightSB 柔化
SvSSAO 阴影
XDOF 景深
dGreenerShader G渲
Tokyo Stage 场景
' D3 y: \( R9 q- Z4 v) J; n
一、格式说明! j8 G& o& R9 ^0 i4 b! q
, c' P7 L+ t0 `+ k9 w7 s, k
  首先,vmd文件本身是一个二进制文件,里面装着类型不同的数据:uint8、uint32_t、float,甚至还有不同编码的字符串,因此我们需要二进制流读入这个文件。) X$ x. T: N! D( d
  vmd格式很像计算机网络的协议格式,某某位是什么含义,区别是,vmd文件的长度理论上是无限的,让我们来看看。; n' y, m5 R) `5 H) y7 c1 B
  vmd的大致格式如下:' D, P" J/ A5 e
9 J$ j1 N  w' r4 T# t, O
    头部' {3 D6 ~  ]2 D( H5 a3 }
    关键帧数量# `& r2 D( H2 S5 P) F
    关键帧
- J* v. M6 i! S" u
* c8 ]* R0 p. W2 I  g7 E头部- y3 {4 i; m3 Z

5 R, J% L+ h+ [* ?* \! R4 M; T  最开始的就是头部(header),看到这就有十分强烈的既视感:# H1 U! m+ {" ^
类型 # f  w0 h7 x. p& \$ O
长度 含义
byte 30 版本信息
byte 10 or 20 模型名称

& h! ?# X3 J( t! l* V* v" H6 l9 i, [- V( A$ v+ j/ l4 o( f/ B
  其中,版本信息(VersionInformation)长度为30,是ascii编码的字符串,翻译过来有两种,一为“Vocaloid Motion Data file”,二为“Vocaloid Motion Data 0002”,长度不足30后用\0(或者说b'\x00')填充。这是由于vmd版本有两种,大概是为了解决模型名称长度不足,因此后续只影响模型名称的占用长度。% e3 n$ Z! C6 x$ r4 q
  模型名称(ModelName),是动作数据保存时用的模型的模型名,通过这个我们可以获取到那个名称,我们知道,一个动作数据想要运作起来,只要套用模型的骨骼名称是标准的模板就可以,因此我想象不出这个名称有何用处,或许某些模型带有特殊骨骼,例如翅膀之类的,这样能方便回溯?模型名称的长度根据版本而决定,version1为10,version长度为20。编码原文写的是shift-JIS,是日语编码,这样想没错,然而我试验后发现并非如此,例如经常改模型的大神神帝宇的模型,他的模型名称用shift-JIS为乱码,用gb2312竟然能正常读出来;还有机动牛肉大神的模型,他的模型名称用gb2312无法解码,用shift-JIS解码竟然是正常的简体中文???怎么做到的?
8 ~5 n7 K) ?) M* w/ f9 L骨骼关键帧(BoneKeyFrame)- |' x: A* F/ L5 d! K6 j6 W

* n$ \+ x. V4 h" y3 i  骨骼关键帧,分为两部分:骨骼关键帧数、骨骼关键帧记录:" U  `" M' n& w& V1 ~2 M" V
类型 长度 含义
uint32_t4
9 v2 F# V' ^/ V. @4 g
骨骼关键帧数量 BoneKeyFrameNumber
' H2 D1 C, i% @% a% Q9 n- x
类型 长度 含义
byte 15 骨骼名称 BoneName
uint32_t 4 关键帧时间 FrameTime
float*3 12 x,y,z空间坐标 Translation.xyz
float*4 16 旋转四元数x,y,z,w Rotation.xyzw
uint8_t * 16 or uint32 * 4 16补间曲线x的坐标 XCurve
  D8 U6 K. F( c  E
uint8_t * 16 or uint32 * 4 16 补间曲线y的坐标 YCurve
uint8_t * 16 or uint32 * 4 16 补间曲线z的坐标 ZCurve
uint8_t * 16 or uint32 * 4 16 补间曲线旋转的坐标 RCurve
byte 111 合计

& K$ {4 W! k/ M* h. s" |5 |1 C# B) X$ H1 z. N1 N
  为何要分开写呢?因为骨骼关键帧数量只需要一个就够了,而后面骨骼关键帧记录的数量会和前面的骨骼关键帧数量保持一致。
' G! a4 a5 ~, s" @8 V" A* Q

- w) c# E" |% S3 D  我们可以查一下,每个骨骼关键帧的数量为111字节。# X9 J9 C" [4 I- ~" V
旋转坐标
9 \# Q* g: y/ D* M% w( u9 g8 D
+ R8 H+ G$ H$ {* ^% k  一开始还没发现,旋转坐标竟然有四个,分别为x, y, z, w,急的我去MMD里查看一下,发现和我印象中没有什么差别
4 H3 T, _9 p) _% r4 h. J0 Q/ |
都是[-180, 180]的角度值,我用程序跑的时候,这四个值完全看不懂;幸好在英文网站上找到这个表示方法:四元数。四元数是用四个值表示旋转的方法
: s$ }+ ~- h0 z- K4 h. \! K; uw+i·x+j·y+k·z
4 w4 S5 x; J& E/ s* F7 i! j5 M,其中" g2 i6 R/ d$ v4 I
i、j、k4 L) G1 Z$ O2 j5 c) n/ M9 Z& A: z
都是虚数,我上网找了一堆资料,并且得到了四元数转化欧拉角的公式
3 u% h' J( o9 ?- g. e# I. W* p! m) ~, I\large X = \arcsin {(2wx-2yz)} \\ \large Y = \arctan2 {(2wy+2xz, 1-2x^2-2y^2)} \\ \large Z = \arctan2 {(2wz+2xy, 1-2x^2-2z^2)} \\$ m9 A( i- Y5 ]8 r" R- D
得到的是角度制,我们通过角度制转弧度制的公式即可算出和MMD中等同的角度表示。
, h0 N+ J# Z* J1 g# q; \( \3 K& y9 m) R- n2 Q! y
补间曲线
8 i0 D4 K- K3 G% ]3 `9 n0 E0 q9 [' S* t
  为何补间曲线的类型不确定呢?上面csdn博客的教程说“uint8_t那里有冗余,每四个只读第一个就行”。说的没有问题,首先我们要清楚这个补间曲线坐标的含义。
% B0 X8 K4 w7 [0 V- d  我们打开MMD,读入模型,随意改变一个骨骼点,记录帧,就会发现左下角会出现补间曲线。3 h9 B4 X% J  Q* h5 F6 _
  补间曲线的用处,就是自动补齐当前记录帧与上一个记录帧之间动作的变化顺序,曲线斜率越高,动作变化越快,具体教程可以参照贴吧中的教程,我们可以通过拖动红色的小x改变调节线,从而改变曲线9 J$ t+ V+ A% \6 D
每一组小红x的坐标,就可以唯一确定一条补间曲线,因此,上面的补间曲线存储的就是小红x的坐标
' R% Q. E5 M6 K$ m7 h(x_1, y_1, x_2, y_2)
& `* m0 W' o5 O,其中左下角调整线的小红x是看做点1,通过程序读取,我知道,小红x的坐标取值为[0~127]间的整数,因此用1字节完全可以存下,可能是当时的设计错误,用了32位整数存,高24位完全浪费了,完全可以不用读取,因此我们可以直接读取32位无符号整数或读取8位无符号整数,然后跳过24位。
, p- G0 o3 d' m2 k2 p  如果曲线只有一个,那么为什么会有四个补间曲线呢?实际上不止一个,补间曲线框的右上角就有个下拉菜单可以选择,对于圆形骨骼,没有相对位置变化,x, y, z补间曲线没有用,只有旋转速率可以调节,而方框骨骼可以移动,因此x, y, z, 旋转补间曲线都有用处。
1 Y7 s2 r/ B; Y. D' W5 D2 k
( A* P/ R0 l0 f* I  Q* r# X4 v% _0 Q
  回过头来,再说一下补间曲线的坐标,在这里,是以左下角为原点,横纵方向[0, 127]的坐标轴
5 d2 f. w: i9 P- j- d

, J- A  w( j% ]& t3 P3 t5 W! w

% e4 e4 N& J1 j7 X  后面的格式与这个格式大同小异。; }+ t2 c3 m7 I) Z# D
表情关键帧(MorphKeyFrame)
) Y% J, S# U! u8 |" Q# ~  ~" x- _) o2 `
  表情关键帧分为:表情关键帧数、表情关键帧记录:; D  ]4 ?3 d6 _! D
类型 长度 含义
uint32_t4
8 a  L& g! ]" p4 F5 w3 z( ]3 R# A
表情关键帧数量 MorphKeyFrameNumber
类型& `% y. |$ {8 S. f% {& b: j
长度0 U, m; a3 k4 e3 ]! X
含义0 ~5 d. r. m/ i% Q' d* r
byte0 F6 F# w- T, h4 P- Y
15$ S5 r: R& k: o4 ~" O' r8 @
表情名称 MorphName
. s7 |6 _# e8 w+ b8 y/ x
uint32_t
9 G& X! s: v( i4 V" P9 B3 V
40 m4 `% L! b/ z3 |+ z% N, j# ^3 ?
关键帧时间 FrameTime
: ~6 l  N  d1 g
float
8 H: t5 ^3 j& i  A' ^- _
4
! f( p$ v8 F* O! j$ x; C% j
程度 Weight! ~; s; f" h; I& o0 t
byte
! `! Z( v8 b4 D/ h- ^
230 T- S$ D. b) R/ _! p4 `
合计. k/ C0 h+ c& l2 z' o
  表情关键帧每个记录长度为23字节,其中程度(Weight)是取值为[0, 1]之间的浮点数,在MMD中的表现如下:
1 p) [! c3 c$ |( i/ w
镜头(CameraKeyFrame)
* M* C, M5 J* l; g8 a: v+ `" H% T6 f1 B. W' w' t% }! Y2 C5 Y
  镜头关键帧分为:镜头关键帧数、镜头关键帧记录:
: f* |) ^# Z  F8 p& K$ a
类型 长度 含义
uint32_t 4 镜头关键帧数量 CameraKeyFrameNumber
$ r" [5 x- V. ?4 i& j
类型 长度 含义
uint32_t 4 关键帧时间 FrameTime
float 4 距离 Distance
float*3 12 x,y,z空间坐标 Position.xyz
float*3 12 旋转角度(弧度制) Rotation.xyz
uint8_t*24 24 相机曲线 Curve
uint32_t 4 镜头FOV角度 ViewAngle
uint8_t 1 Orthographic相机
byte 61 合计
  距离是我们镜头与中心红点的距离,在MMD中,我们可以通过滑轮改变; j! g; L$ w6 h4 Q: ^& ]
- [# I: s5 X& Z4 m1 a& W
  这有什么用呢?可以看下面的图:
! |& I9 F9 ?/ w7 |! y# s0 B
当距离为0时,我们的镜头就在红点上,造成的效果是,当我们移动镜头的Y角度时,镜头就好像在我们眼睛上,视角是第一人称视角。可以看这里,是找镜头资料时偶然看到的。
' F- O# N4 K, h) a. W: c& Q% h# E% X  旋转角度不再是四元数,而是普通的弧度制角度,我猜大概是镜头的万向锁情况没那么严重,因此用弧度制就能表示。' Q+ Z; m) b7 L6 J5 N4 J% {
  Curve是曲线的意思,按照之前的的补间曲线,确实还有一个相机曲线,不过一个曲线=两个小红x=4个坐标点=四字节,因此24字节有20字节的冗余,它的前四个字节就已经表达了坐标,后面20个字节是将这4个字节重复了5次。' z$ N% [7 N! p+ |
  镜头FOV角度和透视值有关,上面的博客写的是float,但实际上我试验是uint32_t,取值刚好就是MMD中的透视值。
8 ?  f2 D0 w" x& |# ]' A
$ S8 K8 m5 n! N  L7 i" v
  Orthographic似乎是一种特殊的相机,没有近大远小的透视关系(不确定),不过在我的实验中,它一直取值为0。和上面的已透视没有关系,当取消已透视时,透视值会强制为1。3 {! t) n* A- H3 t
  下面的骨骼追踪似乎没有记录,可能是强制转换成骨骼所在的坐标了。* a$ s8 u  I4 `" D7 D! d: d
  后面的格式与这个格式大同小异。
5 S+ o& {1 }3 d+ G0 W  G1 @光线关键帧(LightKeyFrame)* U$ y* W. V8 T8 d& c1 B( c  k
) y3 w( c5 j' m
  表情关键帧分为:光线关键帧数、光线关键帧记录:
! k  v) b/ a- T, Y- [# j
类型 长度 含义
uint32_t 4 光线关键帧数量 LightKeyFrameNumber
类型 长度 含义
uint32_t 4 关键帧时间 FrameTime
float*3 12 RGB颜色空间 color.rgb
float*3
5 X% o! Y0 Q* u1 [  X' S
12 xyz投射方向 Direction.xyz
byte 28 合计
  
rgb颜色空间之[0, 1]之间的数,类似html的RGB(50%, 20%, 30%)这种表示方法,转换方式就是把RGB值分别除以256。
& G9 \) b, `! g5 d7 }  l) S# R  W  光线投射方向是[-1, 1]之间的小数。正所对的投射方向是坐标轴的负方向,例如将Y拉到1, 光线会从上向下投影。
- Y7 H* L# n, \二、代码读取! T) n. d/ R; ?9 e

, o- j$ D8 y9 N3 |" I' |" s  我依旧会使用面向对象的方式构建VMD类,不过构造方法无力,属性太多,我选择用静态方法添加属性的方式构建对象
8 e/ I- s0 F& Y. d$ L& A
  • class Vmd:
  •     def __init__(self):
  •         pass
  •     @staticmethod
  •     def from_file(filename, model_name_encode="shift-JIS"):
  •         with open(filename, "rb") as f:
  •             from functools import reduce
  •             array = bytes(reduce(lambda x, y: x+y, list(f)))
  •         vmd = Vmd()
  •         VersionInformation = array[:30].decode("ascii")
  •         if VersionInformation.startswith("Vocaloid Motion Data file"):
  •             vision = 1
  •         elif VersionInformation.startswith("Vocaloid Motion Data 0002"):
  •             vision = 2
  •         else:
  •             raise Exception("unknow vision")
  •         vmd.vision = vision
  •         vmd.model_name = array[30: 30+10*vision].split(bytes([0]))[0].decode(model_name_encode)
  •         vmd.bone_keyframe_number = int.from_bytes(array[30+10*vision: 30+10*vision+4], byteorder='little', signed=False)
  •         vmd.bone_keyframe_record = []
  •         vmd.morph_keyframe_record = []
  •         vmd.camera_keyframe_record = []
  •         vmd.light_keyframe_record = []
  •         current_index = 34+10 * vision
  •         import struct
  •         for i in range(vmd.bone_keyframe_number):
  •             vmd.bone_keyframe_record.append({
  •                 "BoneName": array[current_index: current_index+15].split(bytes([0]))[0].decode("shift-JIS"),
  •                 "FrameTime": struct.unpack("<I", array[current_index+15: current_index+19])[0],
  •                 "osition": {"x": struct.unpack("<f", array[current_index+19: current_index+23])[0],
  •                             "y": struct.unpack("<f", array[current_index+23: current_index+27])[0],
  •                             "z": struct.unpack("<f", array[current_index+27: current_index+31])[0]
  •                             },
  •                 "Rotation":{"x": struct.unpack("<f", array[current_index+31: current_index+35])[0],
  •                             "y": struct.unpack("<f", array[current_index+35: current_index+39])[0],
  •                             "z": struct.unpack("<f", array[current_index+39: current_index+43])[0],
  •                             "w": struct.unpack("<f", array[current_index+43: current_index+47])[0]
  •                             },
  •                 "Curve":{
  •                     "x"array[current_index+47], array[current_index+51], array[current_index+55], array[current_index+59]),
  •                     "y"array[current_index+63], array[current_index+67], array[current_index+71], array[current_index+75]),
  •                     "z"array[current_index+79], array[current_index+83], array[current_index+87], array[current_index+91]),
  •                     "r"array[current_index+95], array[current_index+99], array[current_index+103], array[current_index+107])
  •                 }
  •             })
  •             current_index += 111
  •         # vmd['MorphKeyFrameNumber'] = int.from_bytes(array[current_index: current_index+4], byteorder="little", signed=False)
  •         vmd.morph_keyframe_number = int.from_bytes(array[current_index: current_index+4], byteorder="little", signed=False)
  •         current_index += 4
  •         for i in range(vmd.morph_keyframe_number):
  •             vmd.morph_keyframe_record.append({
  •                 'MorphName': array[current_index: current_index+15].split(bytes([0]))[0].decode("shift-JIS"),
  •                 'FrameTime': struct.unpack("<I", array[current_index+15: current_index+19])[0],
  •                 'Weight': struct.unpack("<f", array[current_index+19: current_index+23])[0]
  •             })
  •             current_index += 23
  •         vmd.camera_keyframe_number = int.from_bytes(array[current_index: current_index+4], byteorder="little", signed=False)
  •         current_index += 4
  •         for i in range(vmd.camera_keyframe_number):
  •             vmd.camera_keyframe_record.append({
  •                 'FrameTime': struct.unpack("<I", array[current_index: current_index+4])[0],
  •                 'Distance': struct.unpack("<f", array[current_index+4: current_index+8])[0],
  •                 "osition": {"x": struct.unpack("<f", array[current_index+8: current_index+12])[0],
  •                             "y": struct.unpack("<f", array[current_index+12: current_index+16])[0],
  •                             "z": struct.unpack("<f", array[current_index+16: current_index+20])[0]
  •                             },
  •                 "Rotation":{"x": struct.unpack("<f", array[current_index+20: current_index+24])[0],
  •                             "y": struct.unpack("<f", array[current_index+24: current_index+28])[0],
  •                             "z": struct.unpack("<f", array[current_index+28: current_index+32])[0]
  •                             },
  •                 "Curve": tuple(b for b in array[current_index+32: current_index+36]),
  •                 "ViewAngle": struct.unpack("<I", array[current_index+56: current_index+60])[0],
  •                 "Orthographic": array[60]
  •             })
  •             current_index += 61
  •         vmd.light_keyframe_number = int.from_bytes(array[current_index: current_index+4], byteorder="little", signed=False)
  •         current_index += 4
  •         for i in range(vmd.light_keyframe_number):
  •             vmd.light_keyframe_record.append({
  •                 'FrameTime': struct.unpack("<I", array[current_index: current_index+4])[0],
  •                 'Color': {
  •                     'r': struct.unpack("<f", array[current_index+4: current_index+8])[0],
  •                     'g': struct.unpack("<f", array[current_index+8: current_index+12])[0],
  •                     'b': struct.unpack("<f", array[current_index+12: current_index+16])[0]
  •                 },
  •                 'Direction':{"x": struct.unpack("<f", array[current_index+16: current_index+20])[0],
  •                             "y": struct.unpack("<f", array[current_index+20: current_index+24])[0],
  •                             "z": struct.unpack("<f", array[current_index+24: current_index+28])[0]
  •                             }
  •             })
  •             current_index += 28
  •         vmd_dict = {}
  •         vmd_dict['Vision'] = vision
  •         vmd_dict['ModelName'] = vmd.model_name
  •         vmd_dict['BoneKeyFrameNumber'] = vmd.bone_keyframe_number
  •         vmd_dict['BoneKeyFrameRecord'] = vmd.bone_keyframe_record
  •         vmd_dict['MorphKeyFrameNumber'] = vmd.morph_keyframe_number
  •         vmd_dict['MorphKeyFrameRecord'] = vmd.morph_keyframe_record
  •         vmd_dict['CameraKeyFrameNumber'] = vmd.camera_keyframe_number
  •         vmd_dict['CameraKeyFrameRecord'] = vmd.camera_keyframe_record
  •         vmd_dict['LightKeyFrameNumber'] = vmd.light_keyframe_number
  •         vmd_dict['LightKeyFrameRecord'] = vmd.light_keyframe_record
  •         vmd.dict = vmd_dict
  •         return vmd4 J! c, M8 E3 W
) U  \0 V( k5 d  |0 p1 B5 c4 n
复制代码; H+ A1 H( s% I5 v6 W: F8 R4 f

. c. Z, v, l$ D/ b. t
8 X' l' |3 A* p) M* I! M2 ~7 L. o% ]三、实验) T, ]$ K' _& T9 G2 Q( t0 m3 I

" H3 b4 e* L9 J- b; {, p  随意掰弯一些关节并注册、使用:
/ L# J" `8 a1 x, L- j
  • if __name__ == '__main__':
  •     vmd = Vmd.from_file("test.vmd", model_name_encode="gb2312")
  •     from pprint import pprint
  •     pprint(vmd.dict)
  •   c2 ]9 I3 ]" G- C, @! r$ G6 ?. x

/ Z/ |$ j5 |! n6 U/ I6 }复制代码, P3 k& x, p7 r! I5 C) W' @7 O
output:
/ z8 g. W2 q# h
  • {'BoneKeyFrameNumber': 4,
  • 'BoneKeyFrameRecord': [{'BoneName': '右腕',
  •                          'Curve': {'r': (20, 20, 107, 107),
  •                                    'x': (20, 20, 107, 107),
  •                                    'y': (20, 20, 107, 107),
  •                                    'z': (20, 20, 107, 107)},
  •                          'FrameTime': 0,
  •                          'Position': {'x': 0.0, 'y': 0.0, 'z': 0.0},
  •                          'Rotation': {'w': 0.9358965158462524,
  •                                       'x': 0.0,
  •                                       'y': -0.3522740602493286,
  •                                       'z': 0.0}},
  •                         {'BoneName': '首',
  •                          'Curve': {'r': (127, 127, 127, 127),
  •                                    'x': (0, 127, 0, 127),
  •                                    'y': (0, 0, 0, 0),
  •                                    'z': (127, 0, 127, 0)},
  •                          'FrameTime': 60,
  •                          'Position': {'x': 0.0, 'y': 0.0, 'z': 0.0},
  •                          'Rotation': {'w': 0.9191020727157593,
  •                                       'x': 0.0,
  •                                       'y': -0.3940184712409973,
  •                                       'z': 0.0}},
  •                         {'BoneName': '右ひじ',
  •                          'Curve': {'r': (127, 127, 127, 127),
  •                                    'x': (0, 127, 0, 127),
  •                                    'y': (0, 0, 0, 0),
  •                                    'z': (127, 0, 127, 0)},
  •                          'FrameTime': 60,
  •                          'Position': {'x': 0.0, 'y': 0.0, 'z': 0.0},
  •                          'Rotation': {'w': 0.9568025469779968,
  •                                       'x': 0.0,
  •                                       'y': -0.290740042924881,
  •                                       'z': 0.0}},
  •                         {'BoneName': '右腕',
  •                          'Curve': {'r': (20, 20, 107, 107),
  •                                    'x': (20, 20, 107, 107),
  •                                    'y': (20, 20, 107, 107),
  •                                    'z': (20, 20, 107, 107)},
  •                          'FrameTime': 60,
  •                          'Position': {'x': 0.0, 'y': 0.0, 'z': 0.0},
  •                          'Rotation': {'w': 0.593818187713623,
  •                                       'x': 0.0,
  •                                       'y': -0.8045986294746399,
  •                                       'z': 0.0}}],
  • 'CameraKeyFrameNumber': 0,
  • 'CameraKeyFrameRecord': [],
  • 'LightKeyFrameNumber': 0,
  • 'LightKeyFrameRecord': [],
  • 'ModelName': '八重樱',
  • 'MorphKeyFrameNumber': 2,
  • 'MorphKeyFrameRecord': [{'FrameTime': 60, 'MorphName': 'まばたき', 'Weight': 1.0},
  •                          {'FrameTime': 60,
  •                           'MorphName': 'あ',
  •                           'Weight': 0.36000001430511475}],
  • 'Vision': 2}
    7 I) V  B0 n! C/ N9 q

" P% w3 {/ ~/ f. w" `复制代码: b4 X- Q$ L+ T) v& [" T7 g+ o, O
因为前面提到的编码模式,我选择用gb2312解码,在很多(也许是大部分)动作数据都会报错,可以去掉编码方式:
; T. W  w# C, a" v
  • vmd = Vmd.from_file("test.vmd")) j( C' S6 r+ B7 j8 w1 b

, G; j1 H% T# h- [0 u复制代码/ L, h6 j) @4 \3 X5 ^
我们没有移动方块骨骼,因此位置信息都是0。
' c$ l* y3 M$ G  M/ p* N  不喜欢看欧拉角的话,可以写一个转换方法:
8 s; k6 A% v8 ^4 n5 F
  •     @staticmethod
  •     def _quaternion_to_EulerAngles(x, y, z, w):
  •         import numpy as np
  •         X = np.arcsin(2*w*x-2*y*z) / np.pi * 180
  •         Y = -np.arctan2(2*w*y+2*x*z, 1-2*x**2-2*y**2) / np.pi * 180
  •         Z = -np.arctan2(2*w*z+2*x*y, 1-2*x**2-2*z**2) / np.pi * 180
  •         return X, Y, Z
  •     @property
  •     def euler_dict(self):
  •         from copy import deepcopy
  •         res_dict = deepcopy(self.dict)
  •         for index, d in enumerate(res_dict['BoneKeyFrameRecord']):
  •             x = d["Rotation"]["x"]
  •             y = d["Rotation"]["y"]
  •             z = d["Rotation"]["z"]
  •             w = d["Rotation"]["w"]
  •             X, Y, Z = Vmd._quaternion_to_EulerAngles(x, y, z, w)
  •             res_dict['BoneKeyFrameRecord'][index]["Rotation"] = {
  •                 "X": X,
  •                 "Y": Y,
  •                 "Z": Z
  •             }
  •         return res_dict
    " z& G/ C) B( ]% x: q1 j5 x2 k

8 h8 a) p8 k/ V3 C& s复制代码
" B1 d( }8 x" g* G1 \6 A 这样只要调用:- p: O9 Z: q) e" P0 L' @$ M  [: Z$ h% i
  • vmd = Vmd.from_file("test.vmd")
  • from pprint import pprint
  • pprint(vmd.euler_dict); ^& M$ Q* H4 n8 b% l5 g

  k  H/ J3 F% x! m+ F! t! H复制代码! l% V& h$ L* |' r
即可得到转换成欧拉角的结果,同样的方式还可以编写转换RGB、弧度、角度等) e' K/ j: `7 g! H0 A" R
  python内置的json包可以很方便得将字典转换成json格式文档储存。$ l  x. P* d8 C* M$ F4 N" @
  我们也可以试着写一些将VMD转换成vmd文件的方法。
+ C6 ~# y$ x( a: L, V四、总结- i; K' f. D6 U2 u2 D& I* o

. j$ d9 H/ Q8 t3 @4 d  通过学习VMD的文件结构,大致了解了储存动作数据的格式和一些方法,或许可以类比到一些主流的商业3D软件上。
1 b5 P) ?" U( n; U# X  读取程序并不难,我写程序的很多时间都是查二进制操作消耗的,通过这个程序,还巩固了二进制操作的知识。
8 m" k# K0 h7 k  M; o: p0 w1 G7 D% d( I8 a- A3 e

) q! j$ U; q  }1 S" `, x/ F' {
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

Archiver|手机版|小黑屋|

GMT+8, 2026-3-22 04:04 AM , Processed in 0.089012 second(s), 23 queries .

Powered by xyh-moon X3.5

© 2001-2025 Discuz! Team.

快速回复 返回顶部 返回列表