找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 158|回复: 0

【MMD】解析VMD格式读取

[复制链接]

983

主题

83

回帖

5万

积分

管理员

积分
53122
发表于 2022-6-30 08:28:08 | 显示全部楼层 |阅读模式
前言
: C* o, ^. g/ h, [8 o- f/ X) w3 b* Z4 z7 ?0 s' r
  MikuMikuDance(简称MMD)是一款动画软件,早期视为Vocaload角色制作动画的软件,现在还经常能在B站等视频网站,或一些动画网站(某I站)看到MMD作品。  Y: \, _4 y( Q* P$ F0 R8 E
  我在高中也简单学过操作这款软件以及PE、水杉等软件,学会了简单k帧、套动作、调渲染、加后期、压缩等技术,这与我学习计算机专业有很大的关系(虽然学校学的和这个八竿子打不着,或许我应该学美术去),现在已经分不清很多东西了,封面静画就是杂七杂八过气MME一锅扔的成果,得益于G渲的强大,还能看出一点效果。
+ ]: ]7 b- O3 ^  现在我想学一些3D的开发,包括用程序读取模型、动作等,很快我就想到之前用过的MMD。; c' g# t( a* i% o' j7 K( ^
  一些3D姿势估计(3D pose estimate)或许能得到骨骼位置以及PAF(骨骼间关系),但我需要知道3D动画是如何储存动作数据的,才能想到怎样将姿势估计得到的数据转化为动作数据。, @' p/ ?1 v$ S! k
  因此我找了一些资料解析MMD的动作数据VMD(Vocaload Mation Data)文件,并写下这篇记录。
0 a- b. A2 M7 ^" e9 C; f/ g) k
; J- o. M. X7 d# T1 S* p1 w& n  根据MMD的规矩,上借物表:
3 b' B5 r) B7 ^5 M* V! y- w) ]
名称 来源
MikuMikuDanceE_v803 圝龙龍龖龘圝
八重樱 神帝宇

; r# d" A5 g% M: S! x: H$ Y% d# l4 d: M, M1 Y
封面静画:
: i9 z) Y% r/ Y" Z0 p6 \, z
名称 类别\来源
LightBloom 背光
AutoLuminousBasic 自发光特效
HgSAO 阴影
SoftLightSB 柔化
SvSSAO 阴影
XDOF 景深
dGreenerShader G渲
Tokyo Stage 场景
$ E- y2 Y9 E+ m
一、格式说明, U9 R! h" Y4 N/ l9 V4 T

2 Q4 ]) H9 H8 V, B7 F0 ~. w  首先,vmd文件本身是一个二进制文件,里面装着类型不同的数据:uint8、uint32_t、float,甚至还有不同编码的字符串,因此我们需要二进制流读入这个文件。
9 B8 G8 z; }* g" C  vmd格式很像计算机网络的协议格式,某某位是什么含义,区别是,vmd文件的长度理论上是无限的,让我们来看看。
5 o4 U/ G; v' d( Y2 h0 M2 ]  vmd的大致格式如下:" r: s! l. _! T- x! x- f- B  U/ [. x

; ~& b* J2 U7 R* y    头部3 x  d) ?. b5 ?2 c
    关键帧数量& o4 ]# Y( d1 a0 [1 I
    关键帧
" y2 b! i4 Z* r" U3 Z0 [( h0 h* r+ B+ i- M$ U; A, F* h
头部
: j& a& }. Z  K4 r7 Z& l; \7 ?( g- K: F9 X* v* s2 ~
  最开始的就是头部(header),看到这就有十分强烈的既视感:$ ^2 h, C7 s7 C, w. e
类型 + G- y* m8 ?, y& z1 i+ E( u
长度 含义
byte 30 版本信息
byte 10 or 20 模型名称

# e& W4 S3 ?$ w' X9 ^
+ S& d& R- T1 H$ H5 ]8 @* b  其中,版本信息(VersionInformation)长度为30,是ascii编码的字符串,翻译过来有两种,一为“Vocaloid Motion Data file”,二为“Vocaloid Motion Data 0002”,长度不足30后用\0(或者说b'\x00')填充。这是由于vmd版本有两种,大概是为了解决模型名称长度不足,因此后续只影响模型名称的占用长度。. l; k; ]: ^9 d3 ^
  模型名称(ModelName),是动作数据保存时用的模型的模型名,通过这个我们可以获取到那个名称,我们知道,一个动作数据想要运作起来,只要套用模型的骨骼名称是标准的模板就可以,因此我想象不出这个名称有何用处,或许某些模型带有特殊骨骼,例如翅膀之类的,这样能方便回溯?模型名称的长度根据版本而决定,version1为10,version长度为20。编码原文写的是shift-JIS,是日语编码,这样想没错,然而我试验后发现并非如此,例如经常改模型的大神神帝宇的模型,他的模型名称用shift-JIS为乱码,用gb2312竟然能正常读出来;还有机动牛肉大神的模型,他的模型名称用gb2312无法解码,用shift-JIS解码竟然是正常的简体中文???怎么做到的?8 t" G" l3 y7 F! J
骨骼关键帧(BoneKeyFrame)
, r3 j1 k8 _  K4 X) ?, c- x- i" c7 a8 T; }% G) S
  骨骼关键帧,分为两部分:骨骼关键帧数、骨骼关键帧记录:
