1.1 20100612: integrate 2.4 and 2.5.
1.2 20100616: implement rigid body.
1.3 20100619: fix rigid body, bone weight.
+1.4 20100626: refactoring.
+1.5 20100629: sphere map.
"""
MMD_SHAPE_GROUP_NAME='_MMD_SHAPE'
# wrapper
import bl24 as bl
+
+ def setMaterialParams(material, m):
+ # diffuse
+ material.diffuse.r=m.R
+ material.diffuse.g=m.G
+ material.diffuse.b=m.B
+ material.diffuse.a=m.alpha
+ # specular
+ 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
+ # ambient
+ material.ambient.r=m.mirR
+ material.ambient.g=m.mirG
+ material.ambient.b=m.mirB
+ # flag
+ material.flag=1 if m.enableSSS else 0
+
+ def toCP932(s):
+ return s
+
+
else:
# for 2.5
import bpy
xrange=range
+ def setMaterialParams(material, m):
+ # diffuse
+ material.diffuse.r=m.diffuse_color[0]
+ material.diffuse.g=m.diffuse_color[1]
+ material.diffuse.b=m.diffuse_color[2]
+ material.diffuse.a=m.alpha
+ # specular
+ material.sinness=0 if m.specular_toon_size<1e-5 else m.specular_hardness*10
+ material.specular.r=m.specular_color[0]
+ material.specular.g=m.specular_color[1]
+ material.specular.b=m.specular_color[2]
+ # ambient
+ material.ambient.r=m.mirror_color[0]
+ material.ambient.g=m.mirror_color[1]
+ material.ambient.b=m.mirror_color[2]
+ # flag
+ material.flag=1 if m.subsurface_scattering.enabled else 0
+ # toon
+ material.toon_index=7
+
+ def toCP932(s):
+ return s.encode('cp932')
+
class Node(object):
__slots__=['o', 'children']
self.vertices, self.normals, self.uvs,
self.b0, self.b1, self.weight)
+ def each(self):
+ keys=[key for key in self.indexArrays.keys()]
+ keys.sort()
+ for key in keys:
+ yield(key, self.indexArrays[key])
+
def __getIndex(self, obj, base_index, pos, normal, uv, b0, b1, weight0):
"""
頂点属性からその頂点のインデックスを得る
b1_0, b1_1, b1_2,
weight0, weight1, weight2
):
- if not material in self.indexArrays:
- self.indexArrays[material]=[]
-
index0=self.__getIndex(obj, base_index0, pos0, n0, uv0, b0_0, b1_0, weight0)
index1=self.__getIndex(obj, base_index1, pos1, n1, uv1, b0_1, b1_1, weight1)
index2=self.__getIndex(obj, base_index2, pos2, n2, uv2, b0_2, b1_2, weight2)
+ if not material in self.indexArrays:
+ self.indexArrays[material]=[]
self.indexArrays[material]+=[index0, index1, index2]
len(self.morphList))
def addMesh(self, obj):
- if bl.objectIsVisible(obj):
- # 非表示
+ if bl.object.isVisible(obj):
+ return
+ if not bl.modifier.hasType(obj, 'ARMATURE'):
return
self.__mesh(obj)
self.__skin(obj)
self.__rigidbody(obj)
self.__constraint(obj)
- def __mesh(self, obj):
- if isBlender24():
- pass
- else:
- if RIGID_SHAPE_TYPE in obj:
- return
- if CONSTRAINT_A in obj:
- return
-
- print("export", obj.name)
- mesh=bl.objectGetData(obj)
+ def __getWeightMap(self, obj, mesh):
+ # bone weight
weightMap={}
secondWeightMap={}
def setWeight(i, name, w):
if i in weightMap:
if i in secondWeightMap:
# 上位２つのweightを採用する
- if w<secondWeightMap[i]:
+ if w<secondWeightMap[i][1]:
pass
- elif w<weightMap[i]:
+ elif w<weightMap[i][1]:
# ２つ目を入れ替え
secondWeightMap[i]=(name, w)
else:
weightMap[i]=(name, w)
if isBlender24():
- for name in bl.meshVertexGroupNames(obj):
+ for name in bl.object.getVertexGroupNames(obj):
for i, w in mesh.getVertsFromGroup(name, 1):
setWeight(i, name, w)
else:
for i, v in enumerate(mesh.verts):
- for g in v.groups:
- setWeight(i, obj.vertex_groups[g.group].name, g.weight)
+ if len(v.groups)>0:
+ for g in v.groups:
+ setWeight(i, obj.vertex_groups[g.group].name, g.weight)
+ else:
+ setWeight(i, obj.vertex_groups[0].name, 1)
# 合計値が1になるようにする
for i in xrange(len(mesh.verts)):
weightMap[i]=("", 0)
secondWeightMap[i]=("", 0)
- # メッシュのコピーを生成してオブジェクトの行列を適用する
- copyMesh, copyObj=bl.objectDuplicate(self.scene, obj)
- if len(copyMesh.verts)==0:
- return
-
- for i, face in enumerate(copyMesh.faces):
- faceVertexCount=bl.faceVertexCount(face)
- material=copyMesh.materials[bl.faceMaterialIndex(face)]
- v=[copyMesh.verts[index] for index in bl.faceVertices(face)]
- uv=bl.meshFaceUv(copyMesh, i, face)
+ return weightMap, secondWeightMap
+
+ def __processFaces(self, mesh, weightMap, secondWeightMap):
+ # 各面の処理
+ for i, face in enumerate(mesh.faces):
+ faceVertexCount=bl.face.getVertexCount(face)
+ material=mesh.materials[bl.face.getMaterialIndex(face)]
+ v=[mesh.verts[index] for index in bl.face.getVertices(face)]
+ uv=bl.mesh.getFaceUV(
+ mesh, i, face, bl.face.getVertexCount(face))
+ # flip triangle
if faceVertexCount==3:
# triangle
self.vertexArray.addTriangle(
self.obj_index, material.name,
- v[0].index, v[1].index, v[2].index,
- v[0].co, v[1].co, v[2].co,
+ v[2].index,
+ v[1].index,
+ v[0].index,
+ v[2].co,
+ v[1].co,
+ v[0].co,
# ToDo vertex normal
#v0.no, v1.no, v2.no,
- bl.faceNormal(face),
- bl.faceNormal(face),
- bl.faceNormal(face),
- uv[0], uv[1], uv[2],
- weightMap[v[0].index][0],
- weightMap[v[1].index][0],
+ bl.face.getNormal(face),
+ bl.face.getNormal(face),
+ bl.face.getNormal(face),
+ uv[2],
+ uv[1],
+ uv[0],
weightMap[v[2].index][0],
- secondWeightMap[v[0].index][0],
- secondWeightMap[v[1].index][0],
+ weightMap[v[1].index][0],
+ weightMap[v[0].index][0],
secondWeightMap[v[2].index][0],
- weightMap[v[0].index][1],
+ secondWeightMap[v[1].index][0],
+ secondWeightMap[v[0].index][0],
+ weightMap[v[2].index][1],
weightMap[v[1].index][1],
- weightMap[v[2].index][1]
+ weightMap[v[0].index][1]
)
elif faceVertexCount==4:
# quadrangle
self.vertexArray.addTriangle(
self.obj_index, material.name,
- v[0].index, v[1].index, v[2].index,
- v[0].co, v[1].co, v[2].co,
+ v[2].index,
+ v[1].index,
+ v[0].index,
+ v[2].co,
+ v[1].co,
+ v[0].co,
#v0.no, v1.no, v2.no,
- bl.faceNormal(face),
- bl.faceNormal(face),
- bl.faceNormal(face),
- uv[0], uv[1], uv[2],
- weightMap[v[0].index][0],
- weightMap[v[1].index][0],
+ bl.face.getNormal(face),
+ bl.face.getNormal(face),
+ bl.face.getNormal(face),
+ uv[2],
+ uv[1],
+ uv[0],
weightMap[v[2].index][0],
- secondWeightMap[v[0].index][0],
- secondWeightMap[v[1].index][0],
+ weightMap[v[1].index][0],
+ weightMap[v[0].index][0],
secondWeightMap[v[2].index][0],
- weightMap[v[0].index][1],
+ secondWeightMap[v[1].index][0],
+ secondWeightMap[v[0].index][0],
+ weightMap[v[2].index][1],
weightMap[v[1].index][1],
- weightMap[v[2].index][1]
+ weightMap[v[0].index][1]
)
self.vertexArray.addTriangle(
self.obj_index, material.name,
- v[2].index, v[3].index, v[0].index,
- v[2].co, v[3].co, v[0].co,
+ v[0].index,
+ v[3].index,
+ v[2].index,
+ v[0].co,
+ v[3].co,
+ v[2].co,
#v2.no, v3.no, v0.no,
- bl.faceNormal(face),
- bl.faceNormal(face),
- bl.faceNormal(face),
- uv[2], uv[3], uv[0],
- weightMap[v[2].index][0],
- weightMap[v[3].index][0],
+ bl.face.getNormal(face),
+ bl.face.getNormal(face),
+ bl.face.getNormal(face),
+ uv[0],
+ uv[3],
+ uv[2],
weightMap[v[0].index][0],
- secondWeightMap[v[2].index][0],
- secondWeightMap[v[3].index][0],
+ weightMap[v[3].index][0],
+ weightMap[v[2].index][0],
secondWeightMap[v[0].index][0],
- weightMap[v[2].index][1],
+ secondWeightMap[v[3].index][0],
+ secondWeightMap[v[2].index][0],
+ weightMap[v[0].index][1],
weightMap[v[3].index][1],
- weightMap[v[0].index][1]
+ weightMap[v[2].index][1]
)
- bl.objectDelete(self.scene, copyObj)
+
+ def __mesh(self, obj):
+ if isBlender24():
+ pass
+ else:
+ if RIGID_SHAPE_TYPE in obj:
+ return
+ if CONSTRAINT_A in obj:
+ return
+
+ bl.message("export: %s" % obj.name)
+
+ # メッシュのコピーを生成してオブジェクトの行列を適用する
+ copyMesh, copyObj=bl.object.duplicate(obj)
+ if len(copyMesh.verts)==0:
+ return
+ # apply transform
+ copyObj.scale=obj.scale
+ bpy.ops.object.scale_apply()
+ copyObj.rotation_euler=obj.rotation_euler
+ bpy.ops.object.rotation_apply()
+ copyObj.location=obj.location
+ bpy.ops.object.location_apply()
+ # apply modifier
+ for m in [m for m in copyObj.modifiers]:
+ if m.type=='SOLIDFY':
+ continue
+ elif m.type=='ARMATURE':
+ continue
+ elif m.type=='MIRROR':
+ bpy.ops.object.modifier_apply(modifier=m.name)
+ else:
+ print(m.tpye)
+
+ weightMap, secondWeightMap=self.__getWeightMap(copyObj, copyMesh)
+ self.__processFaces(copyMesh, weightMap, secondWeightMap)
+
+ bl.object.delete(copyObj)
self.obj_index+=1
+ def createEmptyBasicSkin(self):
+ self.__getOrCreateMorph('base', 0)
+
def __skin(self, obj):
- if not bl.objectHasShapeKey(obj):
+ if not bl.object.hasShapeKey(obj):
return
indexRelativeMap={}
- blenderMesh=bl.objectGetData(obj)
+ blenderMesh=bl.object.getData(obj)
baseMorph=None
# shape keys
- vg=bl.meshVertexGroup(obj, MMD_SHAPE_GROUP_NAME)
+ vg=bl.object.getVertexGroup(obj, MMD_SHAPE_GROUP_NAME)
# base
used=set()
- for b in bl.objectShapeKeys(obj):
+ for b in bl.object.getShapeKeys(obj):
if b.name==BASE_SHAPE_NAME:
baseMorph=self.__getOrCreateMorph('base', 0)
basis=b
relativeIndex=0
for index in vg:
- v=bl.shapeKeyGet(b, index)
+ v=bl.shapekey.getByIndex(b, index)
pos=[v[0], v[1], v[2]]
indices=self.vertexArray.getMappedIndices(index)
for i in indices:
return
# shape keys
- for b in bl.objectShapeKeys(obj):
+ for b in bl.object.getShapeKeys(obj):
if b.name==BASE_SHAPE_NAME:
continue
used=set()
for index, src, dst in zip(
xrange(len(blenderMesh.verts)),
- bl.shapeKeys(basis),
- bl.shapeKeys(b)):
+ bl.shapekey.get(basis),
+ bl.shapekey.get(b)):
offset=[dst[0]-src[0], dst[1]-src[1], dst[2]-src[2]]
if offset[0]==0 and offset[1]==0 and offset[2]==0:
continue
if v[0]==morph.name:
return i
print(morph)
+ return len(englishmap.skinMap)
if isBlender24():
self.morphList.sort(lambda l, r: getIndex(l)-getIndex(r))
else:
return "<Bone %s %d>" % (self.name, self.type)
class BoneBuilder(object):
- __slots__=['bones', 'boneMap', 'ik_list', ]
+ __slots__=['bones', 'boneMap', 'ik_list', 'bone_groups',]
def __init__(self):
self.bones=[]
self.boneMap={}
self.ik_list=[]
+ self.bone_groups=[]
+
+ def getBoneGroup(self, bone):
+ for i, g in enumerate(self.bone_groups):
+ for b in g[1]:
+ if b==bone.name:
+ return i
+ print('no gorup', bone)
+ return 0
def build(self, armatureObj):
if not armatureObj:
return
- print("gather bones")
- armature=bl.objectGetData(armatureObj)
+ bl.message("build skeleton")
+ armature=bl.object.getData(armatureObj)
+
+ ####################
+ # bone group
+ ####################
+ for g in bl.object.boneGroups(armatureObj):
+ self.bone_groups.append((g.name, []))
+
+ ####################
+ # get bones
+ ####################
for b in armature.bones.values():
if b.name=='center':
# root bone
bone=Bone(b.name,
- bl.boneHeadLocal(b),
- bl.boneTailLocal(b))
+ bl.bone.getHeadLocal(b),
+ bl.bone.getTailLocal(b))
self.__addBone(bone)
self.__getBone(bone, b)
if not b.parent and b.name!='center':
# root bone
bone=Bone(b.name,
- bl.boneHeadLocal(b),
- bl.boneTailLocal(b))
+ bl.bone.getHeadLocal(b),
+ bl.bone.getTailLocal(b))
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 = bl.objectGetPose(armatureObj)
+ ####################
+ # get IK
+ ####################
+ pose = bl.object.getPose(armatureObj)
for b in pose.bones.values():
+ ####################
+ # assing bone group
+ ####################
+ self.__assignBoneGroup(b, b.bone_group)
for c in b.constraints:
- if bl.constraintIsIKSolver(c):
+ if bl.constraint.isIKSolver(c):
####################
# IK target
####################
- target=self.__boneByName(bl.ikTarget(c))
+ target=self.__boneByName(bl.constraint.ikTarget(c))
target.type=2
####################
# IK chain
e=b.parent
- chainLength=bl.ikChainLen(c)
+ chainLength=bl.constraint.ikChainLen(c)
for i in range(chainLength):
# IK影響下
chainBone=self.__boneByName(e.name)
e=e.parent
self.ik_list.append(
IKSolver(target, link, chainLength,
- int(bl.ikItration(c) * 0.1),
- bl.ikRotationWeight(c)
+ int(bl.constraint.ikItration(c) * 0.1),
+ bl.constraint.ikRotationWeight(c)
))
+ ####################
+
# boneのsort
self._sortBy()
self._fix()
else:
self.ik_list.sort(key=getIndex)
+ def __assignBoneGroup(self, poseBone, boneGroup):
+ if boneGroup:
+ for g in self.bone_groups:
+ if g[0]==boneGroup.name:
+ g[1].append(poseBone.name)
+
def __checkConnection(self, b, p):
- if bl.boneIsConnected(b):
+ if bl.bone.isConnected(b):
parent=self.__boneByName(p.name)
parent.isConnect=True
if k_v[0]==bone.name:
return i
print(bone)
+ return len(boneMap)
if isBlender24():
self.bones.sort(lambda l, r: getIndex(l)-getIndex(r))
for i, c in enumerate(b.children):
bone=Bone(c.name,
- bl.boneHeadLocal(c),
- bl.boneTailLocal(c))
+ bl.bone.getHeadLocal(c),
+ bl.bone.getTailLocal(c))
self.__addBone(bone)
if parent:
bone.parent_index=parent.index
# ワンスキンメッシュを作る
self.oneSkinMesh=OneSkinMesh(scene)
self.__createOneSkinMesh(root)
- print(self.oneSkinMesh)
+ bl.message(self.oneSkinMesh)
+ if len(self.oneSkinMesh.morphList)==0:
+ # create emtpy skin
+ self.oneSkinMesh.createEmptyBasicSkin()
+
self.name=root.o.name
# skeleton
- self.builder=BoneBuilder()
- self.builder.build(self.armatureObj)
+ self.skeleton=BoneBuilder()
+ self.skeleton.build(self.armatureObj)
def __createOneSkinMesh(self, node):
############################################################
# search armature modifier
############################################################
for m in node.o.modifiers:
- if bl.modifierIsArmature(m):
- armatureObj=bl.armatureModifierGetObject(m)
+ if bl.modifier.isType(m, 'ARMATURE'):
+ armatureObj=bl.modifier.getArmatureObject(m)
if not self.armatureObj:
self.armatureObj=armatureObj
elif self.armatureObj!=armatureObj:
v.normal.y=normal[2]
v.normal.z=normal[1]
v.uv.x=uv[0]
- v.uv.y=uv[1]
- v.bone0=self.builder.indexByName(b0)
- v.bone1=self.builder.indexByName(b1)
+ v.uv.y=1.0-uv[1] # reverse vertical
+ v.bone0=self.skeleton.indexByName(b0)
+ v.bone1=self.skeleton.indexByName(b1)
v.weight0=int(100*weight)
v.edge_flag=0 # edge flag, 0: enable edge, 1: not edge
# 面とマテリアル
vertexCount=self.oneSkinMesh.getVertexCount()
- for material_name, indices in self.oneSkinMesh.vertexArray.indexArrays.items():
- m=bl.materialGet(self.scene, material_name)
+ for material_name, indices in self.oneSkinMesh.vertexArray.each():
+ #print('material:', material_name)
+ m=bl.material.get(material_name)
# マテリアル
material=io.addMaterial()
- if isBlender24():
- material.diffuse.r=m.R
- material.diffuse.g=m.G
- material.diffuse.b=m.B
- material.diffuse.a=m.alpha
- 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.mirR
- material.ambient.g=m.mirG
- material.ambient.b=m.mirB
- material.flag=1 if m.enableSSS else 0
- else:
- material.diffuse.r=m.diffuse_color[0]
- material.diffuse.g=m.diffuse_color[1]
- material.diffuse.b=m.diffuse_color[2]
- material.diffuse.a=m.alpha
- material.sinness=0 if m.specular_hardness<1e-5 else m.specular_hardness*10
- material.specular.r=m.specular_color[0]
- material.specular.g=m.specular_color[1]
- material.specular.b=m.specular_color[2]
- material.ambient.r=m.mirror_color[0]
- material.ambient.g=m.mirror_color[1]
- material.ambient.b=m.mirror_color[2]
- material.flag=1 if m.subsurface_scattering.enabled else 0
+ setMaterialParams(material, m)
material.vertex_count=len(indices)
material.toon_index=0
- # ToDo
- material.texture=""
+ textures=[os.path.basename(path)
+ for path in bl.material.eachTexturePath(m)]
+ if len(textures)>0:
+ material.setTexture(toCP932('*'.join(textures)))
+ else:
+ material.setTexture(toCP932(""))
# 面
for i in indices:
assert(i<vertexCount)
# bones
boneNameMap={}
- for i, b in enumerate(self.builder.bones):
+ for i, b in enumerate(self.skeleton.bones):
bone=io.addBone()
# name
boneNameMap[b.name]=i
v=englishmap.getUnicodeBoneName(b.name)
+ if not v:
+ v=[b.name, b.name]
assert(v)
cp932=v[1].encode('cp932')
assert(len(cp932)<20)
bone.setName(cp932)
# english name
- bone_english_name=b.name
+ bone_english_name=toCP932(b.name)
assert(len(bone_english_name)<20)
- bone.english_name=bone_english_name
+ bone.setEnglishName(bone_english_name)
if len(v)>=3:
# has type
if v[2]==5:
- b.ik_index=self.builder.indexByName('eyes')
+ b.ik_index=self.skeleton.indexByName('eyes')
bone.type=v[2]
else:
bone.type=b.type
bone.pos.z=b.pos[1] if not near(b.pos[1], 0) else 0
# IK
- for ik in self.builder.ik_list:
+ for ik in self.skeleton.ik_list:
solver=io.addIK()
- solver.index=self.builder.getIndex(ik.target)
- solver.target=self.builder.getIndex(ik.effector)
+ solver.index=self.skeleton.getIndex(ik.target)
+ solver.target=self.skeleton.getIndex(ik.effector)
solver.length=ik.length
- b=self.builder.bones[ik.effector.parent_index]
+ b=self.skeleton.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.children.append(self.skeleton.getIndex(b))
+ b=self.skeleton.bones[b.parent_index]
solver.iterations=ik.iterations
solver.weight=ik.weight
morph=io.addMorph()
v=englishmap.getUnicodeSkinName(m.name)
+ if not v:
+ v=[m.name, m.name, 0]
assert(v)
cp932=v[1].encode('cp932')
morph.setName(cp932)
if m.type==4:
io.face_list.append(i)
- # ボーン表示枠
- def createBoneDisplayName(name, english):
- boneDisplayName=io.addBoneDisplayName()
- if isBlender24():
- boneDisplayName.name=name.decode('utf-8').encode('cp932')
- boneDisplayName.english_name=english
- else:
- boneDisplayName.setName(name.encode('cp932'))
- boneDisplayName.setEnglishName(english.encode('cp932'))
- 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):
+ # ボーングループ
+ for g in self.skeleton.bone_groups:
+ boneDisplayName=io.addBoneGroup()
+ # name
+ name=englishmap.getUnicodeBoneGroupName(g[0])
+ if not name:
+ name=g[0]
+ boneDisplayName.setName(toCP932(name+'\n'))
+ # english
+ englishName=g[0]
+ boneDisplayName.setEnglishName(toCP932(englishName+'\n'))
+
+ # ボーングループメンバー
+ for i, b in enumerate(self.skeleton.bones):
if i==0:
continue
if b.type in [6, 7]:
continue
- io.addBoneDisplay(i, getBoneDisplayGroup(b))
+ io.addBoneDisplay(i, self.skeleton.getBoneGroup(b))
# English
io.english_name="blender export"
boneIndex=boneNameMap[obj[RIGID_BONE_NAME]]
if boneIndex==0:
boneIndex=0xFFFF
- bone=self.builder.bones[0]
+ bone=self.skeleton.bones[0]
else:
- bone=self.builder.bones[boneIndex]
+ bone=self.skeleton.bones[boneIndex]
rigidBody.boneIndex=boneIndex
#rigidBody.position.x=obj[RIGID_LOCATION][0]
#rigidBody.position.y=obj[RIGID_LOCATION][1]
constraint.springRot.z=obj[CONSTRAINT_SPRING_ROT][2]
# 書き込み
- print('write', path)
+ bl.message('write %s' % path)
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 __execute(filename, scene):
if not scene.objects.active:
print("abort. no active object.")
return
- bl.progress_start('pmd_export')
- active=bl.objectGetActive(scene)
+ active=bl.object.getActive()
exporter=PmdExporter()
exporter.setup(scene)
exporter.write(filename)
- bl.objectActivate(scene, active)
- bl.progress_finish()
+ bl.object.activate(active)
if isBlender24():
# for 2.4
def execute_24(filename):
- filename=filename.decode(bl.INTERNAL_ENCODING)
- print("pmd exporter: %s" % filename)
-
- Blender.Window.WaitCursor(1)
- t = Blender.sys.time()
-
scene = bpy.data.scenes.active
- __execute(filename, scene)
-
- print('finished in %.2f seconds' % (Blender.sys.time()-t))
- Blender.Redraw()
- Blender.Window.WaitCursor(0)
+ bl.initialize('pmd_export', scene)
+ __execute(filename.decode(bl.INTERNAL_ENCODING), scene)
+ bl.finalize()
Blender.Window.FileSelector(
execute_24,
else:
# for 2.5
- def execute_25(*args):
- __execute(*args)
+ def execute_25(filename, scene):
+ bl.initialize('pmd_export', scene)
+ __execute(filename, scene)
+ bl.finalize()
# operator
class EXPORT_OT_pmd(bpy.types.Operator):
OSDN Git Service
