This script imports a pmd into Blender for editing.
-0.1: 20091126: first implement.
-0.2: 20091209: implement IK.
-0.3: 20091210: implement morph target.
-0.4: 20100305: use english name.
-0.5: 20100408: cleanup not used vertices.
-0.6: 20100416: fix fornt face. texture load fail safe. add progress.
-0.7: 20100506: C extension.
-0.8: 20100521: add shape_key group.
-1.0: 20100530: add invisilbe bone tail(armature layer 2).
-1.1: 20100608: integrate 2.4 and 2.5.
-1.2: 20100616: implement rigid body.
+0.1 20091126: first implement.
+0.2 20091209: implement IK.
+0.3 20091210: implement morph target.
+0.4 20100305: use english name.
+0.5 20100408: cleanup not used vertices.
+0.6 20100416: fix fornt face. texture load fail safe. add progress.
+0.7 20100506: C extension.
+0.8 20100521: add shape_key group.
+1.0 20100530: add invisilbe bone tail(armature layer 2).
+1.1 20100608: integrate 2.4 and 2.5.
+1.2 20100616: implement rigid body.
+1.3 20100619: fix for various models.
+1.4 20100623: fix constraint name.
+1.5 20100626: refactoring.
+1.6 20100629: sphere map.
"""
MMD_SHAPE_GROUP_NAME='_MMD_SHAPE'
RIGID_SHAPE_TYPE='rigid_shape_type'
RIGID_PROCESS_TYPE='rigid_process_type'
RIGID_BONE_NAME='rigid_bone_name'
-CONSTRAINT_A='constraint_a'
-CONSTRAINT_B='constraint_b'
+#RIGID_LOCATION='rigid_loation'
+RIGID_GROUP='ribid_group'
+RIGID_INTERSECTION_GROUP='rigid_intersection_group'
+RIGID_WEIGHT='rigid_weight'
+RIGID_LINEAR_DAMPING='rigid_linear_damping'
+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'
+CONSTRAINT_POS_MAX='const_pos_max'
+CONSTRAINT_ROT_MIN='const_rot_min'
+CONSTRAINT_ROT_MAX='const_rot_max'
+CONSTRAINT_SPRING_POS='const_spring_pos'
+CONSTRAINT_SPRING_ROT='const_spring_rot'
+
###############################################################################
# import
###############################################################################
import os
import sys
-import re
import math
# C extension
# wrapper
import bl24 as bl
+
+ def createPmdMaterial(m, index):
+ material=Blender.Material.New()
+ #material.setRef(1)
+ #material.diffuseSize = 3.14/2
+ #material.setDiffuseSmooth(0)
+ #material.setSpecSize(0)
+ #material.setSpec(0)
+ # shader
+ # diffuse
+ material.setDiffuseShader(Blender.Material.Shaders.DIFFUSE_TOON)
+ material.setRGBCol([m.diffuse.r, m.diffuse.g, m.diffuse.b])
+ material.setAlpha(m.diffuse.a)
+ # specular
+ material.setSpecShader(Blender.Material.Shaders.SPEC_TOON)
+ material.setSpec(m.shinness*0.1)
+ material.setSpecCol([m.specular.r, m.specular.g, m.specular.b])
+ # ambient
+ material.setMirCol([m.ambient.r, m.ambient.g, m.ambient.b])
+ # flag
+ material.enableSSS=True if m.flag==1 else False
+ # name
+ material.name="m_%02d" % index
+ return material
+
+ def poseBoneLimit(n, b):
+ if n.endswith("_t"):
+ return
+ if n.startswith("knee_"):
+ b.lockYRot=True
+ b.lockZRot=True
+ b.limitX=True
+ b.limitMin=[0, 0, 0]
+ b.limitMax=[180, 0, 0]
+ elif n.startswith("ankle_"):
+ b.lockYRot=True
+
+ def setSphereMap(material, index, blende_type=None):
+ pass
+
else:
# for 2.5
import bpy
xrange=range
-###############################################################################
-# progress bar
-###############################################################################
-def progress_start(base):
- global progressBar
- progressBar=bl.ProgressBar(base)
-
-def progress_finish():
- global progressBar
- progressBar.finish()
-
-def progress_print(message, progress=0.05):
- global progressBar
- progressBar.advance(message, progress)
-
-def progress_set(message, progress):
- global progressBar
- progressBar.set(message, progress)
+ def createPmdMaterial(m, index):
+ material = bpy.data.materials.new("Material")
+ # diffuse
+ material.diffuse_shader='FRESNEL'
+ material.diffuse_color=([m.diffuse.r, m.diffuse.g, m.diffuse.b])
+ material.alpha=m.diffuse.a
+ # specular
+ material.specular_shader='TOON'
+ material.specular_color=([m.specular.r, m.specular.g, m.specular.b])
+ material.specular_toon_size=int(m.shinness)
+ # ambient
+ material.mirror_color=([m.ambient.r, m.ambient.g, m.ambient.b])
+ # flag
+ material.subsurface_scattering.enabled=True if m.flag==1 else False
+ # other
+ material.name="m_%02d" % index
+ material.preview_render_type='FLAT'
+ material.transparency=True
+ return material
+
+ def poseBoneLimit(n, b):
+ if n.endswith("_t"):
+ return
+ if n.startswith("knee_"):
+ b.ik_dof_y=False
+ b.ik_dof_z=False
+ b.ik_dof_x=True
+ b.ik_limit_x=True
+ b.ik_min_x=0
+ b.ik_max_x=180
+ elif n.startswith("ankle_"):
+ #b.ik_dof_y=False
+ pass
+
+ def setSphereMap(material, index, blend_type=None):
+ slot=material.texture_slots[index]
+ slot.texture_coordinates='REFLECTION'
+ slot.mapping='SPHERE'
+ if blend_type:
+ slot.blend_type=blend_type
###############################################################################
+def VtoV(v):
+ return bl.createVector(v.x, v.y, v.z)
+
def convert_coord(pos):
"""
Left handed y-up to Right handed z-up
return (pos.x, pos.z, pos.y)
-def convert_uv(uv):
- return (uv.x, 1.0 - uv.y)
-
-
def to_radian(degree):
return math.pi * degree / 180
def get_bone_name(l, index):
- name=englishmap.getEnglishBoneName(l.bones[index].getName())
- return name if name else l.bones[index].getName()
+ if index==0xFFFF:
+ return l.bones[0].getName()
+
+ if index < len(l.bones):
+ name=englishmap.getEnglishBoneName(l.bones[index].getName())
+ if name:
+ return name
+ return l.bones[index].getName()
+ print('invalid bone index', index)
+ return l.bones[0].getName()
def __importShape(obj, l, vertex_map):
if len(l.morph_list)==0:
return
# set shape_key pin
- bl.objectPinShape(obj)
+ bl.object.pinShape(obj, True)
# find base
base=None
base=s
# create vertex group
- bl.meshAddVertexGroup(obj, MMD_SHAPE_GROUP_NAME)
+ bl.object.addVertexGroup(obj, MMD_SHAPE_GROUP_NAME)
hasShape=False
for i in s.indices:
if i in vertex_map:
hasShape=True
- bl.meshAssignVertexGroup(
+ bl.object.assignVertexGroup(
obj, MMD_SHAPE_GROUP_NAME, vertex_map[i], 0)
if not hasShape:
return
assert(base)
# create base key
- baseShapeBlock=bl.objectAddShapeKey(obj, BASE_SHAPE_NAME)
+ baseShapeBlock=bl.object.addShapeKey(obj, BASE_SHAPE_NAME)
# mesh
- mesh=bl.objectGetData(obj)
+ mesh=bl.object.getData(obj)
mesh.update()
# each skin
break
# create shapekey block
- new_shape_key=bl.objectAddShapeKey(obj, name)
+ new_shape_key=bl.object.addShapeKey(obj, name)
# copy vertex to shape key
mesh.update()
else:
# 25
- new_shape_key=bl.objectAddShapeKey(obj, name)
+ new_shape_key=bl.object.addShapeKey(obj, name)
for index, offset in zip(s.indices, s.pos_list):
try:
vertex_index=vertex_map[base.indices[index]]
- bl.shapeKeyAssign(new_shape_key, vertex_index,
+ bl.shapekey.assign(new_shape_key, vertex_index,
mesh.verts[vertex_index].co+
bl.createVector(*convert_coord(offset)))
except IndexError as msg:
break
# select base shape
- bl.objectActivateShapeKey(obj, 0)
+ bl.object.setActivateShapeKey(obj, 0)
def __build(armature, b, p, parent):
if not name:
name=b.getName()
- bone=bl.createArmatureBone(armature, name)
+ bone=bl.armature.createBone(armature, name)
- if b.tail_index==0:
- # 先端
- assert(b.type==6 or b.type==7)
+ if parent and (b.tail_index==0 or b.type==6 or b.type==7 or b.type==9):
bone.head = bl.createVector(*convert_coord(b.pos))
bone.tail=bone.head+bl.createVector(0, 1, 0)
- assert(parent)
bone.parent=parent
if bone.name=="center_t":
# センターボーンは(0, 1, 0)の方向を向いていないと具合が悪い
bone.head=parent.tail
bone.tail=bone.head+bl.createVector(0, 1, 0)
else:
- assert(parent.tail==bone.head)
- bl.boneSetConnected(bone)
+ if parent.tail==bone.head:
+ pass
+ else:
+ print('diffurence with parent.tail and head', name)
+
+ bl.bone.setConnected(bone)
# armature layer 2
- bl.boneLayerMask(bone, [0, 1])
+ bl.bone.setLayerMask(bone, [0, 1])
else:
+ # 通常ボーン
bone.head = bl.createVector(*convert_coord(b.pos))
bone.tail = bl.createVector(*convert_coord(b.tail))
if parent:
bone.parent=parent
if parent.tail==bone.head:
- bl.boneSetConnected(bone)
+ bl.bone.setConnected(bone)
if bone.head==bone.tail:
bone.tail=bone.head+bl.createVector(0, 1, 0)
def __importArmature(scene, l):
# build bone
- armature, armature_object=bl.createArmature(scene)
- bl.armatureMakeEditable(scene, armature_object)
+ armature, armature_object=bl.armature.create()
+ bl.armature.makeEditable(armature_object)
for b in l.bones:
if not b.parent:
__build(armature, b, None, None)
- bl.armatureUpdate(armature)
+ bl.armature.update(armature)
bl.exitEditMode()
# IK constraint
- pose = bl.objectGetPose(armature_object)
+ pose = bl.object.getPose(armature_object)
for ik in l.ik_list:
target=l.bones[ik.target]
name = englishmap.getEnglishBoneName(target.getName())
if not effector_name:
effector_name=l.bones[ik.index].getName()
- constraint=bl.createIkConstraint(armature_object,
+ constraint=bl.armature.createIkConstraint(armature_object,
p_bone, effector_name, ik)
- bl.armatureMakeEditable(scene, armature_object)
- bl.armatureUpdate(armature)
+ bl.armature.makeEditable(armature_object)
+ bl.armature.update(armature)
bl.exitEditMode()
return armature_object
def __import16MaerialAndMesh(meshObject, l,
material_order, face_map, tex_dir):
- mesh=bl.objectGetData(meshObject)
+ mesh=bl.object.getData(meshObject)
############################################################
# material
############################################################
- progress_print('create materials')
+ bl.progress_print('create materials')
mesh_material_map={}
textureMap={}
imageMap={}
except KeyError:
break
- material=bl.createPmdMaterial(m)
+ material=createPmdMaterial(m, material_index)
texture_name=m.getTexture()
if texture_name!='':
- if texture_name in textureMap:
- texture=textureMap[texture_name]
- else:
- try:
- texture, image=bl.createTexture(
- os.path.join(tex_dir, texture_name))
+ for i, t in enumerate(texture_name.split('*')):
+ if t in textureMap:
+ texture=textureMap[t]
+ else:
+ path=os.path.join(tex_dir, t)
+ texture, image=bl.texture.create(path)
textureMap[texture_name]=texture
imageMap[material_index]=image
- except:
- continue
- bl.materialAddTexture(material, texture)
- bl.meshAddMaterial(mesh, material)
+ bl.material.addTexture(material, texture)
+ if t.endswith('sph'):
+ # sphere map
+ setSphereMap(material, i)
+ elif t.endswith('spa'):
+ # sphere map
+ setSphereMap(material, i, 'ADD')
+
+ bl.mesh.addMaterial(mesh, material)
index+=1
############################################################
# vertex
############################################################
- progress_print('create vertices')
+ bl.progress_print('create vertices')
# create vertices
vertices=[]
- if isBlender24():
- for v in l.each_vertex():
- vertices.append(convert_coord(v.pos))
- else:
- for v in l.each_vertex():
- vertices.extend(convert_coord(v.pos))
+ for v in l.each_vertex():
+ vertices.append(convert_coord(v.pos))
############################################################
# face
############################################################
- progress_print('create faces')
+ bl.progress_print('create faces')
# create faces
mesh_face_indices=[]
mesh_face_materials=[]
i0=material_faces[j]
i1=material_faces[j+1]
i2=material_faces[j+2]
- if i2==0:
- triangle=[i2, i0, i1]
- else:
- triangle=[i0, i1, i2]
+ # flip
+ triangle=[i2, i1, i0]
if degenerate(*triangle):
continue
- if isBlender24():
- mesh_face_indices.append(triangle[0:3])
- else:
- mesh_face_indices.extend(
- [triangle[0], triangle[1], triangle[2], 0])
+ mesh_face_indices.append(triangle[0:3])
mesh_face_materials.append(material_index)
used_vertices.add(i0)
used_vertices.add(i1)
############################################################
# create vertices & faces
############################################################
- bl.meshCreateVerteicesAndFaces(mesh, vertices, mesh_face_indices)
+ bl.mesh.addGeometry(mesh, vertices, mesh_face_indices)
############################################################
# vertex bone weight
vertex_groups[v.bone0]=True
vertex_groups[v.bone1]=True
for i in vertex_groups.keys():
- bl.meshAddVertexGroup(meshObject, get_bone_name(l, i))
+ bl.object.addVertexGroup(meshObject, get_bone_name(l, i))
# vertex params
- bl.meshUseVertexUv(mesh)
+ bl.mesh.useVertexUV(mesh)
for i, v, mvert in zip(xrange(len(l.vertices)),
l.each_vertex(), mesh.verts):
# normal, uv
- bl.vertexSetNormal(mvert, convert_coord(v.normal))
- bl.vertexSetUv(mvert, convert_uv(v.uv))
+ bl.vertex.setNormal(mvert, convert_coord(v.normal))
# bone weight
w1=float(v.weight0)/100.0
w2=1.0-w1
- bl.meshAssignVertexGroup(meshObject, get_bone_name(l, v.bone0),
+ bl.object.assignVertexGroup(meshObject, get_bone_name(l, v.bone0),
i, w1)
- bl.meshAssignVertexGroup(meshObject, get_bone_name(l, v.bone1),
+ bl.object.assignVertexGroup(meshObject, get_bone_name(l, v.bone1),
i, w2)
############################################################
# face params
############################################################
used_map={}
- bl.meshAddUV(mesh)
+ bl.mesh.addUV(mesh)
+ for i, (face, material_index) in enumerate(
+ zip(mesh.faces, mesh_face_materials)):
+ try:
+ index=mesh_material_map[material_index]
+ except KeyError as message:
+ print(message, mesh_material_map, m)
+ assert(False)
+ bl.face.setMaterial(face, index)
+ material=mesh.materials[index]
+ used_map[index]=True
+ if bl.material.hasTexture(material):
+ uv_array=[l.getUV(i) for i in bl.face.getIndices(face)]
+ bl.mesh.setFaceUV(mesh, i, face,
+ # fix uv
+ [(uv.x, 1.0-uv.y) for uv in uv_array],
+ imageMap.get(index, None))
+
+ # set smooth
+ face.smooth = 1
- if isBlender24():
- for face, material_index in zip(mesh.faces, mesh_face_materials):
- try:
- index=mesh_material_map[material_index]
- except KeyError as message:
- print(message, mesh_material_map, m)
- assert(False)
- face.mat=index
- material=mesh.materials[index]
- texture=material.getTextures()[0]
- used_map[index]=True
- if texture:
- face.image=texture.tex.image
- texture.tex.imageFlags|=Blender.Texture.ImageFlags.USEALPHA
- face.uv=[
- face.verts[0].uvco, face.verts[1].uvco, face.verts[2].uvco]
- # set smooth
- face.smooth = 1
- # flip
- mesh.flipNormals()
- else:
- for face, uv_face, material_index in zip(mesh.faces,
- mesh.uv_textures[0].data,
- mesh_face_materials,
- ):
- try:
- index=mesh_material_map[material_index]
- except KeyError as message:
- print(message, mesh_material_map, m)
- assert(False)
- face.material_index=index
- material=mesh.materials[index]
- used_map[index]=True
- if material.texture_slots[0]:
- uv=l.getUV(face.verts[0])
- uv_face.uv1=[uv.x, 1.0-uv.y]
-
- uv=l.getUV(face.verts[1])
- uv_face.uv2=[uv.x, 1.0-uv.y]
-
- uv=l.getUV(face.verts[2])
- uv_face.uv3=[uv.x, 1.0-uv.y]
- if face.material_index in imageMap:
- uv_face.image=imageMap[face.material_index]
- uv_face.tex=True
-
- # set smooth
- face.smooth = 1
mesh.update()
############################################################
# clean up not used vertices
############################################################
- progress_print('clean up vertices not used')
+ bl.progress_print('clean up vertices not used')
remove_vertices=[]
vertex_map={}
for i, v in enumerate(l.each_vertex()):
else:
remove_vertices.append(i)
- bl.meshVertsDelete(mesh, remove_vertices)
+ bl.mesh.vertsDelete(mesh, remove_vertices)
- progress_print('%s created' % mesh.name)
+ bl.progress_print('%s created' % mesh.name)
return vertex_map
if io.indices[i] in shape_key_used_vertices:
return True
- # shapeキーで使われるマテリアルを記録する
- shape_key_materials=set()
+ material_with_shape=set()
+
# 各マテリアルの開始頂点インデックスを記録する
face_map={}
face_count=0
for i, m in enumerate(io.materials):
face_map[i]=face_count
if isMaterialUsedInShape(face_count, m):
- shape_key_materials.add(i)
+ material_with_shape.add(i)
face_count+=m.vertex_count
- # list化
- material_order=list(shape_key_materials)
+ # shapeキーで使われる頂点のあるマテリアル
+ material_with_shape=list(material_with_shape)
+ material_with_shape.sort()
- # shapeキーに使われていないマテリアルを後ろに追加
+ # shapeキーに使われていないマテリアル
+ material_without_shape=[]
for i in range(len(io.materials)):
- if not i in material_order:
- material_order.append(i)
-
- # マテリアル16個ごとに分割したメッシュを作成する
- material_offset=0
- mesh_objects=[]
- while material_offset<len(io.materials):
- mesh, meshObject=bl.createMesh(scene, 'mesh')
- # create object
- #meshObject.layers = [1]
- mesh_objects.append(meshObject)
+ if not i in material_with_shape:
+ material_without_shape.append(i)
+
+ # メッシュの生成
+ def __splitList(l, length):
+ for i in range(0, len(l), length):
+ yield l[i:i+length]
+
+ def __importMeshAndShape(material16, name):
+ mesh, meshObject=bl.mesh.create(name)
# activate object
- bl.objectDeselectAll()
- bl.objectActivate(scene, meshObject)
+ bl.object.deselectAll()
+ bl.object.activate(meshObject)
# shapeキーで使われる順に並べなおしたマテリアル16個分の
# メッシュを作成する
vertex_map=__import16MaerialAndMesh(
- meshObject, io,
- material_order[material_offset:material_offset+16],
- face_map, tex_dir)
-
- # enter Edit Mode
- #bl.enterEditMode()
+ meshObject, io, material16, face_map, tex_dir)
# crete shape key
__importShape(meshObject, io, vertex_map)
- # exit Edit Mode
- #bl.exitEditMode()
-
mesh.update()
- material_offset+=16
+ return meshObject
+ mesh_objects=[__importMeshAndShape(material16, 'with_shape')
+ for material16 in __splitList(material_with_shape, 16)]
+
+ mesh_objects+=[__importMeshAndShape(material16, 'mesh')
+ for material16 in __splitList(material_without_shape, 16)]
+
return mesh_objects
def __importConstraints(scene, io):
if isBlender24():
return
- print("create constrains")
- container=bl.createEmptyObject(scene, 'Constraints')
+ print("create constraint")
+ container=bl.object.createEmpty('Constraints')
layer=[
True, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
]
- material=bl.createMaterial('constraint')
+ material=bl.material.create('constraint')
material.diffuse_color=(1, 0, 0)
constraintMeshes=[]
- for c in io.constraints:
+ for i, c in enumerate(io.constraints):
bpy.ops.mesh.primitive_uv_sphere_add(
segments=8,
rings=4,
)
meshObject=scene.objects.active
constraintMeshes.append(meshObject)
- mesh=bl.objectGetData(meshObject)
- bl.meshAddMaterial(mesh, material)
- meshObject.name='c'+c.getName()
+ mesh=bl.object.getData(meshObject)
+ bl.mesh.addMaterial(mesh, material)
+ meshObject.name='c_%d' % i
#meshObject.draw_transparent=True
#meshObject.draw_wire=True
meshObject.max_draw_type='SOLID'
rot=c.rot
meshObject.rotation_euler=(-rot.x, -rot.z, -rot.y)
+ meshObject[CONSTRAINT_NAME]=c.getName()
meshObject[CONSTRAINT_A]=io.rigidbodies[c.rigidA].getName()
meshObject[CONSTRAINT_B]=io.rigidbodies[c.rigidB].getName()
+ meshObject[CONSTRAINT_POS_MIN]=VtoV(c.constraintPosMin)
+ meshObject[CONSTRAINT_POS_MAX]=VtoV(c.constraintPosMax)
+ meshObject[CONSTRAINT_ROT_MIN]=VtoV(c.constraintRotMin)
+ meshObject[CONSTRAINT_ROT_MAX]=VtoV(c.constraintRotMax)
+ meshObject[CONSTRAINT_SPRING_POS]=VtoV(c.springPos)
+ meshObject[CONSTRAINT_SPRING_ROT]=VtoV(c.springRot)
for meshObject in reversed(constraintMeshes):
- bl.objectMakeParent(container, meshObject)
+ bl.object.makeParent(container, meshObject)
return container
return
print("create rigid bodies")
- container=bl.createEmptyObject(scene, 'RigidBodies')
+ container=bl.object.createEmpty('RigidBodies')
layer=[
True, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
]
- material=bl.createMaterial('rigidBody')
+ material=bl.material.create('rigidBody')
rigidMeshes=[]
for rigid in io.rigidbodies:
if rigid.boneIndex==0xFFFF:
assert(False)
meshObject=scene.objects.active
- mesh=bl.objectGetData(meshObject)
+ mesh=bl.object.getData(meshObject)
rigidMeshes.append(meshObject)
- bl.meshAddMaterial(mesh, material)
+ bl.mesh.addMaterial(mesh, material)
meshObject.name=rigid.getName()
#meshObject.draw_transparent=True
#meshObject.draw_wire=True
bone_name=bone.getName()
meshObject[RIGID_BONE_NAME]=bone_name
+ meshObject[RIGID_GROUP]=rigid.group
+ meshObject[RIGID_INTERSECTION_GROUP]=rigid.target
+ meshObject[RIGID_WEIGHT]=rigid.weight
+ meshObject[RIGID_LINEAR_DAMPING]=rigid.linearDamping
+ meshObject[RIGID_ANGULAR_DAMPING]=rigid.angularDamping
+ meshObject[RIGID_RESTITUTION]=rigid.restitution
+ meshObject[RIGID_FRICTION]=rigid.friction
+
for meshObject in reversed(rigidMeshes):
- bl.objectMakeParent(container, meshObject)
+ bl.object.makeParent(container, meshObject)
return container
"""
load pmd file to context.
"""
+
# load pmd
- progress_set('load %s' % filename, 0.0)
+ bl.progress_set('load %s' % filename, 0.0)
io=pmd.IO()
if not io.read(filename):
- print("fail to load %s" % filename)
+ bl.message("fail to load %s" % filename)
return
- progress_set('loaded %s' % filename, 0.1)
+ bl.progress_set('loaded %s' % filename, 0.1)
# create root object
model_name=io.getEnglishName()
if len(model_name)==0:
model_name=io.getName()
- root=bl.createEmptyObject(scene, model_name)
+ root=bl.object.createEmpty(model_name)
# import mesh
mesh_objects=__importMesh(scene, io, os.path.dirname(filename))
for o in mesh_objects:
- bl.objectMakeParent(root, o)
+ bl.object.makeParent(root, o)
# import armature
armature_object=__importArmature(scene, io)
if armature_object:
- bl.objectMakeParent(root, armature_object)
- armature = bl.objectGetData(armature_object)
+ bl.object.makeParent(root, armature_object)
+ armature = bl.object.getData(armature_object)
# add armature modifier
for o in mesh_objects:
- bl.objectAddArmatureModifier(o, armature_object)
+ bl.modifier.addArmature(o, armature_object)
# Limitation
- for n, b in bl.objectGetPose(armature_object).bones.items():
- bl.poseBoneLimit(n, b)
+ for n, b in bl.object.getPose(armature_object).bones.items():
+ poseBoneLimit(n, b)
# import rigid bodies
rigidBodies=__importRigidBodies(scene, io)
if rigidBodies:
- bl.objectMakeParent(root, rigidBodies)
+ bl.object.makeParent(root, rigidBodies)
# import constraints
constraints=__importConstraints(scene, io)
if constraints:
- bl.objectMakeParent(root, constraints)
+ bl.object.makeParent(root, constraints)
+
+ bl.object.activate(root)
- # select objects
- bl.objectSelect(root)
- for o in mesh_objects:
- bl.objectSelect(o)
- bl.objectSelect(armature_object)
-
if isBlender24():
# for 2.4
def execute_24(filename):
- """
- @param filename
- """
- filename=filename.decode(bl.INTERNAL_ENCODING)
- print(bl.INTERNAL_ENCODING, bl.FS_ENCODING)
-
- # set object mode
- mode_edit = Blender.Window.EditMode()
- if mode_edit:
- Blender.Window.EditMode(0)
-
- progress_start('pmd_import')
- scene = bpy.data.scenes.active
- __execute(filename, scene)
- scene.update(0)
- progress_finish()
-
- # restore edit mode
- if mode_edit:
- Blender.Window.EditMode(1)
- Blender.Window.RedrawAll()
+ scene=bpy.data.scenes.active
+ bl.initialize('pmd_import', scene)
+ __execute(
+ filename.decode(bl.INTERNAL_ENCODING),
+ scene)
+ bl.finalize()
Blender.Window.FileSelector(
execute_24,
else:
# for 2.5
- def execute_25(*args):
- progress_start('pmd_import')
- __execute(*args)
- progress_finish()
+ def execute_25(filename, scene):
+ bl.initialize('pmd_import', scene)
+ __execute(filename, scene)
+ bl.finalize()
# import operator
class IMPORT_OT_pmd(bpy.types.Operator):
OSDN Git Service