! @' a) \- X: L9 n- M: C3 B3 ~. R
类型 长度 含义
uint32_t4
- w. P% O" R( }" k& Q7 |
骨骼关键帧数量 BoneKeyFrameNumber

/ {! f$ S, G) U
类型 长度 含义
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 & [) a1 C% p: m5 h# Y5 m
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 合计

4 \% c6 J7 Y* M! W
4 |' q  {1 C$ I7 K8 H( w* ~7 c  为何要分开写呢?因为骨骼关键帧数量只需要一个就够了,而后面骨骼关键帧记录的数量会和前面的骨骼关键帧数量保持一致。3 r/ b' h5 t6 a5 m7 n' [: f/ v) `

. R0 _! M; ]% o) }# k  我们可以查一下,每个骨骼关键帧的数量为111字节。) `2 N5 ]; H7 Z2 k) A5 h
旋转坐标
: z* f7 @  z" l9 g
# v( b& c) b- H% u% Z7 C  一开始还没发现,旋转坐标竟然有四个,分别为x, y, z, w,急的我去MMD里查看一下,发现和我印象中没有什么差别
6 k. \" u! r2 n4 w3 _
都是[-180, 180]的角度值,我用程序跑的时候,这四个值完全看不懂;幸好在英文网站上找到这个表示方法:四元数。四元数是用四个值表示旋转的方法
9 q  _+ J% F5 ^. nw+i·x+j·y+k·z2 s' d( [! Q& M8 u8 _
,其中) k0 Y8 n& G+ J9 [
i、j、k* q0 K2 e! S: O* s
都是虚数,我上网找了一堆资料,并且得到了四元数转化欧拉角的公式
5 Y6 h& {! u  `* _) V' a1 e0 w\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)} \\
* A. [; M# I6 o$ G1 d% p! M得到的是角度制,我们通过角度制转弧度制的公式即可算出和MMD中等同的角度表示。
7 X) c& Z/ S7 N, `1 D+ D8 `
0 I! \( l0 B5 V* N补间曲线
  p9 A, L9 S* i& z  V6 d0 \5 l, |; t
  为何补间曲线的类型不确定呢?上面csdn博客的教程说“uint8_t那里有冗余,每四个只读第一个就行”。说的没有问题,首先我们要清楚这个补间曲线坐标的含义。
' X8 b- ]+ U$ D) z$ g  我们打开MMD,读入模型,随意改变一个骨骼点,记录帧,就会发现左下角会出现补间曲线。+ \2 h, X/ t3 l) x
  补间曲线的用处,就是自动补齐当前记录帧与上一个记录帧之间动作的变化顺序,曲线斜率越高,动作变化越快,具体教程可以参照贴吧中的教程,我们可以通过拖动红色的小x改变调节线,从而改变曲线
. b1 R  X1 Z* p1 E
每一组小红x的坐标,就可以唯一确定一条补间曲线,因此,上面的补间曲线存储的就是小红x的坐标
) ~. k' F3 ~  v8 M2 O6 p(x_1, y_1, x_2, y_2)4 ~1 z# E# {# l6 ]2 y
,其中左下角调整线的小红x是看做点1,通过程序读取,我知道,小红x的坐标取值为[0~127]间的整数,因此用1字节完全可以存下,可能是当时的设计错误,用了32位整数存,高24位完全浪费了,完全可以不用读取,因此我们可以直接读取32位无符号整数或读取8位无符号整数,然后跳过24位。
. u2 v, t( N9 C) b  如果曲线只有一个,那么为什么会有四个补间曲线呢?实际上不止一个,补间曲线框的右上角就有个下拉菜单可以选择,对于圆形骨骼,没有相对位置变化,x, y, z补间曲线没有用,只有旋转速率可以调节,而方框骨骼可以移动,因此x, y, z, 旋转补间曲线都有用处。
7 L/ L# M; m- C0 Z( P
/ f3 K9 G( A. ?$ N% m
  回过头来,再说一下补间曲线的坐标,在这里,是以左下角为原点,横纵方向[0, 127]的坐标轴
, F" f7 H# p! a9 E0 D: O* N
6 X3 x% L0 d8 [

: q; n+ ?" u5 D  后面的格式与这个格式大同小异。
3 M* u; h5 A! R表情关键帧(MorphKeyFrame)
$ e- r# I: p2 O+ ^- B! V8 m
& Y! R2 L4 l+ \( E  表情关键帧分为:表情关键帧数、表情关键帧记录:
& b5 i- I& h# i9 w8 M
类型 长度 含义
uint32_t4 " ?% D. n) F3 \7 E, L+ O: N& i
表情关键帧数量 MorphKeyFrameNumber
类型
+ q3 n# ~" @' w, t, Y: e; o  R
长度
$ e7 w4 `) @8 S) Y
含义
. T0 u. k: G: k; t2 u1 U/ \
byte
+ y+ v! }6 j  @$ P7 [
15
; Y" a/ X, w+ V: m( n9 K' ~
表情名称 MorphName- N. N) J* L+ h/ m1 Y6 E4 X
uint32_t
. W7 G% ~% b! K3 t
4
8 P; C( V( M7 r
关键帧时间 FrameTime  Y# ^- ~; ^- S4 d& @* X
float
( U5 u- k& u# S  F0 T0 Q
4
/ y3 S) q  T0 w% i* @5 W
程度 Weight
: F: r$ J% w- M6 c* \' @
byte. t! k8 C# P. s6 t+ O
23
) {- N# _. F( _- }& w! d
合计
% w* ~9 W7 ]( Y! E
  表情关键帧每个记录长度为23字节,其中程度(Weight)是取值为[0, 1]之间的浮点数,在MMD中的表现如下:
% v  r$ c' B1 o. s; \$ D* j' j0 @
镜头(CameraKeyFrame)
( K+ m7 k( E! }0 A9 U8 ?
. ~4 I4 ]9 F0 r2 a  镜头关键帧分为:镜头关键帧数、镜头关键帧记录:' K' X- y4 C- g1 `4 x
类型 长度 含义
uint32_t 4 镜头关键帧数量 CameraKeyFrameNumber
: Z4 C. W+ H6 u; 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中,我们可以通过滑轮改变+ a. y% t' }# |- C( q6 `

1 Q$ G8 A* r9 P! }! C6 o
  这有什么用呢?可以看下面的图:
  o/ |: Q4 R0 Z" L6 x
当距离为0时,我们的镜头就在红点上,造成的效果是,当我们移动镜头的Y角度时,镜头就好像在我们眼睛上,视角是第一人称视角。可以看这里,是找镜头资料时偶然看到的。
8 C; Z6 _. @2 R' Q  B5 L  旋转角度不再是四元数,而是普通的弧度制角度,我猜大概是镜头的万向锁情况没那么严重,因此用弧度制就能表示。
9 |" n) X- o: Y  Curve是曲线的意思,按照之前的的补间曲线,确实还有一个相机曲线,不过一个曲线=两个小红x=4个坐标点=四字节,因此24字节有20字节的冗余,它的前四个字节就已经表达了坐标,后面20个字节是将这4个字节重复了5次。* `- i4 t$ c1 a! ~
  镜头FOV角度和透视值有关,上面的博客写的是float,但实际上我试验是uint32_t,取值刚好就是MMD中的透视值。
# d' w! z$ c! ~6 b$ w6 F

' L$ \, V- D# _9 y; @3 E2 J3 Y
  Orthographic似乎是一种特殊的相机,没有近大远小的透视关系(不确定),不过在我的实验中,它一直取值为0。和上面的已透视没有关系,当取消已透视时,透视值会强制为1。5 ]$ a8 F' t/ A+ ~
  下面的骨骼追踪似乎没有记录,可能是强制转换成骨骼所在的坐标了。
