X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=swig%2Fblender24%2Fpmd_export.py;h=c407b4e0927b6119cec1e62f2ea1b75df794e25e;hb=e3663cdfa9eba5b3809390cbc46516f50cb244bc;hp=9ce8df21210c7d5aaaa1aac534f8d9e4d2003d90;hpb=efd380964e9620d9c0b3dac17c9b18faa2314a71;p=meshio%2Fmeshio.git diff --git a/swig/blender24/pmd_export.py b/swig/blender24/pmd_export.py index 9ce8df2..c407b4e 100644 --- a/swig/blender24/pmd_export.py +++ b/swig/blender24/pmd_export.py @@ -7,11 +7,12 @@ Tooltip: 'Export PMD file for MikuMikuDance.' """ __author__= ["ousttrue"] -__version__= "0.2" +__version__= "1.0" __url__=() __bpydoc__=""" 0.1 20100318 first implementation. 0.2 20100519 refactoring. use C extension. +1.0 20100530 implement, basic features. """ import Blender import os @@ -165,35 +166,43 @@ class VertexArray(object): class Morph(object): - __slots__=['name', 'type', 'indices', 'offsets'] + __slots__=['name', 'type', 'offsets'] def __init__(self, name, type): self.name=name self.type=type - self.indices=[] self.offsets=[] + def add(self, index, offset): + self.offsets.append((index, offset)) + + def sort(self): + self.offsets.sort(lambda l, r: l[0]-r[0]) + + def __str__(self): + return "" % self.name + +class IKSolver(object): + __slots__=['target', 'effector', 'length', 'iterations', 'weight'] + def __init__(self, target, effector, length, iterations, weight): + self.target=target + self.effector=effector + self.length=length + self.iterations=iterations + self.weight=weight + + class OneSkinMesh(object): - __slots__=['armatureObj', 'vertexArray', 'morphList'] - def __init__(self, root): - self.armatureObj=None + __slots__=['vertexArray', 'morphList'] + def __init__(self): self.vertexArray=VertexArray() self.morphList=[] - self.__create(root) def __str__(self): - return "" % ( - self.armatureObj.name if self.armatureObj else None, + return "" % ( self.vertexArray, len(self.morphList)) - def __create(self, node): - if node.o.getType()=='Mesh': - self.__addMesh(node.o) - - for child in node.children: - self.__create(child) - - def __addMesh(self, obj): + def addMesh(self, obj): if obj.restrictDisplay: # 非表示 return @@ -201,17 +210,6 @@ class OneSkinMesh(object): print("export", obj.name) ############################################################ - # search armature modifier - ############################################################ - for m in obj.modifiers: - if m.name=="Armature": - armatureObj=m[Blender.Modifier.Settings.OBJECT] - if not self.armatureObj: - self.armatureObj=armatureObj - elif self.armatureObj!=armatureObj: - print "warning! found multiple armature. ignored.", armatureObj.name - - ############################################################ # bone weight ############################################################ mesh=obj.getData(mesh=True) @@ -340,11 +338,12 @@ class OneSkinMesh(object): # base indexRelativeMap={} blenderMesh=obj.getData(mesh=True) + baseMorph=None if blenderMesh.key: for b in blenderMesh.key.blocks: if b.name=='Basis': print(b.name) - morph=self.__getOrCreateMorph('base', 0) + baseMorph=self.__getOrCreateMorph('base', 0) relativeIndex=0 basis=b for index in blenderMesh.getVertsFromGroup( @@ -353,32 +352,44 @@ class OneSkinMesh(object): pos=[v[0], v[1], v[2]] indices=self.vertexArray.getMappedIndices(index) for i in indices: - morph.indices.append(i) - morph.offsets.append(pos) - indexRelativeMap[i]=relativeIndex + baseMorph.add(i, pos) + indexRelativeMap[relativeIndex]=i relativeIndex+=1 break - + print(len(baseMorph.offsets)) + baseMorph.sort() assert(basis) # shape keys + vg=obj.getData(mesh=True).getVertsFromGroup( + MMD_SHAPE_GROUP_NAME) for b in obj.getData(mesh=True).key.blocks: if b.name=='Basis': continue print(b.name) morph=self.__getOrCreateMorph(b.name, 4) - for index in obj.getData(mesh=True).getVertsFromGroup( - MMD_SHAPE_GROUP_NAME): - #offset=[d-s for d, s in zip( - # b.data[index], basis.data[index])] - src=basis.data[index] - dst=b.data[index] + for index, src, dst in zip( + xrange(len(blenderMesh.verts)), + basis.data, + b.data): offset=[dst[0]-src[0], dst[1]-src[1], dst[2]-src[2]] - indices=self.vertexArray.getMappedIndices(index) - for i in indices: - morph.indices.append(indexRelativeMap[i]) - morph.offsets.append(offset) + if index in vg: + indices=self.vertexArray.getMappedIndices(index) + for i in indices: + morph.add(indexRelativeMap[i], offset) + assert(len(morph.offsets)==len(baseMorph.offsets)) + + # sort skinmap + if len(self.morphList)>1: + original=self.morphList[:] + def getIndex(morph): + for i, v in enumerate(englishmap.skinMap): + if v[0]==morph.name: + return i + #print(morph) + return 0 + self.morphList.sort(lambda l, r: getIndex(l)-getIndex(r)) def __getOrCreateMorph(self, name, type): for m in self.morphList: @@ -393,14 +404,21 @@ class OneSkinMesh(object): class Bone(object): - __slots__=['index', 'name', 'pos', 'parent_index', 'tail_index', 'type'] - def __init__(self, name, pos): + __slots__=['index', 'name', 'ik_index', + 'pos', 'tail', 'parent_index', 'tail_index', 'type', 'isConnect'] + def __init__(self, name, pos, tail): self.index=-1 self.name=name - self.pos=[pos.x, pos.y, pos.z] + self.pos=pos + self.tail=tail self.parent_index=None self.tail_index=None self.type=0 + self.isConnect=False + self.ik_index=0 + + def __eq__(self, rhs): + return self.index==rhs.index def __str__(self): return "" % (self.name, self.type) @@ -413,57 +431,124 @@ class BoneBuilder(object): self.ik_list=[] def build(self, armatureObj): - if armatureObj: - armature=armatureObj.getData() - for b in armature.bones.values(): - if not b.parent: - # root bone - bone=Bone(b.name, b.head['ARMATURESPACE']) - self.__addBone(bone) - self.__getBone(bone, b) + if not armatureObj: + return + print("gather bones") + armature=armatureObj.getData() + for b in armature.bones.values(): + if b.name=='center': + # root bone + bone=Bone(b.name, + b.head['ARMATURESPACE'][0:3], + b.tail['ARMATURESPACE'][0:3]) + self.__addBone(bone) + self.__getBone(bone, b) + + for b in armature.bones.values(): + if not b.parent and b.name!='center': + # root bone + bone=Bone(b.name, + b.head['ARMATURESPACE'][0:3], + b.tail['ARMATURESPACE'][0:3]) + self.__addBone(bone) + self.__getBone(bone, b) + + print("check connection") + for b in armature.bones.values(): + if not b.parent: + self.__checkConnection(b, None) + + print("gather ik") pose = armatureObj.getPose() + cSetting=Blender.Constraint.Settings for b in pose.bones.values(): for c in b.constraints: if c.type==Blender.Constraint.Type.IKSOLVER: - # IK effector - e=b - for i in range(c[Blender.Constraint.Settings.CHAINLEN]): - # IK影響下 - self.__boneByName(e.name).type=4 - e=e.parent + #################### # IK target - assert(c[Blender.Constraint.Settings.TARGET]==armatureObj) - self.__boneByName( - c[Blender.Constraint.Settings.BONE]).type=2 + #################### + assert(c[cSetting.TARGET]==armatureObj) + target=self.__boneByName( + c[Blender.Constraint.Settings.BONE]) + target.type=2 + + #################### + # IK effector + #################### # IK 接続先 link=self.__boneByName(b.name) - link_tail=self.bones[link.tail_index] - if link_tail.type==7: - # IK接続先 - link_tail.type=6 - + link.type=6 + + # IK chain + e=b.parent + chainLength=c[cSetting.CHAINLEN] + for i in range(chainLength): + # IK影響下 + chainBone=self.__boneByName(e.name) + chainBone.type=4 + chainBone.ik_index=target.index + e=e.parent + self.ik_list.append( + IKSolver(target, link, chainLength, + int(c[cSetting.ITERATIONS] * 0.1), + c[cSetting.ROTWEIGHT] + )) + + def __checkConnection(self, b, p): + if Blender.Armature.CONNECTED in b.options: + parent=self.__boneByName(p.name) + parent.isConnect=True + + for c in b.children: + self.__checkConnection(c, b) + + def sortBy(self, boneMap): + """ + boneMap順に並べ替える + """ + original=self.bones[:] + def getIndex(bone): + for i, k_v in enumerate(boneMap): + if k_v[0]==bone.name: + return i + print(bone) + + self.bones.sort(lambda l, r: getIndex(l)-getIndex(r)) + sortMap={} + for i, b in enumerate(self.bones): + src=original.index(b) + sortMap[src]=i + for b in self.bones: + b.index=sortMap[b.index] + if b.parent_index: + b.parent_index=sortMap[b.parent_index] + if b.tail_index: + b.tail_index=sortMap[b.tail_index] + if b.ik_index>0: + b.ik_index=sortMap[b.ik_index] + + def getIndex(self, bone): + for i, b in enumerate(self.bones): + if b==bone: + return i + assert(false) + + def indexByName(self, name): + return self.getIndex(self.__boneByName(name)) def __boneByName(self, name): return self.bones[self.boneMap[name]] def __getBone(self, parent, b): - if not Blender.Armature.CONNECTED in b.options: - #print b, b.options - pass - if len(b.children)==0: - # 末端の非表示ボーン - bone=Bone(b.name+'_tail', b.tail['ARMATURESPACE']) - bone.type=7 - self.__addBone(bone) - assert(parent) - bone.parent_index=parent.index - parent.tail_index=bone.index + parent.type=7 return for i, c in enumerate(b.children): - bone=Bone(c.name, c.head['ARMATURESPACE']) + bone=Bone(c.name, + c.head['ARMATURESPACE'][0:3], + c.tail['ARMATURESPACE'][0:3]) self.__addBone(bone) if parent: bone.parent_index=parent.index @@ -479,6 +564,9 @@ class BoneBuilder(object): class PmdExporter(object): + def __init__(self): + self.armatureObj=None + def setup(self, scene): # 木構造を構築する object_node_map={} @@ -491,33 +579,49 @@ class PmdExporter(object): root=object_node_map[scene.objects.active] # ワンスキンメッシュを作る - self.oneSkinMesh=OneSkinMesh(root) + self.oneSkinMesh=OneSkinMesh() + self.__createOneSkinMesh(root) print(self.oneSkinMesh) self.name=root.o.name + # skeleton + self.builder=BoneBuilder() + self.builder.build(self.armatureObj) + self.builder.sortBy(englishmap.boneMap) + def getIndex(ik): + for i, v in enumerate(englishmap.boneMap): + if v[0]==ik.target.name: + return i + return len(englishmap.boneMap) + self.builder.ik_list.sort(lambda l, r: getIndex(l)-getIndex(r)) + + def __createOneSkinMesh(self, node): + ############################################################ + # search armature modifier + ############################################################ + for m in node.o.modifiers: + if m.name=="Armature": + armatureObj=m[Blender.Modifier.Settings.OBJECT] + if not self.armatureObj: + self.armatureObj=armatureObj + elif self.armatureObj!=armatureObj: + print "warning! found multiple armature. ignored.", armatureObj.name + + if node.o.getType()=='Mesh': + self.oneSkinMesh.addMesh(node.o) + + for child in node.children: + self.__createOneSkinMesh(child) + def write(self, path): + print('write') io=pmd.IO() io.name=self.name io.comment="blender export" io.version=1.0 - # bones - builder=BoneBuilder() - builder.build(self.oneSkinMesh.armatureObj) - for b in builder.bones: - bone=io.addBone() - bone.name=b.name - bone.type=b.type - bone.parent_index=b.parent_index if b.parent_index!=None else 0xFFFF - bone.tail_index=b.tail_index if b.tail_index!=None else 0 - # ToDo - bone.ik_index=0xFFFF - # convert right-handed z-up to left-handed y-up - bone.pos.x=b.pos[0] - bone.pos.y=b.pos[2] - bone.pos.z=b.pos[1] - # 頂点 + print('vertices') for pos, normal, uv, b0, b1, weight in self.oneSkinMesh.vertexArray.zip(): # convert right-handed z-up to left-handed y-up v=io.addVertex() @@ -529,12 +633,13 @@ class PmdExporter(object): v.normal.z=normal[1] v.uv.x=uv[0] v.uv.y=uv[1] - v.bone0=builder.boneMap[b0] if b0 in builder.boneMap else 0 - v.bone1=builder.boneMap[b1] if b1 in builder.boneMap else 0 + v.bone0=self.builder.boneMap[b0] if b0 in self.builder.boneMap else 0 + v.bone1=self.builder.boneMap[b1] if b1 in self.builder.boneMap else 0 v.weight0=int(100*weight) v.edge_flag=0 # edge flag, 0: enable edge, 1: not edge # 面とマテリアル + print('faces and materials') vertexCount=self.oneSkinMesh.getVertexCount() for m, indices in self.oneSkinMesh.vertexArray.indexArrays.items(): m=Blender.Material.Get(m) @@ -544,15 +649,16 @@ class PmdExporter(object): material.diffuse.g=m.G material.diffuse.b=m.B material.diffuse.a=m.alpha - material.sinness=m.spec + material.sinness=0 if m.spec<1e-5 else m.spec*10 material.specular.r=m.specR material.specular.g=m.specG material.specular.b=m.specB - material.ambient.r=m.amb - material.ambient.g=m.amb - material.ambient.b=m.amb + material.ambient.r=m.mirR + material.ambient.g=m.mirG + material.ambient.b=m.mirB material.vertex_count=len(indices) material.toon_index=0 + material.flag=1 if m.enableSSS else 0 # ToDo material.texture="" # 面 @@ -568,20 +674,187 @@ class PmdExporter(object): #io.indices.append(indices[i+1]) #io.indices.append(indices[i+2]) + # bones + print('bones') + for b in self.builder.bones: + if b.name.endswith("_t"): + if b.name.startswith("arm twist1_") or b.name.startswith("arm twist2_"): + # skip + print "skip %s" % b.name + continue + + bone=io.addBone() + + v=englishmap.getUnicodeBoneName(b.name) + assert(v) + cp932=v[1].encode('cp932') + bone_name="%s" % cp932 + assert(len(bone_name)<20) + bone.name=bone_name + + bone_english_name="%s" % b.name + assert(len(bone_english_name)<20) + bone.english_name=bone_english_name + + if len(v)>=3: + # has type + if v[2]==5: + b.ik_index=self.builder.indexByName('eyes') + bone.type=v[2] + else: + bone.type=b.type + + # parent index + bone.parent_index=b.parent_index if b.parent_index!=None else 0xFFFF + + # tail index + if b.tail_index!=None: + if bone.type==9: + bone.tail_index=0 + else: + bone.tail_index=b.tail_index + else: + bone.tail_index=0 + + bone.ik_index=b.ik_index + + # convert right-handed z-up to left-handed y-up + bone.pos.x=b.pos[0] if not near(b.pos[0], 0) else 0 + bone.pos.y=b.pos[2] if not near(b.pos[2], 0) else 0 + bone.pos.z=b.pos[1] if not near(b.pos[1], 0) else 0 + + # IK + print('ik') + for ik in self.builder.ik_list: + solver=io.addIK() + solver.index=self.builder.getIndex(ik.target) + solver.target=self.builder.getIndex(ik.effector) + solver.length=ik.length + b=self.builder.bones[ik.effector.parent_index] + for i in xrange(solver.length): + solver.children.append(self.builder.getIndex(b)) + b=self.builder.bones[b.parent_index] + solver.iterations=ik.iterations + solver.weight=ik.weight + # 表情 - for m in self.oneSkinMesh.morphList: + print('shape keys') + for i, m in enumerate(self.oneSkinMesh.morphList): # morph morph=io.addMorph() - morph.name=m.name - morph.type=m.type - for index, offset in zip(m.indices, m.offsets): + + v=englishmap.getUnicodeSkinName(m.name) + assert(v) + cp932=v[1].encode('cp932') + morph.name="%s\n" % cp932 + + morph.english_name="%s\n" % m.name + m.type=v[2] + morph.type=v[2] + for index, offset in m.offsets: # convert right-handed z-up to left-handed y-up morph.append(index, offset[0], offset[2], offset[1]) - morph.vertex_count=len(m.indices) + morph.vertex_count=len(m.offsets) + + # 表情枠 + print('display list') + # type==0はbase + for i, m in enumerate(self.oneSkinMesh.morphList): + if m.type==3: + io.face_list.append(i) + for i, m in enumerate(self.oneSkinMesh.morphList): + if m.type==2: + io.face_list.append(i) + for i, m in enumerate(self.oneSkinMesh.morphList): + if m.type==1: + io.face_list.append(i) + for i, m in enumerate(self.oneSkinMesh.morphList): + if m.type==4: + io.face_list.append(i) + + # ボーン表示枠 + print('bone display list') + def createBoneDisplayName(name, english): + boneDisplayName=io.addBoneDisplayName() + boneDisplayName.name=name.decode('utf-8').encode('cp932') + boneDisplayName.english_name=english + boneDisplayName=createBoneDisplayName("IK\n", "IK\n") + boneDisplayName=createBoneDisplayName("体(上)\n", "Body[u]\n") + boneDisplayName=createBoneDisplayName("髪\n", "Hair\n") + boneDisplayName=createBoneDisplayName("腕\n", "Arms\n") + boneDisplayName=createBoneDisplayName("指\n", "Fingers\n") + boneDisplayName=createBoneDisplayName("体(下)\n", "Body[l]\n") + boneDisplayName=createBoneDisplayName("足\n", "Legs\n") + for i, b in enumerate(self.builder.bones): + if i==0: + continue + if b.type in [6, 7]: + continue + io.addBoneDisplay(i, getBoneDisplayGroup(b)) + + # English + print('english') + io.english_name="blender export" + io.english_coment="blender export" + + for i in range(10): + io.getToonTexture(i).name="toon%02d.bmp\n" % i # 書き込み - return io.write(path.encode(FS_ENCODING)) - + return io.write(path) + + +def getBoneDisplayGroup(bone): + boneGroups=[ + [ # IK + "necktie IK", "hair IK_L", "hair IK_R", "leg IK_L", "leg IK_R", + "toe IK_L", "toe IK_R", + ], + [ # 体(上) + "upper body", "neck", "head", "eye_L", "eye_R", + "necktie1", "necktie2", "necktie3", "eyes", + "eyelight_L", "eyelight_R", + ], + [ # 髪 + "front hair1", "front hair2", "front hair3", + "hair1_L", "hair2_L", "hair3_L", + "hair4_L", "hair5_L", "hair6_L", + "hair1_R", "hair2_R", "hair3_R", + "hair4_R", "hair5_R", "hair6_R", + ], + [ # 腕 + "shoulder_L", "arm_L", "arm twist_L", "elbow_L", + "wrist twist_L", "wrist_L", "sleeve_L", + "shoulder_R", "arm_R", "arm twist_R", "elbow_R", + "wrist twist_R", "wrist_R", "sleeve_R", + ], + [ # 指 + "thumb1_L", "thumb2_L", "fore1_L", "fore2_L", "fore3_L", + "middle1_L", "middle2_L", "middle3_L", + "third1_L", "third2_L", "third3_L", + "little1_L", "little2_L", "little3_L", + "thumb1_R", "thumb2_R", "fore1_R", "fore2_R", "fore3_R", + "middle1_R", "middle2_R", "middle3_R", + "third1_R", "third2_R", "third3_R", + "little1_R", "little2_R", "little3_R", + ], + [ # 体(下) + "lower body", "waist accessory", + "front skirt_L", "back skirt_L", + "front skirt_R", "back skirt_R", + ], + [ # 足 + "leg_L", "knee_L", "ankle_L", + "leg_R", "knee_R", "ankle_R", + ], + ] + index=1 + for g in boneGroups: + if bone.name in g: + return index + index+=1 + print(bone) + return -1 def export_pmd(filename): filename=filename.decode(INTERNAL_ENCODING)