1.0 20100530: implement basic features.
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.
"""
MMD_SHAPE_GROUP_NAME='_MMD_SHAPE'
RIGID_ANGULAR_DAMPING='rigid_angular_damping'
RIGID_RESTITUTION='rigid_restitution'
RIGID_FRICTION='rigid_friction'
+CONSTRAINT_NAME='constraint_name'
CONSTRAINT_A='const_a'
CONSTRAINT_B='const_b'
CONSTRAINT_POS_MIN='const_pos_min'
# 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
+
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
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):
"""
頂点属性からその頂点のインデックスを得る
len(self.morphList))
def addMesh(self, obj):
- if bl.objectIsVisible(obj):
+ if bl.object.isVisible(obj):
# 非表示
return
self.__mesh(obj)
return
print("export", obj.name)
- mesh=bl.objectGetData(obj)
+ mesh=bl.object.getData(obj)
weightMap={}
secondWeightMap={}
def setWeight(i, name, w):
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:
secondWeightMap[i]=("", 0)
# メッシュのコピーを生成してオブジェクトの行列を適用する
- copyMesh, copyObj=bl.objectDuplicate(self.scene, obj)
+ copyMesh, copyObj=bl.object.duplicate(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)
+ faceVertexCount=bl.face.getVertexCount(face)
+ material=copyMesh.materials[bl.face.getMaterialIndex(face)]
+ v=[copyMesh.verts[index] for index in bl.face.getVertices(face)]
+ uv=bl.mesh.getFaceUV(copyMesh, i, 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)
+ bl.object.delete(copyObj)
self.obj_index+=1
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
return
print("gather bones")
- armature=bl.objectGetData(armatureObj)
+ armature=bl.object.getData(armatureObj)
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)
self.__checkConnection(b, None)
print("gather ik")
- pose = bl.objectGetPose(armatureObj)
+ pose = bl.object.getPose(armatureObj)
for b in pose.bones.values():
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.ik_list.sort(key=getIndex)
def __checkConnection(self, b, p):
- if bl.boneIsConnected(b):
+ if bl.bone.isConnected(b):
parent=self.__boneByName(p.name)
parent.isConnect=True
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
# 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:
# 面とマテリアル
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():
+ 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
# constraint
for obj in self.oneSkinMesh.constraints:
constraint=io.addConstraint()
- constraint.setName(obj.name[1:].encode('cp932'))
+ constraint.setName(obj[CONSTRAINT_NAME].encode('cp932'))
constraint.rigidA=rigidNameMap[obj[CONSTRAINT_A]]
constraint.rigidB=rigidNameMap[obj[CONSTRAINT_B]]
constraint.pos.x=obj.location[0]
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):