% q! z' ^. ^/ _( K  后面的格式与这个格式大同小异。
/ Q& z( v1 q& }2 b/ w光线关键帧(LightKeyFrame). m- \' i/ n: ?
: y: y7 {1 T. D
  表情关键帧分为:光线关键帧数、光线关键帧记录:
  x9 J1 i! z( F: E' o
类型 长度 含义
uint32_t 4 光线关键帧数量 LightKeyFrameNumber
类型 长度 含义
uint32_t 4 关键帧时间 FrameTime
float*3 12 RGB颜色空间 color.rgb
float*3
; G) l; ~# |: \3 u7 Z4 }8 i
12 xyz投射方向 Direction.xyz
byte 28 合计
  
rgb颜色空间之[0, 1]之间的数,类似html的RGB(50%, 20%, 30%)这种表示方法,转换方式就是把RGB值分别除以256。
5 y: y; q' {  v) g4 v  T  光线投射方向是[-1, 1]之间的小数。正所对的投射方向是坐标轴的负方向,例如将Y拉到1, 光线会从上向下投影。
0 o2 m3 b( h$ J5 U6 ~二、代码读取
- p' L  {! D% S! }% s( N- Q' u# r+ K( X" P2 A8 K6 l. h7 R
  我依旧会使用面向对象的方式构建VMD类,不过构造方法无力,属性太多,我选择用静态方法添加属性的方式构建对象
& H9 H  m% s, L1 ?1 P# Q# N: e
  • 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 vmd
    % m! \9 p3 _' j/ G% z

" T( I- M4 {' }! u' l% W复制代码
- d' S/ W7 B: Y  }7 b, {
. ]9 v$ D/ l! _( E
: K1 b/ T+ H9 T' T* s1 G# O# U三、实验
, B9 |# V* ~: J3 j" ^* r: ~# p9 C3 n0 l% [- p
  随意掰弯一些关节并注册、使用:
7 ^. T/ G# T1 \- L4 q0 W, o7 R3 s! `
  • if __name__ == '__main__':
  •     vmd = Vmd.from_file("test.vmd", model_name_encode="gb2312")
  •     from pprint import pprint
  •     pprint(vmd.dict)

  • % j2 p/ A3 a6 D6 V4 M' X# k) ^" n
' j% O! N1 C8 K2 ^( [  Z
复制代码
/ u: N1 @: E0 n! D+ j  A4 Houtput:; E" w! U8 @! D' w# M5 \' f4 x
  • {'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}9 ^, g' j. g- s

/ v$ n/ V1 }" _- e! q1 g/ T. I复制代码
- Z, W$ C; I7 V* a! F7 w 因为前面提到的编码模式,我选择用gb2312解码,在很多(也许是大部分)动作数据都会报错,可以去掉编码方式:
0 o% Z+ C0 Y' l) t7 I
  • vmd = Vmd.from_file("test.vmd")
    & j9 G9 l$ ?. S  D1 }
, G2 y6 W/ B8 X5 }, }
复制代码- i6 ?* ~0 ~; H! @4 ]: U6 V; {
我们没有移动方块骨骼,因此位置信息都是0。7 G4 H3 m( z. D( e# I
  不喜欢看欧拉角的话,可以写一个转换方法:( x- Y; g3 Y9 y7 R: Z' [3 F; z2 I
  •     @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, t# b& j/ c7 Z4 ^2 y
0 M0 J+ o& @; Z! V
复制代码
) U$ n- t/ k, _) P; Y0 K 这样只要调用:
: T8 _+ |0 A7 c
  • vmd = Vmd.from_file("test.vmd")
  • from pprint import pprint
  • pprint(vmd.euler_dict)
    + X2 `, m  s! K2 D7 }
9 T& P  g# P  ?
复制代码
) i9 u; x% H/ k& N; u即可得到转换成欧拉角的结果,同样的方式还可以编写转换RGB、弧度、角度等; U& `, ~$ o0 P
  python内置的json包可以很方便得将字典转换成json格式文档储存。
  _" R" |! i+ {( D( c! K' s% v) i  我们也可以试着写一些将VMD转换成vmd文件的方法。1 u% m3 d0 I% \( h
四、总结+ @) w% u4 H) ]8 M. w3 k

% h, E& v  E% y; b  通过学习VMD的文件结构,大致了解了储存动作数据的格式和一些方法,或许可以类比到一些主流的商业3D软件上。
- y# K) I4 I- ~2 o9 R% ?5 M  读取程序并不难,我写程序的很多时间都是查二进制操作消耗的,通过这个程序,还巩固了二进制操作的知识。: T- j. f: p/ p1 a. M
$ G; k2 X  ?8 W7 r
$ W8 G" z5 G0 ~( {0 R/ Y$ z9 A% j+ G" K
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

Archiver|手机版|小黑屋|返回首页

GMT+8, 2024-12-23 23:54 , Processed in 0.093424 second(s), 25 queries .

Powered by Discuz! X3.5

© 2001-2024 Discuz! Team.

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