pymeshio.pmd

1 # coding: utf-8 2 """ 3 ======================== 4 MikuMikuDance PMD format 5 ======================== 6 7 file format 8 ~~~~~~~~~~~ 9 * http://blog.goo.ne.jp/torisu_tetosuki/e/209ad341d3ece2b1b4df24abf619d6e4 10 11 specs 12 ~~~~~ 13 * textencoding: bytes(cp932) 14 * coordinate: left handed y-up(DirectX) 15 * uv origin: 16 * face: only triangle 17 * backculling: 18 19 """ 20 import os 21 import sys 22 import struct 23 import warnings 24 from .. import common 25 26

27 -class Vertex(object):

28 """ 29 ========== 30 pmd vertex 31 ========== 32 two bone weighted vertex with normal and uv. 33 34 format 35 ~~~~~~ 36 * http://blog.goo.ne.jp/torisu_tetosuki/e/5a1b16e2f61067838dfc66d010389707 37 38 :IVariables: 39 pos 40 Vector3 41 normal 42 Vector3 43 uv 44 Vector2 45 bone0 46 bone index 47 bone1 48 bone index 49 weight0 50 bone0 influence. min: 0, max: 100 51 edge_flag 52 int flag. 0: edge on, 1: edge off 53 """ 54 __slots__=['pos', 'normal', 'uv', 'bone0', 'bone1', 'weight0', 'edge_flag']

55 - def __init__(self, pos, normal, uv, 56 bone0, bone1, weight0, edge_flag):

57 self.pos=pos 58 self.normal=normal 59 self.uv=uv 60 self.bone0=bone0 61 self.bone1=bone1 62 self.weight0=weight0 63 self.edge_flag=edge_flag

64

65 - def __str__(self):

66 return "<%s %s %s, (%d, %d, %d)>" % ( 67 str(self.pos), 68 str(self.normal), 69 str(self.uv), 70 self.bone0, self.bone1, self.weight0)

71

72 - def __eq__(self, rhs):

73 return ( 74 self.pos==rhs.pos 75 and self.normal==rhs.normal 76 and self.uv==rhs.uv 77 and self.bone0==rhs.bone0 78 and self.bone1==rhs.bone1 79 and self.weight0==rhs.weight0 80 and self.edge_flag==rhs.edge_flag 81 )

82

83 - def __getitem__(self, key):

84 if key==0: 85 return self.pos.x 86 elif key==1: 87 return self.pos.y 88 elif key==2: 89 return self.pos.z 90 else: 91 assert(False)

92 93

94 -class Material(object):

95 """ 96 ============ 97 pmd material 98 ============ 99 100 format 101 ~~~~~~ 102 * http://blog.goo.ne.jp/torisu_tetosuki/e/ea0bb1b1d4c6ad98a93edbfe359dac32 103 104 :IVariables: 105 diffuse_color 106 RGB 107 alpha 108 float 109 specular_factor 110 float 111 specular_color 112 RGB 113 ambient_color 114 RGB 115 toon_index 116 int 117 edge_flag 118 int 119 vertex_count 120 indices length 121 texture_file 122 texture file path 123 """ 124 __slots__=[ 125 'diffuse_color', 'alpha', 126 'specular_factor', 'specular_color', 'ambient_color', 127 'toon_index', 'edge_flag', 128 'vertex_count', 'texture_file', 129 ]

130 - def __init__(self, diffuse_color, alpha, 131 specular_factor, specular_color, ambient_color, 132 toon_index, edge_flag, vertex_count, texture_file):

133 self.diffuse_color=diffuse_color 134 self.alpha=alpha 135 self.specular_factor=specular_factor 136 self.specular_color=specular_color 137 self.ambient_color=ambient_color 138 self.toon_index=toon_index 139 self.edge_flag=edge_flag 140 self.vertex_count=vertex_count 141 self.texture_file=texture_file

142

143 - def __str__(self):

144 return "<Material [%f, %f, %f, %f]>" % ( 145 self.diffuse[0], self.diffuse[1], 146 self.diffuse[2], self.diffuse[3], 147 )

148

149 - def __eq__(self, rhs):

