X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=swig%2Fblender%2Fpmd_import.py;h=8b0463f763c9ef114dd4327c0cca40bd785611d3;hb=e3663cdfa9eba5b3809390cbc46516f50cb244bc;hp=7b97652f3ed218d66b385667d410d7ae35719256;hpb=7e199499cf7fade0fec8de0ca26d693d37d06a6d;p=meshio%2Fmeshio.git diff --git a/swig/blender/pmd_import.py b/swig/blender/pmd_import.py index 7b97652..8b0463f 100644 --- a/swig/blender/pmd_import.py +++ b/swig/blender/pmd_import.py @@ -27,6 +27,7 @@ This script imports a pmd into Blender for editing. """ MMD_SHAPE_GROUP_NAME='_MMD_SHAPE' +BASE_SHAPE_NAME='Basis' ############################################################################### @@ -82,325 +83,69 @@ def progress_set(message, progress): progressBar.set(message, progress) -if isBlender24(): - # functions - 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 get_bone_name(l, index): - name=englishmap.getEnglishBoneName(l.bones[index].getName()) - return name if name else l.bones[index].getName().encode(bl.INTERNAL_ENCODING) - - - def import16MaerialAndMesh(meshObject, l, - material_order, face_map, tex_dir): - mesh=bl.objectGetData(meshObject) - ############################################################ - # material - ############################################################ - progress_print('create materials') - mesh_material_map={} - textureMap={} - index=0 - for material_index in material_order: - try: - m=l.materials[material_index] - mesh_material_map[material_index]=index - except KeyError: - break - - material=bl.createPmdMaterial(m) - - texture_name=m.getTexture() - #tex_file=re.compile('\*.*.spa$').sub('', m.getTexture()) - #tex_path = os.path.join(tex_dir, tex_file).encode( - # bl.INTERNAL_ENCODING) - 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)) - textureMap[texture_name]=texture - imageMap[material_index]=image - except: - continue - bl.materialAddTexture(material, texture) - bl.meshAddMaterial(mesh, material) - index+=1 - - ############################################################ - # vertex - ############################################################ - progress_print('create vertices') - # create vertices - vertices=[] - for v in l.each_vertex(): - vertices.append(convert_coord(v.pos)) - mesh.verts.extend(vertices) +############################################################################### +def convert_coord(pos): + """ + Left handed y-up to Right handed z-up + """ + return (pos.x, pos.z, pos.y) - ############################################################ - # vertex bone weight - ############################################################ - # create vertex group - vertex_groups={} - for v in l.each_vertex(): - vertex_groups[v.bone0]=True - vertex_groups[v.bone1]=True - for i in vertex_groups.keys(): - mesh.addVertGroup(get_bone_name(l, i)) - - # vertex params - mesh.vertexUV = 1 - for i, v, mvert in zip(xrange(len(l.vertices)), l.each_vertex(), mesh.verts): - mvert.no=Mathutils.Vector(*convert_coord(v.normal)) - mvert.uvco=convert_uv(v.uv) - w1=float(v.weight0)/100.0 - w2=1.0-w1 - mesh.assignVertsToGroup(get_bone_name(l, v.bone0), [i], w1, - Blender.Mesh.AssignModes.ADD) - mesh.assignVertsToGroup(get_bone_name(l, v.bone1), [i], w2, - Blender.Mesh.AssignModes.ADD) - - ############################################################ - # face - ############################################################ - progress_print('create faces') - # create faces - mesh_face_indices=[] - mesh_face_materials=[] - used_vertices=set() - def degenerate(i0, i1, i2): - return i0==i1 or i1==i2 or i2==i0 +def convert_uv(uv): + return (uv.x, 1.0 - uv.y) - for material_index in material_order: - face_offset=face_map[material_index] - m=l.materials[material_index] - material_faces=l.indices[face_offset:face_offset+m.vertex_count] - for j in xrange(0, len(material_faces), 3): - i0=material_faces[j] - i1=material_faces[j+1] - i2=material_faces[j+2] - triangle=[i0, i1, i2] - if degenerate(*triangle): - continue - mesh_face_indices.append(triangle) - mesh_face_materials.append(material_index) - used_vertices.add(i0) - used_vertices.add(i1) - used_vertices.add(i2) - mesh.faces.extend(mesh_face_indices, ignoreDups=True) +def to_radian(degree): + return math.pi * degree / 180 - # face params - used_map={} - mesh.addUVLayer('NewUV') - 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() - - ############################################################ - # clean up not used vertices - ############################################################ - progress_print('clean up vertices not used') - remove_vertices=[] - vertex_map={} - for i, v in enumerate(l.each_vertex()): - if i in used_vertices: - vertex_map[i]=len(vertex_map) - else: - remove_vertices.append(i) - mesh.verts.delete(remove_vertices) - - progress_print('%s created' % mesh.name) - return vertex_map - - - class Builder(object): - def __init__(self): - self.boneMap={} - - def build(self, armature, bones): - for b in bones: - if not b.parent: - self.__build(armature, b, None, None) - armature.update() - - def __build(self, armature, b, p, parent): - name=englishmap.getEnglishBoneName(b.getName()) - if not name: - name=b.getName().encode(bl.INTERNAL_ENCODING) - self.boneMap[name]=b - - bone=Blender.Armature.Editbone() - bone.name=name - armature.bones[name]=bone - - if b.tail_index==0: - # 先端 - assert(b.type==6 or b.type==7) - bone.head = Mathutils.Vector(*convert_coord(b.pos)) - bone.tail=bone.head+Mathutils.Vector(0, 1, 0) - assert(parent) - bone.parent=parent - if bone.name=="center_t": - # センターボーンは(0, 1, 0)の方向を向いていないと具合が悪い - parent.tail=parent.head+Mathutils.Vector(0, 1, 0) - bone.head=parent.tail - bone.tail=bone.head+Mathutils.Vector(0, 1, 0) - else: - assert(parent.tail==bone.head) - bone.options=[Blender.Armature.CONNECTED] - # armature layer 2 - bone.layerMask = (1<<1) - else: - bone.head = Mathutils.Vector(*convert_coord(b.pos)) - bone.tail = Mathutils.Vector(*convert_coord(b.tail)) - if parent: - bone.parent=parent - if parent.tail==bone.head: - bone.options=[Blender.Armature.CONNECTED] - - if bone.head==bone.tail: - bone.tail=bone.head+Mathutils.Vector(0, 1, 0) - - for c in b.children: - self.__build(armature, c, b, bone) - - - def importArmature(scene, l): - # create armature - armature = Blender.Armature.New() - # link to object - armature_object = scene.objects.new(armature) - # create action - act = Blender.Armature.NLA.NewAction() - act.setActive(armature_object) - # set XRAY - armature_object.drawMode = ( - armature_object.drawMode | Blender.Object.DrawModes.XRAY) - # armature settings - armature.drawType = Blender.Armature.OCTAHEDRON - armature.drawNames=True - armature.envelopes = False - armature.vertexGroups = True - armature.mirrorEdit = True - - # create armature - armature.makeEditable() - - ############################################################ - # build bone - ############################################################ - builder=Builder() - builder.build(armature, l.bones) - - ############################################################ - # IK - ############################################################ - pose = armature_object.getPose() - cSetting = Blender.Constraint.Settings - for ik in l.ik_list: - # IKtarget->parent(=IK).name - target=l.bones[ik.target] - name = englishmap.getEnglishBoneName(target.getName()) - p_bone = pose.bones[name] - if not p_bone: - print('not found', name) - continue - if len(ik.children) >= 16: - print('over MAX_CHAINLEN', ik, len(ik.children)) - continue - # IK solver - ik_solver = p_bone.constraints.append(Blender.Constraint.Type.IKSOLVER) - ik_solver[cSetting.CHAINLEN]=len(ik.children) - ik_solver[cSetting.TARGET]=armature_object - ik_solver[cSetting.USETIP]=False - - effector_name=englishmap.getEnglishBoneName( - l.bones[ik.index].getName()) - if not effector_name: - effector_name=l.bones[ik.index].getName() - - ik_solver[cSetting.BONE]=effector_name - #ik_solver.influence=ik.weight - # not used. place folder when export. - ik_solver[cSetting.ROTWEIGHT]=ik.weight - ik_solver[cSetting.ITERATIONS]=ik.iterations * 10 - - armature.makeEditable() - armature.update() - - return armature_object - - def importShape(obj, l, vertex_map): - if len(l.morph_list)==0: - return - obj.pinShape=True - mesh=obj.getData(mesh=True) +def get_bone_name(l, index): + name=englishmap.getEnglishBoneName(l.bones[index].getName()) + return name if name else l.bones[index].getName() - # find base - base=None - for s in l.morph_list: - if s.type==0: - base=s - - # create vertex group - mesh.addVertGroup(MMD_SHAPE_GROUP_NAME) - indices=[] - hasShape=False - for i in s.indices: - if i in vertex_map: - hasShape=True - indices.append(vertex_map[i]) - mesh.assignVertsToGroup(MMD_SHAPE_GROUP_NAME, indices, 0, - Blender.Mesh.AssignModes.ADD) - if not hasShape: - return - - # create base key - mesh.insertKey() - assert(len(mesh.key.blocks)==1) - baseShapeIndex=0 - baseShapeBlock=mesh.key.blocks[baseShapeIndex] - baseShapeBlock.name='Basis' - obj.activeShape=baseShapeIndex - mesh.update() - break +def __importShape(obj, l, vertex_map): + if len(l.morph_list)==0: + return - assert(base) + # set shape_key pin + bl.objectPinShape(obj) - # each skin - for s in l.morph_list: - if s.name==base.name: - continue + # find base + base=None + for s in l.morph_list: + if s.type==0: + base=s + # create vertex group + bl.meshAddVertexGroup(obj, MMD_SHAPE_GROUP_NAME) + hasShape=False + for i in s.indices: + if i in vertex_map: + hasShape=True + bl.meshAssignVertexGroup( + 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) + # mesh + mesh=bl.objectGetData(obj) + mesh.update() + + # each skin + for s in l.morph_list: + if s.type==0: + continue + + # name + name=englishmap.getEnglishSkinName(s.getName()) + 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]] @@ -409,7 +154,7 @@ if isBlender24(): v[0]+=offset[0] v[1]+=offset[1] v[2]+=offset[2] - except IndexErrora as msg: + except IndexError as msg: print(msg) print(index, len(base.indices), len(vertex_map)) print(len(mesh.verts)) @@ -420,17 +165,8 @@ if isBlender24(): #print 'this mesh not has shape vertices' break - # get skin name - name=englishmap.getEnglishSkinName(s.getName()) - if not name: - name=s.getName().encode(bl.INTERNAL_ENCODING) - print(name) - # create shapekey block - mesh.insertKey() - shapeIndex=len(mesh.key.blocks)-1 - keyBlock=mesh.key.blocks[shapeIndex] - keyBlock.name=name + new_shape_key=bl.objectAddShapeKey(obj, name) # copy vertex to shape key mesh.update() @@ -442,152 +178,258 @@ if isBlender24(): mv.co[2] = v[2] mesh.update() - # select base shape - obj.activeShape=baseShapeIndex + else: + # 25 + new_shape_key=bl.objectAddShapeKey(obj, name) -else: - # for 2.5 - def to_radian(degree): - return math.pi * degree / 180 + 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, + mesh.verts[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.verts)) + print(base.indices[index]) + print(vertex_index) + break + except KeyError: + #print 'this mesh not has shape vertices' + break + # select base shape + bl.objectActivateShapeKey(obj, 0) + + +def __build(armature, b, p, parent): + name=englishmap.getEnglishBoneName(b.getName()) + if not name: + name=b.getName() + + bone=bl.createArmatureBone(armature, name) + + if b.tail_index==0: + # 先端 + assert(b.type==6 or b.type==7) + 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)の方向を向いていないと具合が悪い + parent.tail=parent.head+bl.createVector(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) + # armature layer 2 + bl.boneLayerMask(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) + + if bone.head==bone.tail: + bone.tail=bone.head+bl.createVector(0, 1, 0) + + for c in b.children: + __build(armature, c, b, bone) + + +def __importArmature(scene, l): + # build bone + armature, armature_object=bl.createArmature(scene) + bl.armatureMakeEditable(scene, armature_object) + for b in l.bones: + if not b.parent: + __build(armature, b, None, None) + bl.armatureUpdate(armature) + bl.exitEditMode() + + # IK constraint + pose = bl.objectGetPose(armature_object) + for ik in l.ik_list: + target=l.bones[ik.target] + name = englishmap.getEnglishBoneName(target.getName()) + if not name: + name=target.getName() + p_bone = pose.bones[name] + if not p_bone: + print('not found', name) + continue + if len(ik.children) >= 16: + print('over MAX_CHAINLEN', ik, len(ik.children)) + continue + effector_name=englishmap.getEnglishBoneName( + l.bones[ik.index].getName()) + if not effector_name: + effector_name=l.bones[ik.index].getName() + + constraint=bl.createIkConstraint(armature_object, + p_bone, effector_name, ik) + + bl.armatureMakeEditable(scene, armature_object) + bl.armatureUpdate(armature) + bl.exitEditMode() + + return armature_object + - 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 getBoneName(bone): - name = englishmap.getEnglishBoneName(bone.getName()) - return name if name else bone.getName() - - - def create_texture(directory, texture_name): - texture=bpy.data.textures.new(texture_name) - texture.type='IMAGE' - texture=texture.recast_type() - texturePath=os.path.join(directory, texture_name) - print('create_texture', texturePath) - image=bpy.data.images.load(texturePath) - texture.image=image - texture.mipmap = True - texture.interpolation = True - texture.use_alpha = True - return texture - - - def import16MaerialAndMesh(meshObject, l, - material_order, face_map, tex_dir): - mesh=bl.objectGetData(meshObject) - ############################################################ - # material - ############################################################ - #progress_print('create materials') - mesh_material_map={} - textureMap={} - imageMap={} - index=0 - for material_index in material_order: - try: - m=l.materials[material_index] - mesh_material_map[material_index]=index - except KeyError: - break - - material=bl.createPmdMaterial(m) - - texture_name=m.getTexture() - if texture_name!='': - if texture_name in textureMap: - texture=textureMap[texture_name] - else: +def __import16MaerialAndMesh(meshObject, l, + material_order, face_map, tex_dir): + + mesh=bl.objectGetData(meshObject) + ############################################################ + # material + ############################################################ + progress_print('create materials') + mesh_material_map={} + textureMap={} + imageMap={} + index=0 + + for material_index in material_order: + try: + m=l.materials[material_index] + mesh_material_map[material_index]=index + except KeyError: + break + + material=bl.createPmdMaterial(m) + + 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)) textureMap[texture_name]=texture imageMap[material_index]=image - bl.materialAddTexture(material, texture) - bl.meshAddMaterial(mesh, material) - index+=1 - - ############################################################ - # vertex - ############################################################ - #progress_print('create vertices') - # create vertices - unpackedVertices=[] + except: + continue + bl.materialAddTexture(material, texture) + bl.meshAddMaterial(mesh, material) + index+=1 + + ############################################################ + # vertex + ############################################################ + progress_print('create vertices') + # create vertices + vertices=[] + if isBlender24(): for v in l.each_vertex(): - unpackedVertices.extend( - convert_coord(v.pos)) - - ############################################################ - # vertex bone weight - ############################################################ - # create vertex group - vertex_groups={} + vertices.append(convert_coord(v.pos)) + else: for v in l.each_vertex(): - vertex_groups[v.bone0]=True - vertex_groups[v.bone1]=True - for i in vertex_groups.keys(): - meshObject.add_vertex_group(getBoneName(l.bones[i])) - - # vertex params - for i, v, mvert in zip(range(len(l.vertices)), - l.each_vertex(), mesh.verts): - mvert.normal=mathutils.Vector(convert_coord(v.normal)) - #mvert.uvco=convert_uv(v.uv) - w1=float(v.weight0)/100.0 - w2=1.0-w1 - - meshObject.add_vertex_to_group(i, - meshObject.vertex_groups[getBoneName(l.bones[v.bone0])], w1, 'ADD') - meshObject.add_vertex_to_group(i, - meshObject.vertex_groups[getBoneName(l.bones[v.bone1])], w2, 'ADD') - ############################################################ - # face - ############################################################ - #progress_print('create faces') - # create faces - mesh_face_indices=[] - mesh_face_materials=[] - used_vertices=set() - - for material_index in material_order: - face_offset=face_map[material_index] - m=l.materials[material_index] - material_faces=l.indices[face_offset:face_offset+m.vertex_count] - for j in range(0, len(material_faces), 3): - i0=material_faces[j] - i1=material_faces[j+1] - i2=material_faces[j+2] - if i2==0: - mesh_face_indices.extend([i2, i0, i1, 0]) - else: - mesh_face_indices.extend([i0, i1, i2, 0]) - mesh_face_materials.append(material_index) - used_vertices.add(i0) - used_vertices.add(i1) - used_vertices.add(i2) - - ############################################################ - # create vertices & faces - ############################################################ - mesh.add_geometry( - int(len(unpackedVertices)/3), 0, int(len(mesh_face_indices)/4)) - mesh.verts.foreach_set("co", unpackedVertices) - mesh.faces.foreach_set("verts_raw", mesh_face_indices) - assert(len(l.vertices)==len(mesh.verts)) - - ############################################################ - # face params - ############################################################ - used_map={} - mesh.add_uv_texture() + vertices.extend(convert_coord(v.pos)) + + ############################################################ + # face + ############################################################ + progress_print('create faces') + # create faces + mesh_face_indices=[] + mesh_face_materials=[] + used_vertices=set() + + for material_index in material_order: + face_offset=face_map[material_index] + m=l.materials[material_index] + material_faces=l.indices[face_offset:face_offset+m.vertex_count] + def degenerate(i0, i1, i2): + """ + 縮退しているか？ + """ + return i0==i1 or i1==i2 or i2==i0 + + for j in xrange(0, len(material_faces), 3): + 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] + 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_materials.append(material_index) + used_vertices.add(i0) + used_vertices.add(i1) + used_vertices.add(i2) + + ############################################################ + # create vertices & faces + ############################################################ + bl.meshCreateVerteicesAndFaces(mesh, vertices, mesh_face_indices) + + ############################################################ + # vertex bone weight + ############################################################ + # create vertex group + vertex_groups={} + for v in l.each_vertex(): + vertex_groups[v.bone0]=True + vertex_groups[v.bone1]=True + for i in vertex_groups.keys(): + bl.meshAddVertexGroup(meshObject, get_bone_name(l, i)) + + # vertex params + bl.meshUseVertexUv(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)) + # bone weight + w1=float(v.weight0)/100.0 + w2=1.0-w1 + bl.meshAssignVertexGroup(meshObject, get_bone_name(l, v.bone0), + i, w1) + bl.meshAssignVertexGroup(meshObject, get_bone_name(l, v.bone1), + i, w2) + + ############################################################ + # face params + ############################################################ + used_map={} + bl.meshAddUV(mesh) + + 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, @@ -601,9 +443,6 @@ else: material=mesh.materials[index] used_map[index]=True if material.texture_slots[0]: - #texture=material.texture_slots[0].texture - #face.image=texture.image - #texture.imageFlags|=Blender.Texture.ImageFlags.USEALPHA uv=l.getUV(face.verts[0]) uv_face.uv1=[uv.x, 1.0-uv.y] @@ -618,164 +457,26 @@ else: # set smooth face.smooth = 1 + mesh.update() - mesh.update() - - #progress_print('%s created' % mesh.name) - return meshObject, used_vertices - - - def build_bone(armature, b, parent=None): - if b.tail_index==0: - return - - name=getBoneName(b) - bone = armature.edit_bones.new(name if name else b.getName()) - if parent: - bone.head = mathutils.Vector(convert_coord(b.pos)) - bone.parent=parent - bone.connected=True if parent.tail==bone.head else False - bone.tail = mathutils.Vector(convert_coord(b.tail)) - if bone.head==bone.tail: - bone.tail=bone.head-mathutils.Vector((0, 1, 0)) - elif b.__class__ is pmd.BONE_IK: - bone.head = mathutils.Vector(convert_coord(b.pos)) - bone.tail = mathutils.Vector(convert_coord(b.tail)) + ############################################################ + # clean up not used vertices + ############################################################ + progress_print('clean up vertices not used') + remove_vertices=[] + vertex_map={} + for i, v in enumerate(l.each_vertex()): + if i in used_vertices: + vertex_map[i]=len(vertex_map) else: - # center - tail=mathutils.Vector(convert_coord(b.pos)) - bone.tail = tail - bone.head = tail-mathutils.Vector((0, 1, 0)) - - for child in b.children: - build_bone(armature, child, bone) - - - def importArmature(scene, l): - # create armature - armature = bpy.data.armatures.new('Armature') - # link to object - armature_object=bpy.data.objects.new('Armature', armature) - scene.objects.link(armature_object) - armature_object.x_ray=True - armature.draw_names=True - - # armature settings - armature.drawtype='OCTAHEDRAL' - armature.deform_envelope=False - armature.deform_vertexgroups=True - armature.x_axis_mirror=True - - # create action - #act = Blender.Armature.NLA.NewAction() - #act.setActive(armature_object) - - # select only armature object and set edit mode - scene.objects.active=armature_object - bpy.ops.object.mode_set(mode='OBJECT', toggle=False) - bpy.ops.object.mode_set(mode='EDIT', toggle=False) - - # create armature - for b in l.bones: - if not b.parent: - build_bone(armature, b) - - bpy.ops.object.mode_set(mode='OBJECT', toggle=False) - bpy.ops.object.select_all(action='DESELECT') - - ############################################################ - # IK - ############################################################ - pose = armature_object.pose - for ik in l.ik_list: - effector=l.bones[ik.target] - parent=l.bones[effector.parent_index] - name=getBoneName(parent) - p_bone = pose.bones[name] - if not p_bone: - print('not found', name) - continue - if len(ik.children) >= 16: - print('over MAX_CHAINLEN', ik, len(ik.children)) - continue - # IK - ik_const = p_bone.constraints.new('IK') - ik_const.chain_length=len(ik.children) - ik_const.target=armature_object - ik_const.subtarget=getBoneName(l.bones[ik.index]) - # ROT - rot_const = p_bone.constraints.new('LIMIT_ROTATION') - rot_const.influence = ik.weight - rot_const.owner_space = 'LOCAL' - rot_const.use_limit_x=True - rot_const.use_limit_z=True - rot_const.minimum_x=to_radian(ik.iterations) - rot_const.maximum_x=to_radian(180) - rot_const.minimum_z=to_radian(180 - ik.iterations) - rot_const.maximum_z=to_radian(0) - - return armature_object - + remove_vertices.append(i) - def importShape(meshObject, l, vertex_map): - if len(l.morph_list)==0: - return + bl.meshVertsDelete(mesh, remove_vertices) - # base - base=None - for s in l.morph_list: - if s.type!=0: - continue - base=s - break - assert(base) - - # create base key - baseblock=meshObject.add_shape_key("Basis") - - # mesh - mesh=meshObject.data - - # each skin - for s in l.morph_list: - if s.getName()==base.name: - # skip base - continue + progress_print('%s created' % mesh.name) + return vertex_map - # restore - #for v, base_pos in zip(mesh.verts, baseblock.data): - # v.co=base_pos.co - #mesh.update() - - # name - name=englishmap.getEnglishSkinName(s.getName()) - if not name: - name=s.getName() - new_shape_key=meshObject.add_shape_key(name) - #new_shape_key.value=1.0 - - # morph - for i, offset in zip(s.indices, s.pos_list): - try: - vertex_index=base.indices[i] - new_shape_key.data[vertex_index].co=[p+o for p, o in zip( - mesh.verts[vertex_index].co, convert_coord(offset))] - except IndexError as msg: - print(IndexError, msg) - print(i, len(base.indices)) - print(vertex_index, len(mesh.verts)) - print(base.indices[i]) - break - except KeyError: - #print 'this mesh not has shape vertices' - break - - # set ipo curve - #icu=ipo.addCurve(name) - #icu.interpolation = Blender.IpoCurve.InterpTypes.LINEAR - #icu.append( (0.0, 0.0) ) - def __importMesh(scene, io, tex_dir): """ @param l[in] mmd.PMDLoader @@ -833,29 +534,32 @@ def __importMesh(scene, io, tex_dir): #meshObject.layers = [1] mesh_objects.append(meshObject) + # activate object + bl.objectDeselectAll() + bl.objectActivate(scene, meshObject) + # shapeキーで使われる順に並べなおしたマテリアル16個分の # メッシュを作成する - vertex_map=import16MaerialAndMesh( + vertex_map=__import16MaerialAndMesh( meshObject, io, material_order[material_offset:material_offset+16], face_map, tex_dir) # enter Edit Mode - bl.objectDeselectAll() - bl.objectActivate(scene, meshObject) - bl.enterEditMode() + #bl.enterEditMode() # crete shape key - importShape(meshObject, io, vertex_map) + __importShape(meshObject, io, vertex_map) # exit Edit Mode - bl.exitEditMode() + #bl.exitEditMode() mesh.update() material_offset+=16 return mesh_objects + def __execute(filename, scene): """ load pmd file to context. @@ -870,8 +574,10 @@ def __execute(filename, scene): progress_set('loaded %s' % filename, 0.1) # create root object - root=bl.createEmptyObject(scene, - io.english_name if len(io.english_name)>0 else io.getName().encode(bl.INTERNAL_ENCODING)) + model_name=io.getEnglishName() + if len(model_name)==0: + model_name=io.getName() + root=bl.createEmptyObject(scene, model_name) # import mesh mesh_objects=__importMesh(scene, io, os.path.dirname(filename)) @@ -879,7 +585,7 @@ def __execute(filename, scene): bl.objectMakeParent(root, o) # import armature - armature_object=importArmature(scene, io) + armature_object=__importArmature(scene, io) if armature_object: bl.objectMakeParent(root, armature_object) armature = bl.objectGetData(armature_object)