一、前言

  PMX是Polygon Model eXtended的简写，是动画软件MikuMikuDance中的模型文件，是.PMD格式（Polygon Model Data）的继承者。
  上次解析的是MMD中的动作文件VMD，相比于VMD，模型文件需要了解的东西更多，为此我还简单学了下建模工具Blender。
  同样的，这次也有参考的网站。

国外Github上，看样子是老外翻译日文到英语的文档
https://gist.github.com/felixjones/f8a06bd48f9da9a4539f
日文Wiki
https://www6.atwiki.jp/vpvpwiki/pages/284.html
参考PmxEditor说明
【PE教学】超超超初心者向PE入门Part1 - 基本原理
古剑二MMD&绑骨教程
mmd教程/pe教程-oeasy
VPVP:https://www6.atwiki.jp/vpvpwiki/pages/118.html

借物表：

使用工具

  相较之前用MMD演示动作数据构成，PMX文件的构成用PmxEditor研究更好，Pmx编辑窗口很好的把文件结构展示出来。

二、PMX文件解析

1.类型说明

  相对于上次VMD的解析，PMX的类型更为复杂，用简单的C数据类型解释很麻烦，因此向国外的文档学习，将其中某些元素定义为一些类型。可以先大致看一眼。

（1）C类型

  C语言风格基础类型，复杂类型也是由许多基础类型定义。

类型名称	C类型	标准类型	大小（字节）	范围
byte	char	uint8_t	1
ubyte	unsigned char	uint8_t	1
short	short	int16_t	2
ushort	unsigned short	uint16_t	2
int	int	int32_t	4
uint	unsigned int	uint32_t	4
float	float	float	4	IEEE754标准定义float范围

（2）PMX类型

  PMX格式所定义类型，不过这些类型在大多数图形库中都有定义

（3）索引类型

  有时候我们需要记住元素的索引，例如某个面是由哪几个点组成的，而表示一个点，就需要索引。
  索引的大小不是确定的，有些元素需要很多索引，因此索引类型也很大；而有些元素很少，索引节点的大小很小。
  同样的元素，例如顶点，有时一个模型只有几个顶点，有的有几万个顶点，因此同样是节点的索引，大小也可能不一样。PMX将索引类型分为3种：Type1、Type2、Type4，分别占有1、2、4个字节，模型的索引的大小储存在Globas全局定义中，后面会提到。

2.文件总体结构概览

  和VMD文件类似，都是全局信息-[元素总数-元素信息]。

  软体应该是作为Pmx独有的，很明显的，PmdEditor没有软体按钮。
  下面是真正开始解析文件每一部分格式。

3.头部、全局信息

Header

  模型头部，描述模型的基本信息

全局信息

用于描述索引类型的类型，就是上面索引类型的[1, 2, 4]

4.顶点

  首先我们打开PmxEditor并读入一个模型，然后进入编辑器的顶点页面。因为顶点有复杂的数据，这次同样先说明一些其他的东西。如果感觉迷惑了不要紧，对照着顶点页面研究就能很好的明白各处的含义。

额外的vec4

  方才在全局定义中，有一个额外的vec4选项，定义为每个顶点多出几个vec4，每个顶点可以最多获得4个额外的vec4值，文件文身也不知道这是什么含义，多数情况会直接传递给vertex shader决定使用情况。例如，vec4用于以下方面：

• 额外的纹理UV
• 高光贴图UV
  详细参考这个教程
    右侧的贴图就是左侧的高光贴图，因为黑色部分的RGB值为0，不会参与高光的计算（参与了但值为0），而金属边框会参与计算，做出的结果是：木头部分不会反射高光，而金属部分会出现高光
• 法线贴图UV
    通过改变法向量，使得平面图计算出阴暗交替的感觉。
• 顶点颜色（PMX2.1拓展）

  忽略这些额外的vec4是最安全的，但同时也会导致很多东西无法显示。

这里就是追加UV选项的地方

顶点绑骨

  顶点要随着骨骼运动、变形，每个骨骼对顶点有相应的权重，在MMD中，一个顶点最多和4个骨骼相关联；随着绑定骨骼数量的不同，顶点绑骨的类型也不同。以下是绑骨类型：

无绑骨

  骨骼索引-1是零值，骨骼应该被忽略。

BDEF 1（Bone Deform）（2.0）

