--- /dev/null
+bl_info = {
+ "name": "MMD pmd format (.pmd)/ Metasequioa mqo format (.mqo)",
+ "author": "ousttrue",
+ "blender": (2, 5, 7),
+ "api": 35622,
+ "location": "File > Import-Export",
+ "description": "Import-Export PMD/MQO meshes",
+ "warning": "",
+ "wiki_url": "",
+ "tracker_url": "",
+ "support": 'COMMUNITY',
+ "category": "Import-Export"
+}
+
+# To support reload properly, try to access a package var, if it's there, reload everything
+if "bpy" in locals():
+ import imp
+ if "import_pmd" in locals():
+ imp.reload(import_pmd)
+ if "export_pmd" in locals():
+ imp.reload(export_pmd)
+
+
+import bpy
+from bpy.props import StringProperty, FloatProperty, BoolProperty
+from io_utils import ImportHelper, ExportHelper
+from . import bl25 as bl
+
+
+'''
+PMD IMOPORTER
+'''
+class ImportPmd(bpy.types.Operator, ImportHelper):
+ '''Import from PMD file format (.pmd)'''
+ bl_idname = "import_scene.mmd_pmd"
+ bl_label = 'Import PMD'
+
+ filename_ext = ".pmd"
+ filter_glob = StringProperty(default="*.pmd", options={'HIDDEN'})
+
+ def execute(self, context):
+ from . import import_pmd
+ bl.initialize('pmd_import', context.scene)
+ import_pmd._execute(**self.as_keywords(
+ ignore=("filter_glob",)))
+ bl.finalize()
+ return {'FINISHED'}
+
+def menu_pmd_import(self, context):
+ self.layout.operator(ImportPmd.bl_idname,
+ text="MikuMikuDance model (.pmd)",
+ icon='PLUGIN'
+ )
+
+
+'''
+PMD EXPORTER
+'''
+class ExportPMD(bpy.types.Operator, ExportHelper):
+ '''Export to PMD file format (.pmd)'''
+ bl_idname = "export_scene.mmd_pmd"
+ bl_label = 'Export PMD'
+
+ filename_ext = ".pmd"
+ filter_glob = StringProperty(default="*.pmd", options={'HIDDEN'})
+
+ use_selection = BoolProperty(name="Selection Only", description="Export selected objects only", default=False)
+
+ def execute(self, context):
+ from . import export_pmd
+ export_pmd._execute(**self.as_keywords(
+ ignore=("check_existing", "filter_glob")))
+ return {'FINISHED'}
+
+def menu_pmd_export(self, context):
+ default_path=bpy.data.filepath.replace(".blend", ".pmd")
+ self.layout.operator(
+ ExportPMD.bl_idname,
+ text="Miku Miku Dance Model(.pmd)",
+ icon='PLUGIN'
+ ).filepath=default_path
+
+
+'''
+MQO IMPORTER
+'''
+class ImportMQO(bpy.types.Operator, ImportHelper):
+ '''Import from MQO file format (.mqo)'''
+ bl_idname = "import_scene.metasequioa_mqo"
+ bl_label = 'Import MQO'
+
+ filename_ext = ".mqo"
+ filter_glob = StringProperty(default="*.mqo", options={'HIDDEN'})
+
+ scale = bpy.props.FloatProperty(
+ name="Scale",
+ description="Scale the MQO by this value",
+ min=0.0001, max=1000000.0,
+ soft_min=0.001, soft_max=100.0, default=0.1)
+
+ def execute(self, context):
+ from . import import_mqo
+ bl.initialize('mqo_import', scene)
+ import_mqo._execute(**self.as_keywords(
+ ignore=("filter_glob",)))
+ bl.finalize()
+ return {'FINISHED'}
+
+def menu_mqo_import(self, context):
+ self.layout.operator(
+ ImportMQO.bl_idname,
+ text="Metasequoia (.mqo)",
+ icon='PLUGIN'
+ )
+
+
+'''
+MQO EXPORTER
+'''
+class ExportMQO(bpy.types.Operator, ExportHelper):
+ '''Save a Metasequoia MQO file.'''
+ bl_idname = "export_scene.metasequioa_mqo"
+ bl_label = 'Export MQO'
+
+ filename_ext = ".mqo"
+ filter_glob = StringProperty(default="*.mqo", options={'HIDDEN'})
+
+ use_selection = BoolProperty(name="Selection Only", description="Export selected objects only", default=False)
+
+ scale = bpy.props.FloatProperty(
+ name="Scale",
+ description="Scale the MQO by this value",
+ min=0.0001, max=1000000.0,
+ soft_min=0.001, soft_max=100.0, default=10.0)
+
+ apply_modifier = bpy.props.BoolProperty(
+ name="ApplyModifier",
+ description="Would apply modifiers",
+ default=False)
+
+ def execute(self, context):
+ from . import export_mqo
+ export_pmd._execute(**self.as_keywords(
+ ignore=("check_existing", "filter_glob")))
+ return {'FINISHED'}
+
+def menu_mqo_export(self, context):
+ default_path=bpy.data.filepath.replace(".blend", ".mqo")
+ self.layout.operator(
+ ExportMQO.bl_idname,
+ text="Metasequoia (.mqo)",
+ icon='PLUGIN'
+ ).filepath=default_path
+
+
+'''
+REGISTER
+'''
+def register():
+ bpy.utils.register_module(__name__)
+ bpy.types.INFO_MT_file_import.append(menu_pmd_import)
+ bpy.types.INFO_MT_file_export.append(menu_pmd_export)
+ bpy.types.INFO_MT_file_import.append(menu_mqo_import)
+ bpy.types.INFO_MT_file_export.append(menu_mqo_export)
+
+def unregister():
+ bpy.utils.unregister_module(__name__)
+ bpy.types.INFO_MT_file_import.remove(menu_pmd_import)
+ bpy.types.INFO_MT_file_export.remove(menu_pmd_export)
+ bpy.types.INFO_MT_file_import.remove(menu_mqo_import)
+ bpy.types.INFO_MT_file_export.remove(menu_mqo_export)
+
+if __name__ == "__main__":
+ register()
+
@staticmethod
def assignVertexGroup(o, name, index, weight):
- g=o.vertex_groups[name]
- o.vertex_groups.assign([index], g, weight, 'ADD')
+ o.vertex_groups[name].add([index], weight, 'ADD')
@staticmethod
def createBoneGroup(o, name, color_set='DEFAULT'):
texture.use_alpha=True
try:
image=bpy.data.images.load(path)
- except SystemError:
- image=bpy.data.images.new('Image')
+ except RuntimeError:
+ image=bpy.data.images.new('Image', width=16, height=16)
texture.image=image
return texture, image
bl.message('no active object !')
-if isBlender24():
- # for 2.4
- def execute_24(filename):
- scene=Blender.Scene.GetCurrent()
- bl.initialize('mqo_export', scene)
- __execute(
- filename.decode(bl.INTERNAL_ENCODING),
- scene, False)
- bl.finalize()
-
- # execute
- Blender.Window.FileSelector(
- execute_24,
- 'Export Metasequoia MQO',
- Blender.sys.makename(ext='.mqo'))
-
-else:
- # for 2.5
- def execute_25(path, scene, scale, apply_modifier):
- bl.initialize('mqo_export', scene)
- __execute(path, scene, scale, apply_modifier)
- bl.finalize()
-
- # operator
- class EXPORT_OT_mqo(bpy.types.Operator):
- '''Save a Metasequoia MQO file.'''
- bl_idname = "export_scene.mqo"
- bl_label = 'Export MQO'
-
- # List of operator properties, the attributes will be assigned
- # to the class instance from the operator settings before calling.
- filepath = bpy.props.StringProperty()
- filename = bpy.props.StringProperty()
- directory = bpy.props.StringProperty()
-
- scale = bpy.props.FloatProperty(
- name="Scale",
- description="Scale the MQO by this value",
- min=0.0001, max=1000000.0,
- soft_min=0.001, soft_max=100.0, default=10.0)
-
- apply_modifier = bpy.props.BoolProperty(
- name="ApplyModifier",
- description="Would apply modifiers",
- default=False)
-
- def execute(self, context):
- execute_25(
- self.properties.filepath,
- context.scene,
- self.properties.scale,
- self.properties.apply_modifier)
- return 'FINISHED'
-
- def invoke(self, context, event):
- wm=context.window_manager
- try:
- wm.fileselect_add(self)
- except:
- wm.add_fileselect(self)
- return 'RUNNING_MODAL'
-
- # register menu
- def menu_func(self, context):
- default_path=bpy.data.filepath.replace(".blend", ".mqo")
- self.layout.operator(
- EXPORT_OT_mqo.bl_idname,
- text="Metasequoia (.mqo)",
- icon='PLUGIN'
- ).filepath=default_path
-
- def register():
- bpy.types.INFO_MT_file_export.append(menu_func)
-
- def unregister():
- bpy.types.INFO_MT_file_export.remove(menu_func)
-
- if __name__ == "__main__":
- register()
-
return io.write(path)
-def __execute(filename):
+def _execute(filename):
+ bl.initialize('pmd_export', scene)
active=bl.object.getActive()
if not active:
print("abort. no active object.")
print(exporter)
exporter.write(filename)
bl.object.activate(active)
+ bl.finalize()
-if isBlender24():
- # for 2.4
- def execute_24(filename):
- bl.initialize('pmd_export', bpy.data.scenes.active)
- __execute(filename.decode(bl.INTERNAL_ENCODING))
- bl.finalize()
-
- Blender.Window.FileSelector(
- execute_24,
- 'Export Metasequoia PMD',
- Blender.sys.makename(ext='.pmd'))
-
-else:
- # for 2.5
- def execute_25(filename, scene):
- bl.initialize('pmd_export', scene)
- __execute(filename)
- bl.finalize()
-
- # operator
- class EXPORT_OT_pmd(bpy.types.Operator):
- '''Save a Metasequoia PMD file.'''
- bl_idname = "export_scene.pmd"
- bl_label = 'Export PMD'
-
- # List of operator properties, the attributes will be assigned
- # to the class instance from the operator settings before calling.
- filepath = bpy.props.StringProperty()
- filename = bpy.props.StringProperty()
- directory = bpy.props.StringProperty()
-
- def execute(self, context):
- execute_25(
- self.properties.filepath,
- context.scene
- )
- return 'FINISHED'
-
- def invoke(self, context, event):
- wm=context.window_manager
- try:
- wm.fileselect_add(self)
- except:
- wm.add_fileselect(self)
- return 'RUNNING_MODAL'
-
- # register menu
- def menu_func(self, context):
- default_path=bpy.data.filepath.replace(".blend", ".pmd")
- self.layout.operator(
- EXPORT_OT_pmd.bl_idname,
- text="Miku Miku Dance Model(.pmd)",
- icon='PLUGIN'
- ).filepath=default_path
-
- def register():
- bpy.types.INFO_MT_file_export.append(menu_func)
-
- def unregister():
- bpy.types.INFO_MT_file_export.remove(menu_func)
-
- if __name__ == "__main__":
- register()
-
# create bone weight\r
create_bone_weight(io, armature_object, objects)\r
\r
- \r
-###############################################################################\r
-# register\r
-###############################################################################\r
-if isBlender24():\r
- # for 2.4\r
- def execute_24(filename):\r
- scene=Blender.Scene.GetCurrent()\r
- bl.initialize('mqo_import', scene)\r
- __execute(\r
- filename.decode(bl.INTERNAL_ENCODING), \r
- scene)\r
- bl.finalize()\r
-\r
- # execute\r
- Blender.Window.FileSelector(execute_24, 'Import MQO', '*.mqo')\r
-\r
-else:\r
- # for 2.5\r
- def execute_25(filename, scene, scale):\r
- bl.initialize('mqo_import', scene)\r
- __execute(filename, scene, scale)\r
- bl.finalize()\r
-\r
- # operator\r
- class IMPORT_OT_mqo(bpy.types.Operator):\r
- '''Import from Metasequoia file format (.mqo)'''\r
- bl_idname = "import_scene.mqo"\r
- bl_label = 'Import MQO'\r
-\r
- # List of operator properties, the attributes will be assigned\r
- # to the class instance from the operator settings before calling.\r
- filepath = bpy.props.StringProperty()\r
- filename = bpy.props.StringProperty()\r
- directory = bpy.props.StringProperty()\r
-\r
- scale = bpy.props.FloatProperty(\r
- name="Scale", \r
- description="Scale the MQO by this value", \r
- min=0.0001, max=1000000.0, \r
- soft_min=0.001, soft_max=100.0, default=0.1)\r
-\r
- def execute(self, context):\r
- execute_25(\r
- self.properties.filepath, \r
- context.scene, \r
- self.properties.scale)\r
- return 'FINISHED'\r
-\r
- def invoke(self, context, event):\r
- wm=context.window_manager\r
- try:\r
- wm.fileselect_add(self)\r
- except:\r
- wm.add_fileselect(self)\r
- return 'RUNNING_MODAL'\r
-\r
-\r
- # register menu\r
- def menu_func(self, context): \r
- self.layout.operator(\r
- IMPORT_OT_mqo.bl_idname, \r
- text="Metasequoia (.mqo)",\r
- icon='PLUGIN'\r
- )\r
-\r
- def register():\r
- bpy.types.INFO_MT_file_import.append(menu_func)\r
-\r
- def unregister():\r
- bpy.types.INFO_MT_file_import.remove(menu_func)\r
-\r
- if __name__=="__main__":\r
- register()\r
\r
print('use meshio C module')
except ImportError:
# full python
- from pymeshio import englishmap
- from pymeshio import mmd as pmd
+ from .pymeshio import englishmap
+ from .pymeshio import mmd as pmd
pmd.IO=pmd.PMDLoader
-def isBlender24():
- return sys.version_info[0]<3
-
-if isBlender24():
- # for 2.4
- import Blender
- from Blender import Mathutils
- import bpy
-
- # wrapper
- import bl24 as bl
-
- def createPmdMaterial(m, index):
- material=Blender.Material.New()
- # fresnelが無いw
- 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, blend_type='MULTIPLY'):
- slot=material.textures[index]
- slot.mapto=Blender.Texture.MapTo.NOR
- slot.mapping=Blender.Texture.Mappings.SPHERE
- if blend_type=='MULTIPLY':
- slot.blendmode=Blender.Texture.BlendModes.MULTIPLY
- elif blend_type=='ADD':
- slot.blendmode=Blender.Texture.BlendModes.ADD
-
-else:
- # for 2.5
- import bpy
- import mathutils
-
- # wrapper
- import bl25 as bl
-
- xrange=range
-
- 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.use=True if m.flag==1 else False
- # other
- material.name="m_%02d" % index
- material.preview_render_type='FLAT'
- material.use_transparency=True
- return material
-
- def poseBoneLimit(n, b):
- if n.endswith("_t"):
- return
- if n.startswith("knee_"):
- b.lock_ik_y=True
- b.lock_ik_z=True
- b.lock_ik_x=False
- # IK limit
- b.use_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='MULTIPLY'):
- slot=material.texture_slots[index]
- slot.texture_coords='NORMAL'
- slot.mapping='SPHERE'
- slot.blend_type=blend_type
+# for 2.5
+import bpy
+import mathutils
+
+# wrapper
+from . import bl25 as bl
+
+xrange=range
+
+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.use=True if m.flag==1 else False
+ # other
+ material.name="m_%02d" % index
+ material.preview_render_type='FLAT'
+ material.use_transparency=True
+ return material
+
+def poseBoneLimit(n, b):
+ if n.endswith("_t"):
+ return
+ if n.startswith("knee_"):
+ b.lock_ik_y=True
+ b.lock_ik_z=True
+ b.lock_ik_x=False
+ # IK limit
+ b.use_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='MULTIPLY'):
+ slot=material.texture_slots[index]
+ slot.texture_coords='NORMAL'
+ slot.mapping='SPHERE'
+ slot.blend_type=blend_type
###############################################################################
# set shape_key pin
bl.object.pinShape(obj, True)
- # find base
+ # find base
base=None
for s in l.morph_list:
if s.type==0:
if not name:
name=s.getName()
- if isBlender24():
- # 24
- for index, offset in zip(s.indices, s.pos_list):
- try:
- vertex_index=vertex_map[base.indices[index]]
- v=mesh.vertices[vertex_index].co
- offset=convert_coord(offset)
- v[0]+=offset[0]
- v[1]+=offset[1]
- v[2]+=offset[2]
- except IndexError as msg:
- print(msg)
- print(index, len(base.indices), len(vertex_map))
- print(len(mesh.vertices))
- print(base.indices[index])
- print(vertex_index)
- break
- except KeyError:
- #print 'this mesh not has shape vertices'
- break
-
- # create shapekey block
- new_shape_key=bl.object.addShapeKey(obj, name)
-
- # copy vertex to shape key
- mesh.update()
-
- # restore
- for mv, v in zip(mesh.vertices, baseShapeBlock.getData()):
- mv.co[0] = v[0]
- mv.co[1] = v[1]
- mv.co[2] = v[2]
- mesh.update()
+ # 25
+ new_shape_key=bl.object.addShapeKey(obj, name)
- else:
- # 25
- 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.shapekey.assign(new_shape_key, vertex_index,
- mesh.vertices[vertex_index].co+
- bl.createVector(*convert_coord(offset)))
- except IndexError as msg:
- print(msg)
- print(index, len(base.indices), len(vertex_map))
- print(len(mesh.vertices))
- print(base.indices[index])
- print(vertex_index)
- break
- except KeyError:
- #print 'this mesh not has shape vertices'
- break
+ for index, offset in zip(s.indices, s.pos_list):
+ try:
+ vertex_index=vertex_map[base.indices[index]]
+ bl.shapekey.assign(new_shape_key, vertex_index,
+ mesh.vertices[vertex_index].co+
+ bl.createVector(*convert_coord(offset)))
+ except IndexError as msg:
+ print(msg)
+ print(index, len(base.indices), len(vertex_map))
+ print(len(mesh.vertices))
+ print(base.indices[index])
+ print(vertex_index)
+ break
+ except KeyError:
+ #print 'this mesh not has shape vertices'
+ break
# select base shape
bl.object.setActivateShapeKey(obj, 0)
if not effector_name:
effector_name=l.bones[ik.index].getName()
- constraint=bl.armature.createIkConstraint(armature_object,
+ constraint=bl.armature.createIkConstraint(armature_object,
p_bone, effector_name, ik)
bl.armature.makeEditable(armature_object)
bl.armature.update(armature)
bl.enterObjectMode()
- if isBlender24():
- pass
- else:
- # create bone group
- for i, g in enumerate(l.bone_group_list):
- name=get_group_name(g)
- bl.object.createBoneGroup(armature_object, name, "THEME%02d" % (i+1))
-
- # assign bone to group
- for b_index, g_index in l.bone_display_list:
- # bone
- b=l.bones[b_index]
- bone_name=englishmap.getEnglishBoneName(b.getName())
- if not bone_name:
- bone_name=b.getName()
- # group
- g=l.bone_group_list[g_index-1]
- group_name=get_group_name(g)
-
- # assign
- pose.bones[bone_name].bone_group=pose.bone_groups[group_name]
-
- bl.enterObjectMode()
+ # create bone group
+ for i, g in enumerate(l.bone_group_list):
+ name=get_group_name(g)
+ bl.object.createBoneGroup(armature_object, name, "THEME%02d" % (i+1))
+
+ # assign bone to group
+ for b_index, g_index in l.bone_display_list:
+ # bone
+ b=l.bones[b_index]
+ bone_name=englishmap.getEnglishBoneName(b.getName())
+ if not bone_name:
+ bone_name=b.getName()
+ # group
+ g=l.bone_group_list[g_index-1]
+ group_name=get_group_name(g)
+
+ # assign
+ pose.bones[bone_name].bone_group=pose.bone_groups[group_name]
+
+ bl.enterObjectMode()
return armature_object
-
-def __import16MaerialAndMesh(meshObject, l,
+
+def __import16MaerialAndMesh(meshObject, l,
material_order, face_map, tex_dir, toon_material):
mesh=bl.object.getData(meshObject)
# toon texture
toon_index=bl.material.addTexture(
- material,
+ material,
bl.material.getTexture(
- toon_material,
+ toon_material,
0 if m.toon_index==0xFF else m.toon_index
),
False)
# vertex params
bl.mesh.useVertexUV(mesh)
- for i, v, mvert in zip(xrange(len(l.vertices)),
+ for i, v, mvert in zip(xrange(len(l.vertices)),
l.each_vertex(), mesh.vertices):
# normal, uv
bl.vertex.setNormal(mvert, convert_coord(v.normal))
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,
+ bl.mesh.setFaceUV(mesh, i, face,
# fix uv
- [(uv.x, 1.0-uv.y) for uv in uv_array],
+ [(uv.x, 1.0-uv.y) for uv in uv_array],
imageMap.get(index, None))
# set smooth
# shapeキーで使われる頂点インデックスを集める
shape_key_used_vertices=set()
if len(io.morph_list)>0:
- # base
+ # base
base=None
for s in io.morph_list:
if s.type!=0:
# マテリアルに含まれる頂点がshape_keyに含まれるか否か？
def isMaterialUsedInShape(offset, m):
- for i in xrange(offset, offset+m.vertex_count):
+ for i in xrange(offset, offset+m.vertex_count):
if io.indices[i] in shape_key_used_vertices:
return True
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(io):
- if isBlender24():
- return
print("create constraint")
container=bl.object.createEmpty('Constraints')
layer=[
def __importRigidBodies(io):
- if isBlender24():
- return
print("create rigid bodies")
container=bl.object.createEmpty('RigidBodies')
return container
-def _execute(filename):
+def _execute(filepath=""):
"""
load pmd file to context.
"""
-
+
# load pmd
- bl.progress_set('load %s' % filename, 0.0)
+ bl.progress_set('load %s' % filepath, 0.0)
io=pmd.IO()
- if not io.read(filename):
- bl.message("fail to load %s" % filename)
+ if not io.read(filepath):
+ bl.message("fail to load %s" % filepath)
return
bl.progress_set('loaded', 0.1)
root[MMD_COMMENT]=io.getEnglishComment()
# toon textures
- tex_dir=os.path.dirname(filename)
+ tex_dir=os.path.dirname(filepath)
toonTextures, toonMaterial=__importToonTextures(io, tex_dir)
bl.object.makeParent(root, toonTextures)
armature_object=__importArmature(io)
if armature_object:
bl.object.makeParent(root, armature_object)
- armature = bl.object.getData(armature_object)
+ armature = bl.object.getData(armature_object)
# add armature modifier
for o in mesh_objects:
bl.object.activate(root)
-
-if isBlender24():
- # for 2.4
- def execute_24(filename):
- bl.initialize('pmd_import', bpy.data.scenes.active)
- _execute(filename.decode(bl.INTERNAL_ENCODING))
- bl.finalize()
-
- Blender.Window.FileSelector(
- execute_24,
- 'Import PMD file',
- Blender.sys.makename(ext='.pmd'))
-
-else:
- # import operator
- class IMPORT_OT_pmd(bpy.types.Operator):
- bl_idname = "import_scene.pmd"
- bl_label = 'Import PMD'
-
- # List of operator properties, the attributes will be assigned
- # to the class instance from the operator settings before calling.
- filepath = bpy.props.StringProperty()
- filename = bpy.props.StringProperty()
- directory = bpy.props.StringProperty()
-
- def execute(self, context):
- bl.initialize('pmd_import', context.scene)
- _execute(self.properties.filepath)
- bl.finalize()
- return 'FINISHED'
-
- def invoke(self, context, event):
- wm = context.window_manager
- try:
- wm.fileselect_add(self)
- except:
- wm.add_fileselect(self)
- return 'RUNNING_MODAL'
-
- # register menu
- def menu_func(self, context):
- self.layout.operator(IMPORT_OT_pmd.bl_idname,
- text="MikuMikuDance model (.pmd)",
- icon='PLUGIN'
- )
-
- def register():
- bpy.types.INFO_MT_file_import.append(menu_func)
-
- def unregister():
- bpy.types.INFO_MT_file_import.remove(menu_func)
-
- if __name__=="__main__":
- register()
-
OSDN Git Service