150 return ( 151 self.diffuse_color==rhs.diffuse_color 152 and self.alpha==rhs.alpha 153 and self.specular_factor==rhs.specular_factor 154 and self.specular_color==rhs.specular_color 155 and self.ambient_color==rhs.ambient_color 156 and self.toon_index==rhs.toon_index 157 and self.edge_flag==rhs.edge_flag 158 and self.vertex_count==rhs.vertex_count 159 and self.texture_file==rhs.texture_file 160 )

161 162

163 -class Bone(object):

164 """ 165 ========== 166 pmd bone 167 ========== 168 169 format 170 ~~~~~~ 171 * http://blog.goo.ne.jp/torisu_tetosuki/e/638463f52d0ad6ca1c46fd315a9b17d0 172 173 :IVariables: 174 name 175 bone name 176 english_name 177 bone english_name 178 index 179 boen index(append for internal use) 180 type 181 bone type 182 ik 183 ik(append for internal use) 184 pos 185 bone head position 186 ik_index 187 ik target bone index 188 parent_index 189 parent bone index 190 tail_index 191 tail bone index 192 parent 193 parent bone(append for internal use) 194 tail 195 tail bone(append for internal use) 196 children 197 children bone(append for internal use) 198 """ 199 # kinds 200 ROTATE = 0 201 ROTATE_MOVE = 1 202 IK = 2 203 IK_ROTATE_INFL = 4 204 ROTATE_INFL = 5 205 IK_TARGET = 6 206 UNVISIBLE = 7 207 # since v4.0 208 ROLLING=8 # ? 209 TWEAK=9 210 __slots__=['name', 'index', 'type', 'parent', 'ik', 'pos', 211 'children', 'english_name', 'ik_index', 212 'parent_index', 'tail_index', 'tail', 213 ]

214 - def __init__(self, name=b'bone', type=0):

215 self.name=name 216 self.index=0 217 self.type=type 218 self.parent_index=0xFFFF 219 self.tail_index=0 220 self.tail=common.Vector3(0, 0, 0) 221 self.parent=None 222 self.ik_index=0xFFFF 223 self.pos=common.Vector3(0, 0, 0) 224 self.children=[] 225 self.english_name=b''

226

227 - def __eq__(self, rhs):

228 return ( 229 self.name==rhs.name 230 and self.index==rhs.index 231 and self.type==rhs.type 232 and self.parent_index==rhs.parent_index 233 and self.tail_index==rhs.tail_index 234 and self.tail==rhs.tail 235 and self.ik_index==rhs.ik_index 236 and self.pos==rhs.pos 237 and self.children==rhs.children 238 and self.english_name==rhs.english_name 239 )

240

241 - def hasParent(self):

242 return self.parent_index!=0xFFFF

243

244 - def hasChild(self):

245 return self.tail_index!=0

246

247 - def display(self, indent=None):

248 indent=indent or [] 249 if len(indent)>0: 250 prefix='' 251 for i, is_end in enumerate(indent): 252 if i==len(indent)-1: 253 break 254 else: 255 prefix+=' ' if is_end else ' |' 256 uni='%s +%s(%s)' % (prefix, unicode(self), self.english_name) 257 print(uni.encode(ENCODING)) 258 else: 259 uni='%s(%s)' % (unicode(self), self.english_name) 260 print(uni.encode(ENCODING)) 261 262 child_count=len(self.children) 263 for i in range(child_count): 264 child=self.children[i] 265 if i<child_count-1: 266 child.display(indent+[False]) 267 else: 268 # last 269 child.display(indent+[True])

270 271 # 0

272 -class Bone_Rotate(Bone):

273 __slots__=[]

274 - def __init__(self, name):

275 super(Bone_Rotate, self).__init__(name, 0)

276 - def __str__(self):

277 return '<ROTATE %s>' % (self.name)

278 # 1

279 -class Bone_RotateMove(Bone):

280 __slots__=[]

281 - def __init__(self, name):

282 super(Bone_RotateMove, self).__init__(name, 1)

283 - def __str__(self):

284 return '<ROTATE_MOVE %s>' % (self.name)

285 # 2

286 -class Bone_IK(Bone):

287 __slots__=[]

288 - def __init__(self, name):

289 super(Bone_IK, self).__init__(name, 2)

290 - def __str__(self):

291 return '<IK %s>' % (self.name)

292 # 4

293 -class Bone_IKRotateInfl(Bone):

