swig/blender/mqo_export.py

   1 #!BPY\r
   2 # coding: utf-8\r
   3 \r
   4 """\r
   5 Name: 'Metasequoia (.mqo)...'\r
   6 Blender: 245\r
   7 Group: 'Export'\r
   8 Tooltip: 'Save as Metasequoia MQO File'\r
   9 """\r
  10 __author__= 'ousttrue'\r
  11 __url__ = ["http://gunload.web.fc2.com/blender/"]\r
  12 __version__= '0.3 2010/06/06'\r
  13 __bpydoc__ = """\\r
  14 This script is an exporter to MQO file format.\r
  15 \r
  16 Usage:\r
  17 \r
  18 Run this script from "File->Export" menu.\r
  19 \r
  20 0.1 20080128:\r
  21 0.2 20100518: refactoring.\r
  22 0.3 20100606: integrate 2.4 and 2.5.\r
  23 """\r
  24 \r
  25 \r
  26 ###############################################################################\r
  27 # import\r
  28 ###############################################################################\r
  29 import os\r
  30 import sys\r
  31 \r
  32 def isBlender24():\r
  33     return sys.version_info[0]<3\r
  34 \r
  35 if isBlender24():\r
  36     # for 2.4\r
  37     import Blender\r
  38     from Blender import Mathutils\r
  39     import bpy\r
  40 \r
  41     # wrapper\r
  42     import bl24 as bl\r
  43 \r
  44 else:\r
  45     # for 2.5\r
  46     import bpy\r
  47     from bpy.props import *\r
  48 \r
  49     # wrapper\r
  50     import bl25 as bl\r
  51 \r
  52 def apply_transform(vec, matrix):\r
  53     x, y, z = vec\r
  54     xloc, yloc, zloc = matrix[3][0], matrix[3][1], matrix[3][2]\r
  55     return    x*matrix[0][0] + y*matrix[1][0] + z*matrix[2][0] + xloc,\\r
  56             x*matrix[0][1] + y*matrix[1][1] + z*matrix[2][1] + yloc,\\r
  57             x*matrix[0][2] + y*matrix[1][2] + z*matrix[2][2] + zloc\r
  58 \r
  59 def convert_to_mqo(vec):\r
  60     return vec.x, vec.z, -vec.y\r
  61 \r
  62 \r
  63 class OutlineNode(object):\r
  64     __slots__=['o', 'children']\r
  65     def __init__(self, o):\r
  66         self.o=o\r
  67         self.children=[]\r
  68 \r
  69     def __str__(self):\r
  70         return "<Node %s>" % self.o\r
  71 \r
  72 \r
  73 class ObjectInfo(object):\r
  74     __slots__=['object', 'depth', 'material_map']\r
  75     def __init__(self, o, depth):\r
  76         self.object=o\r
  77         self.depth=depth\r
  78         self.material_map={}\r
  79 \r
  80     def __str__(self):\r
  81         return "<ObjectInfo %d %s>" % (self.depth, self.object)\r
  82 \r
  83 \r
  84 class MqoExporter(object):\r
  85     __slots__=["materials", "objects"]\r
  86     def __init__(self):\r
  87         self.objects=[]\r
  88         self.materials=[]\r
  89 \r
  90     def setup(self, scene):\r
  91         # 木構造を構築する\r
  92         object_node_map={}\r
  93         for o in scene.objects:\r
  94             object_node_map[o]=OutlineNode(o)\r
  95         for node in object_node_map.values():\r
  96             if node.o.parent:\r
  97                 object_node_map[node.o.parent].children.append(node)\r
  98 \r
  99         # ルートを得る\r
 100         root=object_node_map[scene.objects.active]\r
 101 \r
 102         # 情報を集める\r
 103         if root.o.type.upper()=='EMPTY':\r
 104             # depth調整 \r
 105             for node in root.children:\r
 106                 self.__setup(node)\r
 107         else:\r
 108             self.__setup(root)\r
 109 \r
 110     def __setup(self, node, depth=0):\r
 111         info=ObjectInfo(node.o, depth)\r
 112         self.objects.append(info)\r
 113         if node.o.type.upper()=='MESH':\r
 114             # set material index\r
 115             for i, m in enumerate(node.o.data.materials):\r
 116                 info.material_map[i]=self.__getOrAddMaterial(m)\r
 117         # recursive\r
 118         for child in node.children:\r
 119             self.__setup(child, depth+1)\r
 120             \r
 121     def __getOrAddMaterial(self, material):\r
 122         for i, m in enumerate(self.materials):\r
 123             if m==material:\r
 124                 return i\r
 125         index=len(self.materials)\r
 126         self.materials.append(material)\r
 127         return index\r
 128 \r
 129     def write(self, path, scene):\r
 130         io=bl.Writer(path, 'cp932')\r
 131         self.__write_header(io)\r
 132         self.__write_scene(io)\r
 133         print("Writing MaterialChunk")\r
 134         self.__write_materials(io, os.path.dirname(path))\r
 135         print("Writing ObjectChunk")\r
 136         for info in self.objects:\r
 137             self.__write_object(io, info, scene)\r
 138         io.write("Eof\r\n")\r
 139         io.flush()\r
 140         io.close()\r
 141 \r
 142     def __write_header(self, io):\r
 143         io.write("Metasequoia Document\r\n")\r
 144         io.write("Format Text Ver 1.0\r\n")\r
 145         io.write("\r\n")\r
 146 \r
 147     def __write_scene(self, io):\r
 148         print("Writing SceneChunk")\r
 149         io.write("Scene {\r\n")\r
 150         io.write("}\r\n")\r
 151 \r
 152     def __write_materials(self, io, dirname):\r
 153         # each material    \r
 154         io.write("Material %d {\r\n" % (len(self.materials)))\r
 155         for m in self.materials:\r
 156             tex, aplane=bl.getTexture(m, dirname)\r
 157             if len(tex):\r
 158                 # textureがある場合は下地を白に\r
 159                 io.write("\"%s\" shader(3) col(1 1 1 1)" % m.name)\r
 160             else:\r
 161                 # 無い場合はそのまま\r
 162                 io.write(bl.materialToMqo(m))\r
 163             io.write(tex)\r
 164             io.write(aplane)\r
 165             io.write("\r\n") \r
 166         # end of chunk\r
 167         io.write("}\r\n") \r
 168 \r
 169     def __write_object(self, io, info, scene):\r
 170         print(info)\r
 171 \r
 172         obj=info.object\r
 173         if obj.type.upper()!='MESH':\r
 174             return\r
 175 \r
 176         # duplicate and applyMatrix\r
 177         mesh, dumy=bl.objectDuplicate(scene, obj)\r
 178 \r
 179         ############################################################\r
 180         # write\r
 181         ############################################################\r
 182         io.write("Object \""+obj.name+"\" {\r\n")\r
 183 \r
 184         # depth\r
 185         io.write("\tdepth %d\r\n" % info.depth)\r
 186 \r
 187         # mirroring                \r
 188         isMirrorring=False\r
 189         for mod in obj.modifiers:\r
 190                 if mod.name=="Mirror":\r
 191                         isMirrorring=True\r
 192                         break\r
 193         if isMirrorring:\r
 194                 io.write("\tmirror 1\r\n")\r
 195                 io.write("\tmirror_axis 1\r\n")\r
 196 \r
 197         # vertices\r
 198         io.write("\tvertex %d {\r\n" % len(mesh.verts))\r
 199         for vert in mesh.verts:\r
 200             x, y, z = convert_to_mqo(vert.co)\r
 201             io.write("\t\t%f %f %f\r\n" % (x, y, z)) # rotate to y-up\r
 202         io.write("\t}\r\n")\r
 203 \r
 204         # faces\r
 205         io.write("\tface %d {\r\n" % len(mesh.faces))\r
 206         for i, face in enumerate(mesh.faces):\r
 207             count=bl.faceVertexCount(face)\r
 208             # V\r
 209             io.write("\t\t%d V(" % count)\r
 210             for j in bl.faceVertices(face):\r
 211                 io.write("%d " % j)\r
 212             io.write(")")\r
 213             # mat\r
 214             if len(mesh.materials):\r
 215                 io.write(" M(%d)" % \r
 216                         info.material_map[bl.faceMaterialIndex(face)])\r
 217             # UV\r
 218             if bl.meshHasUV(mesh) and bl.faceHasUV(mesh, i, face):\r
 219                 io.write(" UV(")\r
 220                 for uv in bl.faceGetUV(mesh, i, face, count):\r
 221                     # reverse vertical value\r
 222                     io.write("%f %f " % (uv[0], 1.0-uv[1])) \r
 223                 io.write(")")\r
 224             io.write("\r\n")\r
 225         io.write("\t}\r\n") # end of faces\r
 226         io.write("}\r\n") # end of object\r
 227         ############################################################\r
 228 \r
 229         # 削除する\r
 230         scene.objects.unlink(dumy)\r
 231 \r
 232 \r
 233 def __execute(filename, scene, scale):\r
 234     exporter=MqoExporter()\r
 235     exporter.setup(scene)\r
 236     exporter.write(filename, scene)\r
 237 \r
 238 \r
 239 if isBlender24():\r
 240     # for 2.4\r
 241     def execute_24(filename):\r
 242         """\r
 243         export mqo.\r
 244         """\r
 245         filename=filename.decode(bl.INTERNAL_ENCODING)\r
 246         print("mqo exporter: %s" % filename)\r
 247 \r
 248         Blender.Window.WaitCursor(1) \r
 249         t = Blender.sys.time() \r
 250 \r
 251         __execute(filename, Blender.Scene.GetCurrent(), 1.0)\r
 252 \r
 253         print('finished in %.2f seconds' % (Blender.sys.time()-t) )\r
 254         Blender.Redraw()\r
 255         Blender.Window.WaitCursor(0) \r
 256 \r
 257     # execute\r
 258     Blender.Window.FileSelector(\r
 259             execute_24, \r
 260             'Export Metasequoia MQO', \r
 261             Blender.sys.makename(ext='.mqo'))\r
 262 \r
 263 else:\r
 264     # for 2.5\r
 265     def execute_25(*args):\r
 266         __execute(*args)\r
 267 \r
 268     # operator\r
 269     class EXPORT_OT_mqo(bpy.types.Operator):\r
 270         '''Save a Metasequoia MQO file.'''\r
 271         bl_idname = "export_scene.mqo"\r
 272         bl_label = 'Export MQO'\r
 273 \r
 274         # List of operator properties, the attributes will be assigned\r
 275         # to the class instance from the operator settings before calling.\r
 276 \r
 277         path = StringProperty(\r
 278                 name="File Path",\r
 279                 description="File path used for exporting the MQO file",\r
 280                 maxlen= 1024,\r
 281                 default= ""\r
 282                 )\r
 283         filename = StringProperty(\r
 284                 name="File Name", \r
 285                 description="Name of the file.")\r
 286         directory = StringProperty(\r
 287                 name="Directory", \r
 288                 description="Directory of the file.")\r
 289 \r
 290         check_existing = BoolProperty(\r
 291                 name="Check Existing",\r
 292                 description="Check and warn on overwriting existing files",\r
 293                 default=True,\r
 294                 options=set('HIDDEN'))\r
 295 \r
 296         scale = FloatProperty(\r
 297                 name="Scale", \r
 298                 description="Scale the MQO by this value", \r
 299                 min=0.0001, max=1000000.0, \r
 300                 soft_min=0.001, soft_max=100.0, default=1.0)\r
 301 \r
 302         def execute(self, context):\r
 303             execute_25(\r
 304                     self.properties.path, \r
 305                     context.scene, \r
 306                     self.properties.scale)\r
 307             return 'FINISHED'\r
 308 \r
 309         def invoke(self, context, event):\r
 310             wm=context.manager\r
 311             wm.add_fileselect(self)\r
 312             return 'RUNNING_MODAL'\r
 313 \r
 314     # register menu\r
 315     def menu_func(self, context): \r
 316         default_path=bpy.data.filename.replace(".blend", ".mqo")\r
 317         self.layout.operator(\r
 318                 EXPORT_OT_mqo.bl_idname, \r
 319                 text="Metasequoia (.mqo)").path=default_path\r
 320 \r
 321     def register():\r
 322         bpy.types.register(EXPORT_OT_mqo)\r
 323         bpy.types.INFO_MT_file_export.append(menu_func)\r
 324 \r
 325     def unregister():\r
 326         bpy.types.unregister(EXPORT_OT_mqo)\r
 327         bpy.types.INFO_MT_file_export.remove(menu_func)\r
 328 \r
 329     if __name__ == "__main__":\r
 330         register()\r
 331 \r