注意：索引类型（index）对每个元素不同，骨骼索引的定义看上面的索引类型说明。

BDEF 2（2.0）

BDEF 4（2.0）

类型	名称	说明
索引-骨骼	骨骼1
索引-骨骼	骨骼2
索引-骨骼	骨骼3
索引-骨骼	骨骼4
foat	骨骼1权重
foat	骨骼2权重
foat	骨骼3权重
foat	骨骼4权重	不保证=1

SDEF（2.0）

  一种SBS（Spherical Blend Skinning）球面混合蒙皮方式，能使皮肤的扭动更自然。

类型	名称	说明
索引-骨骼	骨骼1
索引-骨骼	骨骼2
foat	骨骼1权重	骨骼2权重 = 1-骨骼1权重
vec3
vec3
vec3

QDEF（2.1）

  双四元数变型混合

类型	名称	说明
索引-骨骼	骨骼1
索引-骨骼	骨骼2
索引-骨骼	骨骼3
索引-骨骼	骨骼4
foat	骨骼1权重
foat	骨骼2权重
foat	骨骼3权重
foat	骨骼4权重	不保证=1

顶点数据

  顶点部分以一个int开始，定义了有多少个顶点（注意它是一个带符号的int），后面跟着每个顶点的定义
每个顶点的格式如下：

5.面

  面以三个顶点为一组，定义单个三角形面；三角形面向按顺时针缠绕顺序定义，顺时针为正面，逆时针为背面（与DirectX一样）。
  同样别忘了先读取一个int来确定有多少个面，不过要注意，面的定义是按照索引数量定义的，因此要将这个数字整除3。

附加面类型（PMX2.1）

  材质数据在2.1版本有扩充，能包含点和线的绘制，详细需要查阅资料。

6.纹理

  此处是纹理路径表，路径本身是字符串，它的格式和操作系统相关，可能是绝对路径也可能是相对路径。
  某些实现程序会基于文件名修改纹理，例如使用"_s"作为球体贴图或使用"_n"作为法线贴图。
  纹理贴图没有首选格式，最常见个纹理格式可能是bmp、png、tga，有时候也可能是jpg或dds格式。

保留的纹理名称

纹理名称toon01.bmp"到"toon10.bmp"是保留的，模型不应该通过纹理数据引用这些纹理。如果不巧使用了，会发生什么取决于实现程序，某些实现将忽略这些，某些实现会使用内部的纹理。
  同样，纹理数据以一个int开头，定义总共有多少纹理。

  PmxEditor编辑没有独立的纹理页面，但在材质页面能看到材质引用的纹理。

7.材质

  PMX用基于材质的渲染，而不是基于物理的渲染，
鉴于后面的材质数据会使用标志位，先放出材质的标志类型定义（1byte=8flag）：

点线绘图（PMX2.1）

  如果绘点和绘线标志同时存在，绘点标志将覆盖绘线标志。

• 普通面通过顶点 [A -> B -> C]渲染
• 通过点绘制，每个顶点被渲染为单独的点[A，B，C]，从而产生3个点。
• 线条图将呈现3条线[A-> B，B-> C，C-> A]，产生3条线。

  启用点渲染时，材质（不是顶点）的边尺度值将控制点的大小。
  如果设置了边缘标志，则点或线将具有边缘，这是未定义的行为。

材质数据

  与之前相同，材质也有一个int记录材质的数量，材质的数据结构定义如下：

注1：环境混合模式3将使用第一个额外的vec4来映射环境纹理，仅使用X和Y值作为纹理UV。它被映射为附加纹理图层。这可能与第一个额外vec4的其他用途冲突。
注2：Toon值将是一个非常类似于标准纹理和环境纹理索引的纹理索引，除非Toon引用字节等于1，在这种情况下，Toon值将是一个引用一组10个内部toon纹理的字节（大多数实现将使用“toon01.bmp”到“toon10.bmp”作为内部纹理，请参阅上面纹理的保留名称。
注3：表面计数总是3的倍数。它基于先前材质的偏移量与当前材质的尺寸。如果将所有材质的所有表面计数相加，则应最终得到表面总数。
人话3：图上的“脸红”为第一个材质，有81个面，[0, 81)面都属于本材质，而“首”由38个面组成，索引[81, 81+38]都属于“首”材质，以此类推，这样将材质、纹理、面组成的网格，组成面的顶点都结合起来了。