294 __slots__=[]

295 - def __init__(self, name):

296 super(Bone_IKRotateInfl, self).__init__(name, 4)

297 - def __str__(self):

298 return '<IK_ROTATE_INFL %s>' % (self.name)

299 # 5

300 -class Bone_RotateInfl(Bone):

301 __slots__=[]

302 - def __init__(self, name):

303 super(Bone_RotateInfl, self).__init__(name, 5)

304 - def __str__(self):

305 return '<ROTATE_INFL %s>' % (self.name)

306 # 6

307 -class Bone_IKTarget(Bone):

308 __slots__=[]

309 - def __init__(self, name):

310 super(Bone_IKTarget, self).__init__(name, 6)

311 - def __str__(self):

312 return '<IK_TARGET %s>' % (self.name)

313 # 7

314 -class Bone_Unvisible(Bone):

315 __slots__=[]

316 - def __init__(self, name):

317 super(Bone_Unvisible, self).__init__(name, 7)

318 - def __str__(self):

319 return '<UNVISIBLE %s>' % (self.name)

320 # 8

321 -class Bone_Rolling(Bone):

322 __slots__=[]

323 - def __init__(self, name):

324 super(Bone_Rolling, self).__init__(name, 8)

325 - def __str__(self):

326 return '<ROLLING %s>' % (self.name)

327 # 9

328 -class Bone_Tweak(Bone):

329 __slots__=[]

330 - def __init__(self, name):

331 super(Bone_Tweak, self).__init__(name, 9)

332 - def __str__(self):

333 return '<TWEAK %s>' % (self.name)

334 335

336 -def createBone(name, type):

337 if type==0: 338 return Bone_Rotate(name) 339 elif type==1: 340 return Bone_RotateMove(name) 341 elif type==2: 342 return Bone_IK(name) 343 elif type==3: 344 raise Exception("no used bone type: 3(%s)" % name) 345 elif type==4: 346 return Bone_IKRotateInfl(name) 347 elif type==5: 348 return Bone_RotateInfl(name) 349 elif type==6: 350 return Bone_IKTarget(name) 351 elif type==7: 352 return Bone_Unvisible(name) 353 elif type==8: 354 return Bone_Rolling(name) 355 elif type==9: 356 return Bone_Tweak(name) 357 else: 358 raise Exception("unknown bone type: %d(%s)", type, name)

359 360

361 -class IK(object):

362 __slots__=['index', 'target', 'iterations', 'weight', 'length', 'children']

363 - def __init__(self, index=0, target=0):

364 self.index=index 365 self.target=target 366 self.iterations=None 367 self.weight=None 368 self.children=[]

369

370 - def __str__(self):

371 return "<IK index: %d, target: %d, iterations: %d, weight: %f, children: %s(%d)>" %(self.index, self.target, self.iterations, self.weight, '-'.join([str(i) for i in self.children]), len(self.children))

372

373 - def __eq__(self, rhs):

374 return ( 375 self.index==rhs.index 376 and self.target==rhs.target 377 and self.iterations==rhs.iterations 378 and self.weight==rhs.weight 379 and self.children==rhs.children 380 )

381 382

383 -class Morph(object):

384 __slots__=['name', 'type', 'indices', 'pos_list', 'english_name', 385 'vertex_count']

386 - def __init__(self, name):

387 self.name=name 388 self.type=None 389 self.indices=[] 390 self.pos_list=[] 391 self.english_name=b'' 392 self.vertex_count=0

393

394 - def append(self, index, x, y, z):

395 self.indices.append(index) 396 self.pos_list.append(common.Vector3(x, y, z))

397

398 - def __str__(self):

399 return '<Skin name: "%s", type: %d, vertex: %d>' % ( 400 self.name, self.type, len(self.indices))

401

402 - def __eq__(self, rhs):

403 return ( 404 self.name==rhs.name 405 and self.type==rhs.type 406 and self.indices==rhs.indices 407 and self.pos_list==rhs.pos_list 408 and self.english_name==rhs.english_name 409 and self.vertex_count==rhs.vertex_count 410 )

411 412

413 -class BoneGroup(object):

414 __slots__=['name', 'english_name']

415 - def __init__(self, name=b'group', english_name=b'center'):

416 self.name=name 417 self.english_name=english_name

