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

diff --git a/swig/blender/mqo_import.py b/swig/blender/mqo_import.py
index b297a90..630501e 100644
--- a/swig/blender/mqo_import.py
+++ b/swig/blender/mqo_import.py
@@ -22,12 +22,9 @@ This script imports a mqo into Blender for editing.
 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
-###############################################################################
 import os
 import sys
 
@@ -45,6 +42,21 @@ if isBlender24():
 
     # 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
@@ -53,6 +65,23 @@ else:
     # 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:
@@ -65,7 +94,7 @@ def has_mikoto(mqo):
     return False
 
 
-def __createMaterials(scene, mqo, directory):
+def __createMaterials(mqo, directory):
     """
     create blender materials and renturn material list.
     """
@@ -75,7 +104,7 @@ def __createMaterials(scene, mqo, directory):
     if len(mqo.materials)>0:
         for material_index, m in enumerate(mqo.materials):
             # material
-            material=bl.createMqoMaterial(m)
+            material=createMqoMaterial(m)
             materials.append(material)
             # texture
             texture_name=m.getTexture()
@@ -93,20 +122,20 @@ def __createMaterials(scene, mqo, directory):
                     # texture
                     if os.path.exists(path):
                         print("create texture:", path)
-                        texture, image=bl.createTexture(path)
+                        texture, image=bl.texture.create(path)
                         textureMap[texture_name]=texture
                         imageMap[material_index]=image
                     else:
                         print("%s not exits" % path)
                         continue
-                bl.materialAddTexture(material, texture)
+                bl.material.addTexture(material, texture)
     else:
         # default material
         pass
     return materials, imageMap
 
 
-def __createObjects(scene, mqo, root, materials, imageMap, scale):
+def __createObjects(mqo, root, materials, imageMap, scale):
     """
     create blender mesh objects.
     """
@@ -114,7 +143,7 @@ def __createObjects(scene, mqo, root, materials, imageMap, scale):
     stack=[root]    
     objects=[]
     for o in mqo.objects:
-        mesh, mesh_object=bl.createMesh(scene, o.getName())
+        mesh, mesh_object=bl.mesh.create(o.getName())
 
         # add hierarchy
         stack_depth=len(stack)-1
@@ -122,15 +151,15 @@ def __createObjects(scene, mqo, root, materials, imageMap, scale):
         if o.depth<stack_depth:
             for i in range(stack_depth-o.depth):
                 stack.pop()
-        bl.objectMakeParent(stack[-1], mesh_object)
+        bl.object.makeParent(stack[-1], mesh_object)
         stack.append(mesh_object)
 
         if o.getName().startswith('sdef'):
             objects.append(mesh_object)
         elif o.getName().startswith('anchor'):
-            bl.objectLayerMask(mesh_object, [0, 1])
+            bl.object.setLayerMask(mesh_object, [0, 1])
         elif o.getName().startswith('bone'):
-            bl.objectLayerMask(mesh_object, [0, 1])
+            bl.object.setLayerMask(mesh_object, [0, 1])
 
         # geometry
         vertices=[(v.x * scale, -v.z * scale, v.y * scale) for v in o.vertices]
@@ -143,7 +172,7 @@ def __createObjects(scene, mqo, root, materials, imageMap, scale):
                 face_indices.append(f.getIndex(i))
             faces.append(face_indices)
             materialMap[f.material_index]=True
-        bl.meshAddGeometry(mesh, vertices, faces)
+        bl.mesh.addGeometry(mesh, vertices, faces)
 
         # blender limits 16 materials per mesh
         for i, material_index in enumerate(materialMap.keys()):
@@ -151,32 +180,33 @@ def __createObjects(scene, mqo, root, materials, imageMap, scale):
                 # split a mesh ?
                 print("over 16 materials!")
                 break
-            bl.meshAddMaterial(mesh, materials[material_index])
+            bl.mesh.addMaterial(mesh, materials[material_index])
             materialMap[material_index]=i
  
         # set face params
         assert(len(o.faces)==len(mesh.faces))
-        bl.meshAddUV(mesh)
+        bl.mesh.addUV(mesh)
         for i, (f, face) in enumerate(zip(o.faces, mesh.faces)):
             uv_array=[]
+            # 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.meshSetFaceUv(mesh, i, face, uv_array, 
+            bl.mesh.setFaceUV(mesh, i, face, uv_array, 
                     imageMap.get(f.material_index, None))
             if f.material_index in materialMap:
-                bl.faceSetMaterial(face, materialMap[f.material_index])
-            bl.faceSetSmooth(face, True)
+                bl.face.setMaterial(face, materialMap[f.material_index])
+            bl.face.setSmooth(face, True)
 
         # mirror modifier
         if o.mirror:
-            bl.objectAddMirrorModifier(mesh_object)
+            bl.modifier.addMirror(mesh_object)
 
         # set smoothing
-        bl.meshSetSmooth(mesh, o.smoothing)
+        bl.mesh.setSmooth(mesh, o.smoothing)
 
         # calc normal
-        #bl.meshRecalcNormals(mesh_object)
+        bl.mesh.recalcNormals(mesh_object)
 
     return objects
 
@@ -295,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
     """
@@ -571,26 +601,26 @@ def __execute(filename, scene, scale=0.1):
     # parse file
     io=mqo.IO()
     if not io.read(filename):
-        print("fail to load",filename)
+        bl.message("fail to load %s" % filename)
         return
 
     # create materials
-    materials, imageMap=__createMaterials(scene, io, os.path.dirname(filename))
+    materials, imageMap=__createMaterials(io, os.path.dirname(filename))
     if len(materials)==0:
-        materials.append(bl.createMaterial('default'))
+        materials.append(bl.material.create('default'))
 
     # create objects
-    root=bl.createEmptyObject(scene, os.path.basename(filename))
-    objects=__createObjects(scene, io, root, materials, imageMap, scale)
+    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)
+            create_bone_weight(io, armature_object, objects)
 
  
 ###############################################################################
@@ -599,33 +629,22 @@ def __execute(filename, scene, scale=0.1):
 if isBlender24():
     # for 2.4
     def execute_24(filename):
-        """
-        import a mqo file.
-        """
-        filename=filename.decode(bl.INTERNAL_ENCODING)
-        print("##start mqo_import.py##")
-        print(bl.INTERNAL_ENCODING, bl.FS_ENCODING)
-        print("parse mqo file: %s" % (filename))
-
-        Blender.Window.WaitCursor(1) 
-        t = Blender.sys.time() 
-
-        # execute
-        scene = Blender.Scene.GetCurrent()
-        __execute(filename, scene)
-        scene.update(0)
-
-        print('finished in %.2f seconds' % (Blender.sys.time()-t))
-        print('')
-        Blender.Redraw()
-        Blender.Window.WaitCursor(0) 
+        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
-    def execute_25(*args):
-        __execute(*args)
+    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):
@@ -651,7 +670,7 @@ else:
                 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.01)
+                soft_min=0.001, soft_max=100.0, default=0.1)
 
         def execute(self, context):
             execute_25(