8.骨骼

  用于骨骼动画。

骨骼标志

骨骼继承

  假如上图的付予栏位中的旋转、移动有一个被选中，这个类型有效

骨骼固定轴

骨骼Local坐标

  PmxEditor最下面的local轴选项，这个见于左腕、右腕（左右胳膊）、以及往下延伸的子骨骼中，其他用法可以看看这个。
  MMD左下角有操作手柄：

Global,Local无效,Local有效

外亲骨

  MMD即时绑定两个模型，为什么会出现在模型文件中，真是个迷。

IK 角度限制

IK链

~是参考其他类型，也可能没有的意思。

IK骨

  这里IK骨的数据看起来很迷

骨骼数据

  骨骼数据以有符号int开头，定义了有多少个骨骼

9.变形

  变形就是我们常说的表情

变型类型

  标识变形的类型，长度只有1byte。
  对于使用者，常认为变型有三种或五种等等，从文件存储来说似乎不止这些：

偏移与偏移值

  变形对每一个持有的作用元素(顶点、骨骼、UV这些)称为偏移（Offset），我感觉不是十分准确，不过PmxEditor都是这么翻译的，那就入乡随俗了。
  针对不同的作用元素，会拥有不用的偏移值（偏移量）：

组合（Group）

顶点（Vertex）

骨骼（Bone）

UV（及拓展UV）

材质（Material）

不是很清楚环境色调（Environment tint）的意义，毕竟前面材质中光照贴图都给翻译成环境贴图了。

切换（Flip）

  和分组很像，这里大致有应用。

脉冲（Impulse）

变形数据

  依旧先以一个有符号的int开始

10.表示枠

  一开始看着英文还很蒙（Display Frame），寻思展示帧是什么。表示枠其实就是在MMD中，模型可以注册的物件的分组（只有骨骼和变形，相机、
光照不属于模型），在MMD左侧栏，那些可以展开的就是表示枠：

帧类型

骨骼帧数据

变形帧数据

帧数据

表示枠数据

  以一个有符号int开始作为表示枠个数

11.刚体

刚体形状类型

物理模式

刚体数据

  刚体部分以一个int开始，用于定义有多少刚体

  形状大小固定vec3不变，不过不同的刚体形状，对应的有效字节数不同，球是1字节有效（半径），箱体是3字节（长高宽），胶囊是2字节有效（半径、高）

12.关节点

  关节点（Joint）是用来连接刚体的“钉子”。

关节点类型

关节点数据

关节点数据以一个有符号的int开头，标识关节点数量

13.软体

  软体基于Bullet Physics，随PMX 2.1一起推出。
  我暂时还不会物理方面的知识，暂时机翻，这部分等学一学Bullet后再来补全。

形状类型

标识

空气动力学模型

锚固刚体

顶点针脚

软体数据

14.样例代码

  因为不清楚软体方面，所以没有读取软体数据，不过数据组织套路都一样，有需求可以自己写。代码只考虑2.1版本，2.0版本根据各处版本描述自行更改适应程序。
  因为需要先实验一次，所以用Python，写起来更快一些；C++需要考虑组织程序以及数据类型，Opengl还没学到家，现在只读出了顶点数据，等写出差不多的模型读取器后，再把C++程序放上来。或者直接上github搜索已有现成的mmd读取器saba，参考src/Saba/Model/MMD/PMXFile.h文件，我的C++pmx文件读取程序也是参考这个写法。

