X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=swig%2Fblender%2Fmqo_import.py;h=630501ec3a5ca415b8fb4e727635b7f36be1c8f9;hb=e4436302445448dfac7da7b9b9666786611d33ab;hp=cb05bc8243cd64bd2b33d0e466fafcd71655a646;hpb=8624b41a70d35ec83be65b050a82e5c24bc06ad7;p=meshio%2Fmeshio.git

diff --git a/swig/blender/mqo_import.py b/swig/blender/mqo_import.py
index cb05bc8..630501e 100644
--- a/swig/blender/mqo_import.py
+++ b/swig/blender/mqo_import.py
@@ -21,10 +21,12 @@ This script imports a mqo into Blender for editing.
 0.5 20100311: create armature from mikoto bone.
 0.6 20100505: C extension.
 0.7 20100606: integrate 2.4 and 2.5.
+0.8 20100619: fix multibyte object name.
+0.9 20100626: refactoring.
 '''
+
 import os
 import sys
-import math
 
 # C extension
 from meshio import mqo
@@ -32,182 +34,186 @@ from meshio import mqo
 def isBlender24():
     return sys.version_info[0]<3
 
-
 if isBlender24():
     # for 2.4
     import Blender
     from Blender import Mathutils
     import bpy
 
-    # ファイルシステムの文字コード
-    # 改造版との共用のため
-    FS_ENCODING=sys.getfilesystemencoding()
-    if os.path.exists(os.path.dirname(sys.argv[0])+"/utf8"):
-        INTERNAL_ENCODING='utf-8'
-    else:
-        INTERNAL_ENCODING=FS_ENCODING
+    # wrapper
+    import bl24 as bl
+
+    def createMqoMaterial(m):
+        material = Blender.Material.New(
+                m.getName().encode(bl.INTERNAL_ENCODING))
+        #material.mode |= Blender.Material.Modes.SHADELESS
+        # diffuse
+        material.rgbCol = [m.color.r, m.color.g, m.color.b]
+        material.alpha = m.color.a
+        # other
+        material.amb=m.ambient
+        material.spec=m.specular
+        material.hard=int(255 * m.power)
+        material.emit=m.emmit
+        return material
+
 else:
     # for 2.5
     import bpy
     from bpy.props import *
 
+    # wrapper
+    import bl25 as bl
+
+    def createMqoMaterial(m):
+        material = bpy.data.materials.new(m.getName())
+        # shader
+        if m.shader==1:
+            material.diffuse_shader='FRESNEL'
+        else:
+            material.diffuse_shader='LAMBERT'
+        # diffuse
+        material.diffuse_color=[m.color.r, m.color.g, m.color.b]
+        material.diffuse_intensity=m.diffuse
+        material.alpha=m.color.a
+        # other
+        material.ambient = m.ambient
+        #material.specular = m.specular
+        material.emit=m.emit
+        return material
+
 
 def has_mikoto(mqo):
+    #for o in mqo.objects:
+    #    if o.getName().startswith('bone'):
+    #        return True
+    #    if o.getName().startswith('sdef'):
+    #        return True
+    #    if o.getName().startswith('anchor'):
+    #        return True
     return False
 
 
-def create_materials(scene, mqo, directory):
+def __createMaterials(mqo, directory):
     """
     create blender materials and renturn material list.
     """
     materials = []
-    images = []
-    for m in mqo.materials:
-        material = Blender.Material.New(m.getName().encode(INTERNAL_ENCODING))
-        materials.append(material)
-
-        material.mode |= Blender.Material.Modes.SHADELESS
-        material.rgbCol = [m.color.r, m.color.g, m.color.b]
-        material.alpha = m.color.a
-        material.amb = m.ambient
-        material.spec = m.specular
-        material.hard = int(255 * m.power)
-        if m.texture!="":
-            texture_path=m.getTexture()
-
-            # load texture image
-            if os.path.isabs(texture_path):
-                # absolute
-                path = texture_path
-            else:
-                # relative
-                path = os.path.join(directory, texture_path)
-
-            # backslash to slash
-            #path = path.replace('\\', '/')
-
+    textureMap={}
+    imageMap={}
+    if len(mqo.materials)>0:
+        for material_index, m in enumerate(mqo.materials):
+            # material
+            material=createMqoMaterial(m)
+            materials.append(material)
             # texture
-            if os.path.exists(path):
-                image = Blender.Image.Load(path.encode(INTERNAL_ENCODING))
-                images.append(image)
-                material.mode = material.mode | Blender.Material.Modes.TEXFACE
-                tex = Blender.Texture.New(path.encode(INTERNAL_ENCODING))
-                tex.type = Blender.Texture.Types.IMAGE
-                tex.image = image
-                material.setTexture(0, tex, Blender.Texture.TexCo.UV)
-            else:
-                print("%s not exits" % path)
-            
-    return materials
+            texture_name=m.getTexture()
+            if texture_name!='':
+                if texture_name in textureMap:
+                    texture=textureMap[texture_name]
+                else:
+                    # load texture image
+                    if os.path.isabs(texture_name):
+                        # absolute
+                        path = texture_name
+                    else:
+                        # relative
+                        path = os.path.join(directory, texture_name)
+                    # texture
+                    if os.path.exists(path):
+                        print("create texture:", path)
+                        texture, image=bl.texture.create(path)
+                        textureMap[texture_name]=texture
+                        imageMap[material_index]=image
+                    else:
+                        print("%s not exits" % path)
+                        continue
+                bl.material.addTexture(material, texture)
+    else:
+        # default material
+        pass
+    return materials, imageMap
 
 
-def create_objects(scene, root, mqo, materials):
+def __createObjects(mqo, root, materials, imageMap, scale):
     """
     create blender mesh objects.
     """
-    # store hierarchy
+    # tree stack
     stack=[root]    
-
     objects=[]
     for o in mqo.objects:
-        #print "%s:v(%d),f(%d)" % (o.name, len(o.vertices), len(o.faces))
-        # create mesh
-        mesh = Blender.Mesh.New()
-        mesh_object=scene.objects.new(mesh, o.name.encode('utf-8'))
+        mesh, mesh_object=bl.mesh.create(o.getName())
 
         # add hierarchy
         stack_depth=len(stack)-1
-        print(o.depth, stack_depth)
+        #print(o.depth, stack_depth)
         if o.depth<stack_depth:
             for i in range(stack_depth-o.depth):
                 stack.pop()
-        stack[-1].makeParent([mesh_object])
+        bl.object.makeParent(stack[-1], mesh_object)
         stack.append(mesh_object)
 
-        if o.name.startswith('sdef'):
-            # add sdef object
+        if o.getName().startswith('sdef'):
             objects.append(mesh_object)
-        elif o.name.startswith('anchor'):
-            #print("hide %s" % o.name)
-            #mesh_object.restrictDisplay=False
-            mesh_object.layers=[2]
-        elif o.name.startswith('bone'):
-            mesh_object.layers=[2]
-
-        # add vertices
-        mesh.verts.extend(Mathutils.Vector(0, 0, 0)) # dummy
-        mesh.verts.extend([(v.x, -v.z, v.y) for v in o.vertices])
-        # add faces
-        mesh_faces=[]
-        for face in o.faces:
+        elif o.getName().startswith('anchor'):
+            bl.object.setLayerMask(mesh_object, [0, 1])
+        elif o.getName().startswith('bone'):
+            bl.object.setLayerMask(mesh_object, [0, 1])
+
+        # geometry
+        vertices=[(v.x * scale, -v.z * scale, v.y * scale) for v in o.vertices]
+        faces=[]
+        materialMap={}
+        for f in o.faces:
             face_indices=[]
-            for i in xrange(face.index_count):
-                face_indices.append(face.getIndex(i)+1)
-            mesh_faces.append(face_indices)
-        #new_faces=mesh.faces.extend([face.indices for face in o.faces], 
-        new_faces=mesh.faces.extend(mesh_faces,
-                #ignoreDups=True, 
-                indexList=True)
-        mesh.update()
-        
-        # gather used materials
-        usedMaterials = {}
-        if new_faces:
-            for i in new_faces:
-                if type(i) is int:
-                    usedMaterials[o.faces[i].material_index]=True
+            # flip face
+            for i in reversed(range(f.index_count)):
+                face_indices.append(f.getIndex(i))
+            faces.append(face_indices)
+            materialMap[f.material_index]=True
+        bl.mesh.addGeometry(mesh, vertices, faces)
 
         # blender limits 16 materials per mesh
-        # separate mesh ?
-        for i, material_index in enumerate(usedMaterials.keys()):
+        for i, material_index in enumerate(materialMap.keys()):
             if i>=16:
+                # split a mesh ?
                 print("over 16 materials!")
                 break
-            mesh.materials+=[materials[material_index]]
-            usedMaterials[material_index]=i
-        
+            bl.mesh.addMaterial(mesh, materials[material_index])
+            materialMap[material_index]=i
+ 
         # set face params
-        for i, f in enumerate(o.faces):       
-            if not type(new_faces[i]) is int:
-                continue
-
-            face=mesh.faces[new_faces[i]]
-
+        assert(len(o.faces)==len(mesh.faces))
+        bl.mesh.addUV(mesh)
+        for i, (f, face) in enumerate(zip(o.faces, mesh.faces)):
             uv_array=[]
-            for i in xrange(f.index_count):
-                uv_array.append(Blender.Mathutils.Vector(
-                    f.getUV(i).x, 
-                    1.0-f.getUV(i).y)
-                    )
-            try:
-                face.uv=uv_array
-            except Exception, msg:
-                #print msg
-                #print face.index, uv_array
-                pass
-        
-            if f.material_index in usedMaterials:
-                face.mat = usedMaterials[f.material_index]
-
-            face.smooth = 1
-
-        # rmeove dummy 0 vertex
-        mesh.verts.delete(0)
-            
-        mesh.mode |= Blender.Mesh.Modes.AUTOSMOOTH
-        mesh.maxSmoothAngle = int(o.smoothing)
-        mesh.smooth()
-        mesh.calcNormals()
-        mesh.flipNormals()
-        mesh.update()
+            # ToDo FIX
+            # flip face
+            for j in reversed(range(f.index_count)):
+                uv_array.append((f.getUV(j).x, 1.0-f.getUV(j).y))
+            bl.mesh.setFaceUV(mesh, i, face, uv_array, 
+                    imageMap.get(f.material_index, None))
+            if f.material_index in materialMap:
+                bl.face.setMaterial(face, materialMap[f.material_index])
+            bl.face.setSmooth(face, True)
 
         # mirror modifier
         if o.mirror:
-            mod=mesh_object.modifiers.append(Blender.Modifier.Types.MIRROR)
+            bl.modifier.addMirror(mesh_object)
+
+        # set smoothing
+        bl.mesh.setSmooth(mesh, o.smoothing)
+
+        # calc normal
+        bl.mesh.recalcNormals(mesh_object)
 
     return objects
 
 
+###############################################################################
+# for mqo mikoto bone.
+###############################################################################
 class MikotoBone(object):
     __slots__=[
             'name',
@@ -226,9 +232,9 @@ class MikotoBone(object):
 
         self.name=materials[face.material_index].name.encode('utf-8')
 
-        i0=face.indices[0]
-        i1=face.indices[1]
-        i2=face.indices[2]
+        i0=face.getIndex(0)
+        i1=face.getIndex(1)
+        i2=face.getIndex(2)
         v0=vertices[i0]
         v1=vertices[i1]
         v2=vertices[i2]
@@ -319,7 +325,7 @@ def build_armature(armature, mikotoBone, parent=None):
         build_armature(armature, child, bone)
 
 
-def create_armature(scene, mqo):
+def create_armature(mqo):
     """
     create armature
     """
@@ -409,8 +415,8 @@ def create_armature(scene, mqo):
 
 class TrianglePlane(object):
     """
-    mikoto方式ボーンのアンカーウェイト計算用。
-    (不完全)
+    mikoto$BJ}<0%\!<%s$N%"%s%+!<%&%'%$%H7W;;MQ!#(B
+    ($BIT40A4(B)
     """
     __slots__=['normal', 
             'v0', 'v1', 'v2',
@@ -468,7 +474,7 @@ class TrianglePlane(object):
 
 class MikotoAnchor(object):
     """
-    mikoto方式スケルトンのアンカー。
+    mikoto$BJ}<0%9%1%k%H%s$N%"%s%+!<!#(B
     """
     __slots__=[
             "triangles", "bbox",
@@ -589,57 +595,110 @@ def create_bone_weight(scene, mqo, armature_object, objects):
                 # debug orphan vertex
                 print('orphan', mvert)
         mesh.update()
-    
 
-def execute_24(filename):
-    """
-    import a mqo file.
-    """
-    filename=filename.decode(INTERNAL_ENCODING)
-    print "##start mqo_import.py##"
-    print INTERNAL_ENCODING, FS_ENCODING
-    print "parse mqo file: %s" % (filename)
-
-    Blender.Window.WaitCursor(1) 
-    t = Blender.sys.time() 
 
+def __execute(filename, scene, scale=0.1):
     # parse file
     io=mqo.IO()
-    
     if not io.read(filename):
+        bl.message("fail to load %s" % filename)
         return
 
-    # get active scene
-    scene = Blender.Scene.GetCurrent()
-
     # create materials
-    materials=create_materials(scene, io, os.path.dirname(filename))
- 
+    materials, imageMap=__createMaterials(io, os.path.dirname(filename))
+    if len(materials)==0:
+        materials.append(bl.material.create('default'))
+
     # create objects
-    root=scene.objects.new("Empty")
-    root.setName(os.path.basename(filename))
-    objects=create_objects(scene, root, io, materials)
+    root=bl.object.createEmpty(os.path.basename(filename))
+    objects=__createObjects(io, root, materials, imageMap, scale)
 
     if has_mikoto(io):
         # create mikoto bone
-        armature_object=create_armature(scene, io)
+        armature_object=create_armature(io)
         if armature_object:
             root.makeParent([armature_object])
 
             # create bone weight
-            create_bone_weight(scene, io, armature_object, objects)
-
-
-    print('finished in %.2f seconds' % (Blender.sys.time()-t))
-    print('')
-    Blender.Redraw()
-    Blender.Window.WaitCursor(0) 
-
+            create_bone_weight(io, armature_object, objects)
 
+ 
+###############################################################################
+# register
+###############################################################################
 if isBlender24():
     # for 2.4
+    def execute_24(filename):
+        scene=Blender.Scene.GetCurrent()
+        bl.initialize('mqo_import', scene)
+        __execute(
+                filename.decode(bl.INTERNAL_ENCODING), 
+                scene)
+        bl.finalize()
+
+    # execute
     Blender.Window.FileSelector(execute_24, 'Import MQO', '*.mqo')
+
 else:
     # for 2.5
-    pass
+    def execute_25(filename, scene, scale):
+        bl.initialize('mqo_import', scene)
+        __execute(filename, scene, scale)
+        bl.finalize()
+
+    # operator
+    class IMPORT_OT_mqo(bpy.types.Operator):
+        '''Import from Metasequoia file format (.mqo)'''
+        bl_idname = "import_scene.mqo"
+        bl_label = 'Import MQO'
+
+        # List of operator properties, the attributes will be assigned
+        # to the class instance from the operator settings before calling.
+
+        path = StringProperty(
+                name="File Path", 
+                description="File path used for importing the MQO file", 
+                maxlen= 1024, default= "")
+        filename = StringProperty(
+                name="File Name", 
+                description="Name of the file.")
+        directory = StringProperty(
+                name="Directory", 
+                description="Directory of the file.")
+
+        scale = 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):
+            execute_25(
+                    self.properties.path, 
+                    context.scene, 
+                    self.properties.scale)
+            return 'FINISHED'
+
+        def invoke(self, context, event):
+            wm=context.manager
+            wm.add_fileselect(self)
+            return 'RUNNING_MODAL'
+
+
+    # register menu
+    def menu_func(self, context): 
+        self.layout.operator(
+                IMPORT_OT_mqo.bl_idname, 
+                text="Metasequoia (.mqo)")
+
+    def register():
+        bpy.types.register(IMPORT_OT_mqo)
+        bpy.types.INFO_MT_file_import.append(menu_func)
+
+    def unregister():
+        bpy.types.unregister(IMPORT_OT_mqo)
+        bpy.types.INFO_MT_file_import.remove(menu_func)
+
+    if __name__=="__main__":
+        register()