418

419 - def __eq__(self, rhs):

420 return self.name==rhs.name and self.english_name==rhs.english_name

421 422 423 SHAPE_SPHERE=0 424 SHAPE_BOX=1 425 SHAPE_CAPSULE=2 426 427 RIGIDBODY_KINEMATICS=0 428 RIGIDBODY_PHYSICS=1 429 RIGIDBODY_PHYSICS_WITH_BONE=2 430 431

432 -class RigidBody(object):

433 __slots__=['name', 434 'bone_index', 435 'collision_group', 436 'no_collision_group', 437 'shape_type', 438 'shape_size', 439 'shape_position', 440 'shape_rotation', 441 'mass', 442 'linear_damping', 443 'angular_damping', 444 'restitution', 445 'friction', 446 'mode' 447 ]

448 - def __init__(self, name, 449 bone_index, 450 collision_group, 451 no_collision_group, 452 shape_type, 453 shape_size, 454 shape_position, 455 shape_rotation, 456 mass, 457 linear_damping, 458 angular_damping, 459 restitution, 460 friction, 461 mode 462 ):

463 self.name=name 464 self.bone_index=bone_index 465 self.collision_group=collision_group 466 self.no_collision_group=no_collision_group 467 self.shape_type=shape_type 468 self.shape_size=shape_size 469 self.shape_position=shape_position 470 self.shape_rotation=shape_rotation 471 self.mass=mass 472 self.linear_damping=linear_damping 473 self.angular_damping=angular_damping 474 self.restitution=restitution 475 self.friction=friction 476 self.mode=mode

477

478 - def __eq__(self, rhs):

479 return ( 480 self.name==rhs.name 481 and self.bone_index==rhs.bone_index 482 and self.collision_group==rhs.collision_group 483 and self.no_collision_group==rhs.no_collision_group 484 and self.shape_type==rhs.shape_type 485 and self.shape_size==rhs.shape_size 486 and self.shape_position==rhs.shape_position 487 and self.shape_rotation==rhs.shape_rotation 488 and self.mass==rhs.mass 489 and self.linear_damping==rhs.linear_damping 490 and self.angular_damping==rhs.angular_damping 491 and self.restitution==rhs.restitution 492 and self.friction==rhs.friction 493 and self.mode==rhs.mode 494 )

495 496

497 -class Joint(object):

498 __slots__=[ 'name', 'rigidbody_index_a', 'rigidbody_index_b', 499 'position', 'rotation', 500 'translation_limit_max', 'translation_limit_min', 501 'rotation_limit_max', 'rotation_limit_min', 502 'spring_constant_translation', 'spring_constant_rotation', 503 ]

504 - def __init__(self, name, 505 rigidbody_index_a, rigidbody_index_b, 506 position, rotation, 507 translation_limit_max, translation_limit_min, 508 rotation_limit_max, rotation_limit_min, 509 spring_constant_translation, spring_constant_rotation 510 ):

511 self.name=name 512 self.rigidbody_index_a=rigidbody_index_a 513 self.rigidbody_index_b=rigidbody_index_b 514 self.position=position 515 self.rotation=rotation 516 self.translation_limit_max=translation_limit_max 517 self.translation_limit_min=translation_limit_min 518 self.rotation_limit_max=rotation_limit_max 519 self.rotation_limit_min=rotation_limit_min 520 self.spring_constant_translation=spring_constant_translation 521 self.spring_constant_rotation=spring_constant_rotation

522

523 - def __eq__(self, rhs):

524 return ( 525 self.name==rhs.name 526 and self.rigidbody_index_a==rhs.rigidbody_index_a 527 and self.rigidbody_index_b==rhs.rigidbody_index_b 528 and self.position==rhs.position 529 and self.rotation==rhs.rotation 530 and self.translation_limit_max==rhs.translation_limit_max 531 and self.translation_limit_min==rhs.translation_limit_min 532 and self.rotation_limit_max==rhs.rotation_limit_max 533 and self.rotation_limit_min==rhs.rotation_limit_min 534 and self.spring_constant_translation==rhs.spring_constant_translation 535 and self.spring_constant_rotation==rhs.spring_constant_rotation 536 )

537 538

539 -class Model(object):