class PMX:
    def __init__(self):
        pass

    #Version
    #Index
    #Model_Name
    #Model_Name_Universal
    #Comments_Local
    #Comments_Universal
    #Vertices
    #Surfaces
    #Textures
    #Materials
    #Bones
    #Morphs
    #DisplayFrames
    #Rigid_Bodies
    #Joints

    @staticmethod
    def from_file(filename):
        res = PMX()

        f = open(filename, 'rb')
        Signature = f.read(4)

        if Signature.decode() != "PMX ":
            raise Exception("model type is not PMX")
        else:
            print("Loading PMX")

        res.Version = struct.unpack('<f', f.read(4))[0]

        Global_Count = int.from_bytes(f.read(1), byteorder='little', signed=False)

        Globals = list(f.read(Global_Count))

        Index = res.Index = {'Text Encoding' : "UTF16" if Globals[0] == 0 else "UTF8",
                 'Appendix UV' : Globals[1],
                'Vertex Index Size' : Globals[2],
                'Texture Index Size' : Globals[3],
                'Material Index Size' :Globals[4],
                'Bone Index Size' : Globals[5],
                'Morph Index Size' : Globals[6],
                'Rigid Body Index Size' : Globals[7],
                 }

        res.Model_Name = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(res.Index['Text Encoding'])
        res.Model_Name_Universal = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(res.Index['Text Encoding'])

        res.Comments_Local = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(Index['Text Encoding'])
        res.Comments_Universal = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(Index['Text Encoding'])

        #索引类型对应unpack的大小
        bone_index_type = {1: 'b', 2: 'h', 4:'i'}[Index['Bone Index Size']]
        vertex_index_type = {1:'B', 2:'H', 4:'i'}[Index['Vertex Index Size']]
        texture_index_type = {1: 'b', 2: 'h', 4:'i'}[Index['Texture Index Size']]
        morph_index_type = {1: 'b', 2: 'h', 4:'i'}[Index['Morph Index Size']]
        material_index_type = {1: 'b', 2: 'h', 4:'i'}[Index['Material Index Size']]
        rigid_body_index_type = {1: 'b', 2: 'h', 4:'i'}[Index['Rigid Body Index Size']]

        Vertex_Count = int.from_bytes(f.read(4), byteorder='little', signed=True)
        print(f"Vertex Count: {Vertex_Count}")
        res.Vertices = []

        for i in range(Vertex_Count):
            Position = struct.unpack("<fff", f.read(12))

            Normal = struct.unpack("<fff", f.read(12))

            UV_Texture_Coordinate = struct.unpack("<ff", f.read(8))

            Appendix_UV = []
            for j in range(Index['Appendix UV']):
                Appendix_UV.append(struct.unpack("<ffff", f.read(16)))

            Weight_Type = int.from_bytes(f.read(1), byteorder='little', signed=True)

            # struct: [(bone, weight),...]
            Weight_Deform = []
            if Weight_Type == 0:# BDEF1
                BDEF1 = struct.unpack('<'+bone_index_type, f.read(Index['Bone Index Size']))[0]
                Weight_Deform.append((BDEF1, 1))
            elif Weight_Type == 1:# BDEF2
                BDEF2 = struct.unpack('<'+bone_index_type*2+'f', f.read(Index['Bone Index Size']*2+4))
                Weight_Deform.extend([(BDEF2[0], BDEF2[2]), (BDEF2[1], 1-BDEF2[2])])
            elif Weight_Type == 2:# BDEF4
                BDEF4 = struct.unpack('<'+bone_index_type*4+'ffff', f.read(Index['Bone Index Size']*4+16))
                Weight_Deform.extend([(BDEF4[0], BDEF4[4]),
                                      (BDEF4[1], BDEF4[5]),
                                      (BDEF4[2], BDEF4[6]),
                                      (BDEF4[3], BDEF4[7])])
            elif Weight_Type == 3:# SDEF
                SDEF = struct.unpack('<'+bone_index_type*2+'f'+'f'*9, f.read(Index['Bone Index Size']*2+40))
                Weight_Deform.extend([(SDEF[0], SDEF[2]), (SDEF[1], 1 - SDEF[2]), {'C': SDEF[3:6], 'R0':SDEF[6:9], 'R1':SDEF[9:12]}])
            elif Weight_Type == 4:#QDEF
                QDEF = struct.unpack('<' + bone_index_type * 4 + 'ffff', f.read(Index['Bone Index Size'] * 4 + 16))
                Weight_Deform.extend([(QDEF[0], QDEF[4]),
                                      (QDEF[1], QDEF[5]),
                                      (QDEF[2], QDEF[6]),
                                      (QDEF[3], QDEF[7])])
            elif Weight_Type == -1:
                pass
            else:
                raise Exception(f'Weight Type {Weight_Type} not found')

            Edge_Scale = struct.unpack('<f', f.read(4))[0]

            res.Vertices.append({
                'Position':Position,
                'Normal':Normal,
                'UV Texture Coordinate':UV_Texture_Coordinate,
                'Appendix UV':Appendix_UV,
                'Weight Type':Weight_Type,
                'Weight Deform':Weight_Deform,
                'Edge Scale':Edge_Scale
            })

        Surface_Count = int.from_bytes(f.read(4), byteorder='little', signed=True)
        print(f'Surface count: {Surface_Count}')

        res.Surfaces = []
        for i in range(Surface_Count//3):
            res.Surfaces.append(struct.unpack('<'+vertex_index_type*3,f.read(3*Index['Vertex Index Size'])))

        Texture_Count = int.from_bytes(f.read(4), byteorder='little', signed=True)
        print(f'Texture_Count: {Texture_Count}')
        res.Textures = []
        for i in range(Texture_Count):
            res.Textures.append(f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(Index['Text Encoding']))


        Material_Count = int.from_bytes(f.read(4), byteorder='little', signed=True)
        print(f'Material Count: {Material_Count}')
        res.Materials = []
        for i in range(Material_Count):
            Material_Name_Local = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(Index['Text Encoding'])
            Material_Name_Universal = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(Index['Text Encoding'])
            Diffuser_Color = struct.unpack('<ffff', f.read(16))
            Specular_Color=struct.unpack('<fff', f.read(12))
            Speculat_Strength=struct.unpack('<f', f.read(4))[0]
            Ambient_Color=struct.unpack('<fff',f.read(12))
            Drawing_Flags=f.read(1)[0]
            Drawing_Flags = {
                'No-Cull': Drawing_Flags & 0b00000001 == 0b00000001,
                'Ground Shadow':Drawing_Flags & 0b00000010 == 0b00000010,
                'Draw shadow':Drawing_Flags & 0b00000100 == 0b00000100,
                'Receive Shadow':Drawing_Flags & 0b00001000 == 0b00001000,
                'Has Edge':Drawing_Flags & 0b00010000 == 0b00010000,
                'Vertex Color':Drawing_Flags & 0b00100000 == 0b00100000,
                'Point Drawing':Drawing_Flags & 0b01000000 == 0b01000000,
                'Line Drawing': Drawing_Flags & 0b10000000 == 0b10000000
            }
            Edge_Color = struct.unpack('<ffff', f.read(16))
            Edge_Scale = struct.unpack('<f', f.read(4))[0]
            Texture_Index = struct.unpack('<'+texture_index_type, f.read(Index['Texture Index Size']))[0]
            Environment_Index = struct.unpack('<' + texture_index_type, f.read(Index['Texture Index Size']))[0]
            Environment_Blend_Mode = f.read(1)[0]
            Toon_Reference = f.read(1)[0]
            if Toon_Reference == 0:#reference texture
                Toon_Value = struct.unpack('<'+texture_index_type, f.read(Index['Texture Index Size']))[0]
            elif Toon_Reference == 1:#reference internal
                Toon_Value = f.read(1)[0]
            else:
                raise Exception(f'Toon Reference {Toon_Reference} not found')
            Meta_Data = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode('UTF16')
            Material_Surface_Count = int.from_bytes(f.read(4), byteorder='little', signed=True)
            res.Materials.append({
                'Material Name Local':Material_Name_Local,
                'Material Name Universal': Material_Name_Universal,
                'Diffuser Color': Diffuser_Color,
                'Specular Color': Specular_Color,
                'Speculat Strength': Speculat_Strength,
                'Ambient Color': Ambient_Color,
                'Drawing Flags': Drawing_Flags,
                'Edge Color': Edge_Color,
                'Texture Index': Texture_Index,
                'Environment Index': Environment_Index,
                'Environment Blend Mode': Environment_Blend_Mode,
                'Toon Reference': Toon_Reference,
                'Toon Value': Toon_Value,
                'Meta Data': Meta_Data,
                'Surface Count': Material_Surface_Count
            })

        Bone_Count = int.from_bytes(f.read(4), byteorder='little', signed=True)
        print(f'Bone Count: {Bone_Count}')
        res.Bones = []
        for i in range(Bone_Count):
            Bone_Name_Local = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(Index['Text Encoding'])
            Bone_Name_Universal = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(Index['Text Encoding'])
            Position = struct.unpack('<fff', f.read(12))
            Parent_Bone_Index = struct.unpack('<'+bone_index_type,f.read(Index['Bone Index Size']))[0]
            Layer = int.from_bytes(f.read(4), byteorder='little', signed=True)
            Bone_Flags = f.read(2)
            Bone_Flags = {
                'Indexed Tail Position': Bone_Flags[0] & 0b00000001 == 0b00000001,
                'Rotatable': Bone_Flags[0] & 0b00000010 == 0b00000010,
                'Translatable': Bone_Flags[0] & 0b00000100 == 0b00000100,
                'Is Visible': Bone_Flags[0] & 0b00001000 == 0b00001000,
                'Enabled': Bone_Flags[0] & 0b00010000 == 0b00010000,
                'IK': Bone_Flags[0] & 0b00100000 == 0b00100000,
                'Inherit Rotation': Bone_Flags[1] & 0b00000001 == 0b00000001,
                'Inherit Translation': Bone_Flags[1] & 0b00000010 == 0b00000010,
                'Fixed Axis': Bone_Flags[1] & 0b00000100 == 0b00000100,
                'Local Coordinate': Bone_Flags[1] & 0b00001000 == 0b00001000,
                'Physics After Deform': Bone_Flags[1] & 0b00010000 == 0b00010000,
                'External Parent Deform': Bone_Flags[1] & 0b00100000 == 0b00100000,
            }

            if Bone_Flags['Indexed Tail Position'] is True:
                Tail_Position = struct.unpack('<'+bone_index_type,f.read(Index['Bone Index Size']))[0]
            else:
                Tail_Position = struct.unpack('<fff', f.read(12))

            if Bone_Flags['Inherit Rotation'] or Bone_Flags['Inherit Translation']:
                Inherit_Bone = {
                    'Parent Index': struct.unpack('<'+bone_index_type,f.read(Index['Bone Index Size']))[0],
                    'Parent Influence': struct.unpack('<f', f.read(4))[0]
                }
            else:
                Inherit_Bone = None

            if Bone_Flags['Fixed Axis']:
                Fixed_Axis = struct.unpack('<fff', f.read(12))
            else:
                Fixed_Axis = None

            if Bone_Flags['Local Coordinate']:
                Local_Coordinate = [struct.unpack('<fff', f.read(12)), struct.unpack('<fff', f.read(12))]
            else:
                Local_Coordinate = None

            if Bone_Flags['External Parent Deform']:
                External_Parent = struct.unpack('<'+bone_index_type,f.read(Index['Bone Index Size']))[0]
            else:
                External_Parent = None

            if Bone_Flags['IK']:
                Target = struct.unpack('<'+bone_index_type,f.read(Index['Bone Index Size']))[0]
                Loop = int.from_bytes(f.read(4), byteorder='little', signed=False)
                Limit_Radian = struct.unpack('<f', f.read(4))[0]
                Link_Count = int.from_bytes(f.read(4), byteorder='little', signed=False)
                IK_Links = []
                for j in range(Link_Count):
                    Bone_Index = struct.unpack('<'+bone_index_type,f.read(Index['Bone Index Size']))[0]
                    Has_Limit = bool(f.read(1)[0])
                    if Has_Limit:
                        Limit_Min = struct.unpack('<fff', f.read(12))
                        Limit_Max = struct.unpack('<fff', f.read(12))
                    IK_Links.append({
                        'Bone Index': Bone_Index,
                        'Has Limit': Has_Limit,
                        'Limit Min': Limit_Min if Has_Limit else None,
                        'Limit Max': Limit_Max if Has_Limit else None,
                    })
                IK = {
                    'Target': Target,
                    'Loop': Loop,
                    'Limit Radian': Limit_Radian,
                    'Link Count': Link_Count,
                    'IK Links': IK_Links
                }
            else:
                IK = None

            res.Bones.append({
                'Bone Name Local': Bone_Name_Local,
                'Bone Name Universal': Bone_Name_Universal,
                'Position': Position,
                'Parent Bone Index': Parent_Bone_Index,
                'Layer': Layer,
                'Bone Flags': Bone_Flags,
                'Tail Position': Tail_Position,
                'Inherit Bone': Inherit_Bone,
                'Fixed Axis': Fixed_Axis,
                'Local Coordinate': Local_Coordinate,
                'IK': IK
            })

        Morph_Count = int.from_bytes(f.read(4), byteorder='little', signed=True)
        print(f'Morph Count: {Morph_Count}')
        res.Morphs = []
        for i in range(Morph_Count):
            Morph_Name_Local = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(Index['Text Encoding'])
            Morph_Name_Universal = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(
                Index['Text Encoding'])
            Panel_Type = f.read(1)[0]
            Morph_Type = f.read(1)[0]
            Offset_Size = int.from_bytes(f.read(4), byteorder='little', signed=False)
            Offset_Data = []
            for j in range(Offset_Size):
                #注意这里面的索引类型多不一样
                if Morph_Type in [0, 9]:#Group or Flip
                    Offset_Data.append({
                        'Morph Index': struct.unpack('<' + morph_index_type, f.read(Index['Morph Index Size']))[0],
                        'Influence': struct.unpack('<f', f.read(4))[0]
                     })
                elif Morph_Type == 1:#Vertex
                    Offset_Data.append({
                        'Vertex Index': struct.unpack('<' + vertex_index_type, f.read(Index['Vertex Index Size']))[0],
                        'Translation': struct.unpack('<fff', f.read(12))
                    })
                elif Morph_Type == 2:#Bone
                    Offset_Data.append({
                        'Bone Index': struct.unpack('<' + bone_index_type, f.read(Index['Bone Index Size']))[0],
                        'Translation': struct.unpack('<fff', f.read(12)),
                        'Rotation': struct.unpack('<ffff', f.read(16)),
                    })
                elif Morph_Type in [3, 4, 5, 6, 7]:#UV
                    Offset_Data.append({
                        'Vertex Index': struct.unpack('<' + vertex_index_type, f.read(Index['Vertex Index Size']))[0],
                        'Data': struct.unpack('<ffff', f.read(16))
                    })
                elif Morph_Type == 8:#Material
                    Offset_Data.append({
                        'Material Index': struct.unpack('<' + material_index_type, f.read(Index['Material Index Size']))[0],
                        'Mix Method': f.read(1)[0],
                        'Diffuse': struct.unpack('<ffff', f.read(16)),
                        'Specular': struct.unpack('<fff', f.read(12)),
                        'Specularity': struct.unpack('<f', f.read(4))[0],
                        'Ambient': struct.unpack('<fff', f.read(12)),
                        'Edge Color': struct.unpack('<ffff', f.read(16)),
                        'Edge Size': struct.unpack('<f', f.read(4))[0],
                        'Texture Tint': struct.unpack('<ffff', f.read(16)),
                        'Environment Tint': struct.unpack('<ffff', f.read(16)),
                        'Toon Tint': struct.unpack('<ffff', f.read(16))
                    })
                elif Morph_Type == 10: #Impulse
                    Offset_Data.append({
                        'Rigid Body Index': struct.unpack('<' + rigid_body_index_type, f.read(Index['Rigid Body Index Size'])),
                        'Local Flag': struct.unpack('<f', f.read(4))[0],
                        'Movement Speed': struct.unpack('<fff', f.read(12)),
                        'Rotation torque': struct.unpack('<fff', f.read(12)),
                    })
                else:
                    raise Exception('morph type is not exist')

            res.Morphs.append({
                'Morph Name Local': Morph_Name_Local,
                'Morph Name Universal': Morph_Name_Universal,
                'Panel Type': Panel_Type,
                'Morph Type': Morph_Type,
                'Offset Size': Offset_Size,
                'Offset Data': Offset_Data
            })

        DisplayFrame_Count = int.from_bytes(f.read(4), byteorder='little', signed=True)
        print(f'DisplayFrame Count: {DisplayFrame_Count}')
        res.DisplayFrames = []
        for i in range(DisplayFrame_Count):
            DisplayFrame_Name_Local = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(
                Index['Text Encoding'])
            DisplayFrame_Name_Universal = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(
                Index['Text Encoding'])
            Special_Flag = f.read(1)[0]
            Frame_Count = int.from_bytes(f.read(4), byteorder='little', signed=True)
            Frames = []
            for j in range(Frame_Count):
                Frame_Type = f.read(1)[0]
                if Frame_Type == 1:
                    Frame_Data = struct.unpack('<' + morph_index_type, f.read(Index['Morph Index Size']))[0]
                elif Frame_Type == 0:
                    Frame_Data = struct.unpack('<' + bone_index_type, f.read(Index['Bone Index Size']))[0]
                else:
                    raise Exception('frame type is not exist')
                Frames.append({
                    'Frame Type': Frame_Type,
                    'Frame Data': Frame_Data
                })
            res.DisplayFrames.append({
                'DisplayFrame Name Local': DisplayFrame_Name_Local,
                'DisplayFrame Name Universal': DisplayFrame_Name_Universal,
                'Special Flag': Special_Flag,
                'Frame Count': Frame_Count,
                'Frames': Frames
            })

        Rigid_Body_Count = int.from_bytes(f.read(4), byteorder='little', signed=True)
        print(f'Rigid Body Count: {Rigid_Body_Count}')
        res.Rigid_Bodies = []
        for i in range(Rigid_Body_Count):
            Rigid_Body_Name_Local = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(
                Index['Text Encoding'])
            Rigid_Body_Name_Universal = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(
                Index['Text Encoding'])
            Related_Bone_Index = struct.unpack('<' + bone_index_type, f.read(Index['Bone Index Size']))[0]
            Group_Id = f.read(1)[0]
            Non_Collision_Group = struct.unpack('<h', f.read(2))[0]
            Non_Collision_Group = [((1<<j) & Non_Collision_Group) != (1<<j) for j in range(14)]
            Shape = f.read(1)[0]
            Shape_Size = struct.unpack('<fff', f.read(12))
            Shape_Position = struct.unpack('<fff', f.read(12))
            Shape_Rotation = struct.unpack('<fff', f.read(12))
            Mass = struct.unpack('<f', f.read(4))[0]
            Move_Attenuation = struct.unpack('<f', f.read(4))[0]
            Rotation_Damping = struct.unpack('<f', f.read(4))[0]
            Repulsion = struct.unpack('<f', f.read(4))[0]
            Friction_Force = struct.unpack('<f', f.read(4))[0]
            Physics_Mode = f.read(1)[0]
            res.Rigid_Bodies.append({
                'Rigid Body Name Local': Rigid_Body_Name_Local,
                'Rigid Body Name Universal': Rigid_Body_Name_Universal,
                'Related Bone Index': Related_Bone_Index,
                'Group Id': Group_Id,
                'Non Collision Group': Non_Collision_Group,
                'Shape': Shape,
                'Shape Size': Shape_Size,
                'Shape Position': Shape_Position,
                'Shape Rotation': Shape_Rotation,
                'Mass': Mass,
                'Move Attenuation': Move_Attenuation,
                'Rotation Damping': Rotation_Damping,
                'Repulsion': Repulsion,
                'Friction Force': Friction_Force,
                'Physics Mode': Physics_Mode
            })

        Joint_Count = int.from_bytes(f.read(4), byteorder='little', signed=True)
        print(f'Joint_Count: {Joint_Count}')
        res.Joints = []
        for i in range(Joint_Count):
            Joint_Name_Local = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(
                Index['Text Encoding'])
            Joint_Name_Universal = f.read(int.from_bytes(f.read(4), byteorder='little', signed=False)).decode(
                Index['Text Encoding'])
            Joint_Type = f.read(1)[0]
            Rigid_body_index_A = struct.unpack('<' + rigid_body_index_type, f.read(Index['Rigid Body Index Size']))[0]
            Rigid_body_index_B = struct.unpack('<' + rigid_body_index_type, f.read(Index['Rigid Body Index Size']))[0]
            Position = struct.unpack('<fff', f.read(12))
            Rotation = struct.unpack('<fff', f.read(12))
            Position_Limit = (struct.unpack('<fff', f.read(12)), struct.unpack('<fff', f.read(12)))
            Rotation_Limit = (struct.unpack('<fff', f.read(12)), struct.unpack('<fff', f.read(12)))
            Position_Spring = struct.unpack('<fff', f.read(12))
            Rotation_Spring = struct.unpack('<fff', f.read(12))
            res.Joints.append({
                'Joint Name Local': Joint_Name_Local,
                'Joint Name Universal': Joint_Name_Universal,
                'Joint Type': Joint_Type,
                'Rigid body index A': Rigid_body_index_A,
                'Rigid body index B': Rigid_body_index_B,
                'Position': Position,
                'Rotation': Rotation,
                'Position Limit': Position_Limit,
                'Rotation Limit': Rotation_Limit,
                'Position Spring': Position_Spring,
                'Rotation Spring': Rotation_Spring,
            })
            f.close()
            return res

初始化：

if __name__ == '__main__':
    pmx = PMX.from_file('model/model_test.pmx')

  PMX对象的成员参考staticmethod上面的注释。