swig/blender/mqo_import.py

   1 #!BPY\r
   2 # coding: utf-8\r
   3 """ \r
   4 Name: 'Metasequoia(.mqo)...'\r
   5 Blender: 245\r
   6 Group: 'Import'\r
   7 Tooltip: 'Import from Metasequoia file format (.mqo)'\r
   8 """\r
   9 __author__=['ousttrue']\r
  10 __url__ = ["http://gunload.web.fc2.com/blender/"]\r
  11 __version__= '0.6 2010/05/05'\r
  12 __bpydoc__= '''\\r
  13 \r
  14 MQO Importer\r
  15 \r
  16 This script imports a mqo into Blender for editing.\r
  17 \r
  18 0.2 20080123: update.\r
  19 0.3 20091125: modify for linux.\r
  20 0.4 20100310: rewrite.\r
  21 0.5 20100311: create armature from mikoto bone.\r
  22 0.6 20100505: C extension.\r
  23 0.7 20100606: integrate 2.4 and 2.5.\r
  24 0.8 20100619: fix multibyte object name.\r
  25 '''\r
  26 \r
  27 \r
  28 ###############################################################################\r
  29 # import\r
  30 ###############################################################################\r
  31 import os\r
  32 import sys\r
  33 \r
  34 # C extension\r
  35 from meshio import mqo\r
  36 \r
  37 def isBlender24():\r
  38     return sys.version_info[0]<3\r
  39 \r
  40 if isBlender24():\r
  41     # for 2.4\r
  42     import Blender\r
  43     from Blender import Mathutils\r
  44     import bpy\r
  45 \r
  46     # wrapper\r
  47     import bl24 as bl\r
  48 else:\r
  49     # for 2.5\r
  50     import bpy\r
  51     from bpy.props import *\r
  52 \r
  53     # wrapper\r
  54     import bl25 as bl\r
  55 \r
  56 \r
  57 def has_mikoto(mqo):\r
  58     return False\r
  59 \r
  60 \r
  61 def __createMaterials(scene, mqo, directory):\r
  62     """\r
  63     create blender materials and renturn material list.\r
  64     """\r
  65     materials = []\r
  66     textureMap={}\r
  67     imageMap={}\r
  68     if len(mqo.materials)>0:\r
  69         for material_index, m in enumerate(mqo.materials):\r
  70             # material\r
  71             material=bl.createMqoMaterial(m)\r
  72             materials.append(material)\r
  73             # texture\r
  74             texture_name=m.getTexture()\r
  75             if texture_name!='':\r
  76                 if texture_name in textureMap:\r
  77                     texture=textureMap[texture_name]\r
  78                 else:\r
  79                     # load texture image\r
  80                     if os.path.isabs(texture_name):\r
  81                         # absolute\r
  82                         path = texture_name\r
  83                     else:\r
  84                         # relative\r
  85                         path = os.path.join(directory, texture_name)\r
  86                     # texture\r
  87                     if os.path.exists(path):\r
  88                         print("create texture:", path)\r
  89                         texture, image=bl.createTexture(path)\r
  90                         textureMap[texture_name]=texture\r
  91                         imageMap[material_index]=image\r
  92                     else:\r
  93                         print("%s not exits" % path)\r
  94                         continue\r
  95                 bl.materialAddTexture(material, texture)\r
  96     else:\r
  97         # default material\r
  98         pass\r
  99     return materials, imageMap\r
 100 \r
 101 \r
 102 def __createObjects(scene, mqo, root, materials, imageMap, scale):\r
 103     """\r
 104     create blender mesh objects.\r
 105     """\r
 106     # store hierarchy\r
 107     stack=[root]    \r
 108     objects=[]\r
 109     for o in mqo.objects:\r
 110         mesh, mesh_object=bl.createMesh(scene, o.getName())\r
 111 \r
 112         # add hierarchy\r
 113         stack_depth=len(stack)-1\r
 114         print(o.depth, stack_depth)\r
 115         if o.depth<stack_depth:\r
 116             for i in range(stack_depth-o.depth):\r
 117                 stack.pop()\r
 118         bl.objectMakeParent(stack[-1], mesh_object)\r
 119         stack.append(mesh_object)\r
 120 \r
 121         if o.getName().startswith('sdef'):\r
 122             objects.append(mesh_object)\r
 123         elif o.getName().startswith('anchor'):\r
 124             bl.objectLayerMask(mesh_object, [0, 1])\r
 125         elif o.getName().startswith('bone'):\r
 126             bl.objectLayerMask(mesh_object, [0, 1])\r
 127 \r
 128         bl.meshAddMqoGeometry(mesh, o, materials, imageMap, scale)\r
 129 \r
 130     return objects\r
 131 \r
 132 \r
 133 def __execute(filename, scene, scale=1.0):\r
 134     # parse file\r
 135     io=mqo.IO()\r
 136     if not io.read(filename):\r
 137         print("fail to load",filename)\r
 138         return\r
 139 \r
 140     # create materials\r
 141     materials, imageMap=__createMaterials(scene, io, os.path.dirname(filename))\r
 142 \r
 143     # create objects\r
 144     root=bl.createEmptyObject(scene, os.path.basename(filename))\r
 145     objects=__createObjects(scene, io, root, materials, imageMap, scale)\r
 146 \r
 147     if has_mikoto(io):\r
 148         # create mikoto bone\r
 149         armature_object=create_armature(scene, io)\r
 150         if armature_object:\r
 151             root.makeParent([armature_object])\r
 152 \r
 153             # create bone weight\r
 154             create_bone_weight(scene, io, armature_object, objects)\r
 155 \r
 156  \r
 157 ###############################################################################\r
 158 # register\r
 159 ###############################################################################\r
 160 if isBlender24():\r
 161     # for 2.4\r
 162     def execute_24(filename):\r
 163         """\r
 164         import a mqo file.\r
 165         """\r
 166         filename=filename.decode(bl.INTERNAL_ENCODING)\r
 167         print("##start mqo_import.py##")\r
 168         print(bl.INTERNAL_ENCODING, bl.FS_ENCODING)\r
 169         print("parse mqo file: %s" % (filename))\r
 170 \r
 171         Blender.Window.WaitCursor(1) \r
 172         t = Blender.sys.time() \r
 173 \r
 174         # execute\r
 175         scene = Blender.Scene.GetCurrent()\r
 176         __execute(filename, scene)\r
 177         scene.update(0)\r
 178 \r
 179         print('finished in %.2f seconds' % (Blender.sys.time()-t))\r
 180         print('')\r
 181         Blender.Redraw()\r
 182         Blender.Window.WaitCursor(0) \r
 183 \r
 184     # execute\r
 185     Blender.Window.FileSelector(execute_24, 'Import MQO', '*.mqo')\r
 186 else:\r
 187     # for 2.5\r
 188     def execute_25(*args):\r
 189         __execute(*args)\r
 190 \r
 191     # operator\r
 192     class IMPORT_OT_mqo(bpy.types.Operator):\r
 193         '''Import from Metasequoia file format (.mqo)'''\r
 194         bl_idname = "import_scene.mqo"\r
 195         bl_label = 'Import MQO'\r
 196 \r
 197         # List of operator properties, the attributes will be assigned\r
 198         # to the class instance from the operator settings before calling.\r
 199 \r
 200         path = StringProperty(\r
 201                 name="File Path", \r
 202                 description="File path used for importing the MQO file", \r
 203                 maxlen= 1024, default= "")\r
 204         filename = StringProperty(\r
 205                 name="File Name", \r
 206                 description="Name of the file.")\r
 207         directory = StringProperty(\r
 208                 name="Directory", \r
 209                 description="Directory of the file.")\r
 210 \r
 211         scale = FloatProperty(\r
 212                 name="Scale", \r
 213                 description="Scale the MQO by this value", \r
 214                 min=0.0001, max=1000000.0, \r
 215                 soft_min=0.001, soft_max=100.0, default=0.01)\r
 216 \r
 217         def execute(self, context):\r
 218             execute_25(\r
 219                     self.properties.path, \r
 220                     context.scene, \r
 221                     self.properties.scale)\r
 222             return 'FINISHED'\r
 223 \r
 224         def invoke(self, context, event):\r
 225             wm=context.manager\r
 226             wm.add_fileselect(self)\r
 227             return 'RUNNING_MODAL'\r
 228 \r
 229 \r
 230     # register menu\r
 231     def menu_func(self, context): \r
 232         self.layout.operator(\r
 233                 IMPORT_OT_mqo.bl_idname, \r
 234                 text="Metasequoia (.mqo)")\r
 235 \r
 236     def register():\r
 237         bpy.types.register(IMPORT_OT_mqo)\r
 238         bpy.types.INFO_MT_file_import.append(menu_func)\r
 239 \r
 240     def unregister():\r
 241         bpy.types.unregister(IMPORT_OT_mqo)\r
 242         bpy.types.INFO_MT_file_import.remove(menu_func)\r
 243 \r
 244     if __name__=="__main__":\r
 245         register()\r
 246 \r