540 """pmd loader class. 541 542 Attributes: 543 io: internal use. 544 end: internal use. 545 pos: internal user. 546 547 version: pmd version number 548 _name: internal 549 """ 550 __slots__=[ 551 'path', 552 'version', 'name', 'comment', 553 'english_name', 'english_comment', 554 'vertices', 'indices', 'materials', 'bones', 555 'ik_list', 'morphs', 556 'morph_indices', 'bone_group_list', 'bone_display_list', 557 'toon_textures', 558 'rigidbodies', 'joints', 559 560 'no_parent_bones', 561 ]

562 - def __init__(self, version=1.0):

563 self.path=b'' 564 self.version=version 565 self.name=b'' 566 self.comment=b'' 567 self.english_name=b'' 568 self.english_comment=b'' 569 self.vertices=[] 570 self.indices=[] 571 self.materials=[] 572 self.bones=[] 573 self.ik_list=[] 574 self.morphs=[] 575 self.morph_indices=[] 576 self.bone_group_list=[] 577 self.bone_display_list=[] 578 # extend 579 self.toon_textures=[b'']*10 580 self.rigidbodies=[] 581 self.joints=[] 582 # innner use 583 self.no_parent_bones=[]

584

585 - def each_vertex(self): return self.vertices

586 - def getUV(self, i): return self.vertices[i].uv

587

588 - def __str__(self):

589 return '<pmd-%g, "%s" vertex: %d, face: %d, material: %d, bone: %d ik: %d, skin: %d>' % ( 590 self.version, self.name, len(self.vertices), len(self.indices), 591 len(self.materials), len(self.bones), len(self.ik_list), len(self.morphs))

592

593 - def __eq__(self, rhs):

594 return ( 595 self.name==rhs.name 596 and self.comment==rhs.comment 597 and self.english_name==rhs.english_name 598 and self.english_comment==rhs.english_comment 599 and self.vertices==rhs.vertices 600 and self.indices==rhs.indices 601 and self.materials==rhs.materials 602 and self.bones==rhs.bones 603 and self.ik_list==rhs.ik_list 604 and self.morphs==rhs.morphs 605 and self.morph_indices==rhs.morph_indices 606 and self.bone_group_list==rhs.bone_group_list 607 and self.bone_display_list==rhs.bone_display_list 608 and self.toon_textures==rhs.toon_textures 609 and self.rigidbodies==rhs.rigidbodies 610 and self.joints==rhs.joints 611 )

612

613 - def diff(self, rhs):

614 if self.name!=rhs.name: 615 print(self.name, rhs.name) 616 return 617 if self.comment!=rhs.comment: 618 print(self.comment, rhs.comment) 619 return 620 if self.english_name!=rhs.english_name: 621 print(self.english_name, rhs.english_name) 622 return 623 if self.english_comment!=rhs.english_comment: 624 print(self.english_comment, rhs.english_comment) 625 return 626 if self.vertices!=rhs.vertices: 627 print(self.vertices, rhs.vertices) 628 return 629 if self.indices!=rhs.indices: 630 print(self.indices, rhs.indices) 631 return 632 if self.materials!=rhs.materials: 633 print(self.materials, rhs.materials) 634 return 635 if self.bones!=rhs.bones: 636 print(self.bones, rhs.bones) 637 return 638 if self.ik_list!=rhs.ik_list: 639 print(self.ik_list, rhs.ik_list) 640 return 641 if self.morphs!=rhs.morphs: 642 print(self.morphs, rhs.morphs) 643 return 644 if self.morph_indices!=rhs.morph_indices: 645 print(self.morph_indices, rhs.morph_indices) 646 return 647 if self.bone_group_list!=rhs.bone_group_list: 648 print(self.bone_group_list, rhs.bone_group_list) 649 return 650 if self.bone_display_list!=rhs.bone_display_list: 651 print(self.bone_display_list, rhs.bone_display_list) 652 return 653 if self.toon_textures!=rhs.toon_textures: 654 print(self.toon_textures, rhs.toon_textures) 655 return 656 if self.rigidbodies!=rhs.rigidbodies: 657 print(self.rigidbodies, rhs.rigidbodies) 658 return 659 if self.joints!=rhs.joints: 660 print(self.joints, rhs.joints) 661 return

662

Source Code for Package pymeshio.pmd