test/pmd_diff_test.py

   1 import pymeshio.pmd
   2 import meshio.pmd
   3 import sys
   4 from nose.tools import *
   5
   6 PMD_FILE="K:/MMD/model/official/miku.pmd"
   7
   8 def test_pmd_diff():
   9     io_py=pymeshio.pmd.IO()
  10     assert io_py.read(PMD_FILE)
  11     io_c=meshio.pmd.IO()
  12     assert io_c.read(PMD_FILE)
  13
  14     # header
  15     assert_equal(io_py.version, io_c.version)
  16     assert_equal(io_py.name, io_c.name)
  17     assert_equal(io_py.english_name, io_c.english_name)
  18     assert_equal(io_py.comment, io_c.comment)
  19     assert_equal(io_py.english_comment, io_c.english_comment)
  20
  21     # vertices
  22     assert_equal(len(io_py.vertices), len(io_c.vertices))
  23     for l, r in zip(io_py.vertices, io_c.vertices):
  24         assert_equal(l.pos.x, r.pos.x)
  25         assert_equal(l.pos.y, r.pos.y)
  26         assert_equal(l.pos.z, r.pos.z)
  27         assert_equal(l.normal.x, r.normal.x)
  28         assert_equal(l.normal.y, r.normal.y)
  29         assert_equal(l.normal.z, r.normal.z)
  30         assert_equal(l.uv.x, r.uv.x)
  31         assert_equal(l.uv.y, r.uv.y)
  32         assert_equal(l.bone0, r.bone0)
  33         assert_equal(l.bone1, r.bone1)
  34         assert_equal(l.weight0, r.weight0)
  35         assert_equal(l.edge_flag, r.edge_flag)
  36
  37     # indices
  38     assert_equal(len(io_py.indices), len(io_c.indices))
  39     for l, r in zip(io_py.indices, io_c.indices):
  40         assert_equal(l, r)
  41
  42     # materials
  43     assert_equal(len(io_py.materials), len(io_c.materials))
  44     for l, r in zip(io_py.materials, io_c.materials):
  45         assert_equal(l.diffuse.r, r.diffuse.r)
  46         assert_equal(l.diffuse.g, r.diffuse.g)
  47         assert_equal(l.diffuse.b, r.diffuse.b)
  48         assert_equal(l.diffuse.a, r.diffuse.a)
  49         assert_equal(l.shinness, r.shinness)
  50         assert_equal(l.specular.r, r.specular.r)
  51         assert_equal(l.specular.g, r.specular.g)
  52         assert_equal(l.specular.b, r.specular.b)
  53         assert_equal(l.ambient.r, r.ambient.r)
  54         assert_equal(l.ambient.g, r.ambient.g)
  55         assert_equal(l.ambient.b, r.ambient.b)
  56         assert_equal(l.vertex_count, r.vertex_count)
  57         assert_equal(l.texture, r.texture)
  58         assert_equal(l.toon_index, r.toon_index)
  59         assert_equal(l.flag, r.flag)
  60
  61     # bones
  62     assert_equal(len(io_py.bones), len(io_c.bones))
  63     for l, r in zip(io_py.bones, io_c.bones):
  64         assert_equal(l.name, r.name)
  65         assert_equal(l.type, r.type)
  66         assert_equal(l.parent_index, r.parent_index)
  67         assert_equal(l.tail_index, r.tail_index)
  68         assert_equal(l.tail.x, r.tail.x)
  69         assert_equal(l.tail.y, r.tail.y)
  70         assert_equal(l.tail.z, r.tail.z)
  71         assert_equal(l.ik_index, r.ik_index)
  72         assert_equal(l.pos.x, r.pos.x)
  73         assert_equal(l.pos.y, r.pos.y)
  74         assert_equal(l.pos.z, r.pos.z)
  75         assert_equal(l.english_name, r.english_name)
  76
  77     # ik_list
  78     assert_equal(len(io_py.ik_list), len(io_c.ik_list))
  79     for l, r in zip(io_py.ik_list, io_c.ik_list):
  80         assert_equal(l.index, r.index)
  81         assert_equal(l.target, r.target)
  82         assert_equal(l.iterations, r.iterations)
  83         assert_equal(l.weight, r.weight)
  84         for l_child, r_child in zip(l.children, r.children):
  85             assert_equal(l_child, r_child)
  86
  87     # morph_list
  88     assert_equal(len(io_py.morph_list), len(io_c.morph_list))
  89     for l, r in zip(io_py.morph_list, io_c.morph_list):
  90         assert_equal(l.name, r.name)
  91         assert_equal(l.type, r.type)
  92         for l_index, r_index in zip(l.indices, r.indices):
  93             assert_equal(l_index, r_index)
  94         for l_pos, r_pos in zip(l.pos_list, r.pos_list):
  95             assert_equal(l_pos.x, l_pos.x)
  96             assert_equal(l_pos.y, l_pos.y)
  97             assert_equal(l_pos.z, l_pos.z)
  98         assert_equal(l.english_name, l.english_name)
  99         assert_equal(l.vertex_count, l.vertex_count)
 100
 101
 102     # face_list
 103     assert_equal(len(io_py.face_list), len(io_c.face_list))
 104     for l, r in zip(io_py.face_list, io_c.face_list):
 105         assert_equal(l, r)
 106
 107     # bone_group_list
 108     assert_equal(len(io_py.bone_group_list), len(io_c.bone_group_list))
 109     for l, r in zip(io_py.bone_group_list, io_c.bone_group_list):
 110         assert_equal(l.name, r.name)
 111         assert_equal(l.english_name, r.english_name)
 112
 113     # bone_display_list
 114     assert_equal(len(io_py.bone_display_list), len(io_c.bone_display_list))
 115     for l, r in zip(io_py.bone_display_list, io_c.bone_display_list):
 116         assert_equal(l[0], r[0])
 117         assert_equal(l[1], r[1])
 118
 119     # toon_textures
 120     for l, r in ((io_py.toon_textures[i], io_c.toon_textures[i]) for i in range(10)):
 121         assert_equal(l, r.str())
 122
 123     # rigidbodies
 124     assert_equal(len(io_py.rigidbodies), len(io_c.rigidbodies))
 125     for l, r in zip(io_py.rigidbodies, io_c.rigidbodies):
 126         assert_equal(l.name, r.name)
 127         assert_equal(l.boneIndex, r.boneIndex)
 128         assert_equal(l.group, r.group)
 129         assert_equal(l.target, r.target)
 130         assert_equal(l.shapeType, r.shapeType)
 131         assert_equal(l.w, r.w)
 132         assert_equal(l.h, r.h)
 133         assert_equal(l.d, r.d)
 134         assert_equal(l.position.x, r.position.x)
 135         assert_equal(l.position.x, r.position.x)
 136         assert_equal(l.position.x, r.position.x)
 137         assert_equal(l.rotation.x, r.rotation.x)
 138         assert_equal(l.rotation.x, r.rotation.x)
 139         assert_equal(l.rotation.x, r.rotation.x)
 140         assert_equal(l.weight, r.weight)
 141         assert_equal(l.linearDamping, r.linearDamping)
 142         assert_equal(l.angularDamping, r.angularDamping)
 143         assert_equal(l.restitution, r.restitution)
 144         assert_equal(l.friction, r.friction)
 145         assert_equal(l.processType, r.processType)
 146
 147     # constraints
 148     assert_equal(len(io_py.constraints), len(io_c.constraints))
 149     for l, r in zip(io_py.constraints, io_c.constraints):
 150         assert_equal(l.name, r.name)
 151         assert_equal(l.rigidA, r.rigidA)
 152         assert_equal(l.rigidB, r.rigidB)
 153         assert_equal(l.pos.x, r.pos.x)
 154         assert_equal(l.pos.y, r.pos.y)
 155         assert_equal(l.pos.z, r.pos.z)
 156         assert_equal(l.rot.x, r.rot.x)
 157         assert_equal(l.rot.y, r.rot.y)
 158         assert_equal(l.rot.z, r.rot.z)
 159         assert_equal(l.constraintPosMin.x, r.constraintPosMin.x)
 160         assert_equal(l.constraintPosMin.y, r.constraintPosMin.y)
 161         assert_equal(l.constraintPosMin.z, r.constraintPosMin.z)
 162         assert_equal(l.constraintPosMax.x, r.constraintPosMax.x)
 163         assert_equal(l.constraintPosMax.y, r.constraintPosMax.y)
 164         assert_equal(l.constraintPosMax.z, r.constraintPosMax.z)
 165         assert_equal(l.constraintRotMin.x, r.constraintRotMin.x)
 166         assert_equal(l.constraintRotMin.y, r.constraintRotMin.y)
 167         assert_equal(l.constraintRotMin.z, r.constraintRotMin.z)
 168         assert_equal(l.constraintRotMax.x, r.constraintRotMax.x)
 169         assert_equal(l.constraintRotMax.y, r.constraintRotMax.y)
 170         assert_equal(l.constraintRotMax.z, r.constraintRotMax.z)
 171         assert_equal(l.springPos.x, r.springPos.x)
 172         assert_equal(l.springPos.y, r.springPos.y)
 173         assert_equal(l.springPos.z, r.springPos.z)
 174         assert_equal(l.springRot.x, r.springRot.x)
 175         assert_equal(l.springRot.y, r.springRot.y)
 176         assert_equal(l.springRot.z, r.springRot.z)
 177