+++ /dev/null
-#!BPY\r
-# coding: utf-8\r
-""" \r
-Name: 'Metasequoia(.mqo)...'\r
-Blender: 245\r
-Group: 'Import'\r
-Tooltip: 'Import from Metasequoia file format (.mqo)'\r
-"""\r
-__author__=['ousttrue']\r
-__url__ = ["http://gunload.web.fc2.com/blender/"]\r
-__version__= '2.2'\r
-__bpydoc__= '''\\r
-\r
-MQO Importer\r
-\r
-This script imports a mqo into Blender for editing.\r
-\r
-0.2 20080123: update.\r
-0.3 20091125: modify for linux.\r
-0.4 20100310: rewrite.\r
-0.5 20100311: create armature from mikoto bone.\r
-0.6 20100505: C extension.\r
-0.7 20100606: integrate 2.4 and 2.5.\r
-0.8 20100619: fix multibyte object name.\r
-0.9 20100626: refactoring.\r
-2.0 20100724: update for Blender2.53.\r
-2.1 20100731: add full python module.\r
-2.2 20101005: update for Blender2.54.\r
-2.3 20101228: update for Blender2.55.\r
-'''\r
-\r
-bl_addon_info = {\r
- 'category': 'Import/Export',\r
- 'name': 'Import: Metasequioa Model Format (.mqo)',\r
- 'author': 'ousttrue',\r
- 'version': (2, 0),\r
- 'blender': (2, 5, 3),\r
- 'location': 'File > Import',\r
- 'description': 'Import from the Metasequioa Model Format (.mqo)',\r
- 'warning': '', # used for warning icon and text in addons panel\r
- 'wiki_url': 'http://sourceforge.jp/projects/meshio/wiki/FrontPage',\r
- 'tracker_url': 'http://sourceforge.jp/ticket/newticket.php?group_id=5081',\r
- }\r
-\r
-import os\r
-import sys\r
-\r
-try:\r
- # C extension\r
- from meshio import mqo\r
- print('use meshio C module')\r
-except ImportError:\r
- # full python\r
- from pymeshio import mqo\r
-\r
-def isBlender24():\r
- return sys.version_info[0]<3\r
-\r
-if isBlender24():\r
- # for 2.4\r
- import Blender\r
- from Blender import Mathutils\r
- import bpy\r
-\r
- # wrapper\r
- import bl24 as bl\r
-\r
- def createMqoMaterial(m):\r
- material = Blender.Material.New(\r
- m.getName().encode(bl.INTERNAL_ENCODING))\r
- #material.mode |= Blender.Material.Modes.SHADELESS\r
- # diffuse\r
- material.rgbCol = [m.color.r, m.color.g, m.color.b]\r
- material.alpha = m.color.a\r
- # other\r
- material.amb=m.ambient\r
- material.spec=m.specular\r
- material.hard=int(255 * m.power)\r
- material.emit=m.emit\r
- return material\r
-\r
-else:\r
- # for 2.5\r
- import bpy\r
-\r
- # wrapper\r
- import bl25 as bl\r
-\r
- def createMqoMaterial(m):\r
- material = bpy.data.materials.new(m.getName())\r
- # shader\r
- if m.shader==1:\r
- material.diffuse_shader='FRESNEL'\r
- else:\r
- material.diffuse_shader='LAMBERT'\r
- # diffuse\r
- material.diffuse_color=[m.color.r, m.color.g, m.color.b]\r
- material.diffuse_intensity=m.diffuse\r
- material.alpha=m.color.a\r
- # other\r
- material.ambient = m.ambient\r
- #material.specular = m.specular\r
- material.emit=m.emit\r
- material.use_shadeless=True\r
- return material\r
-\r
-\r
-def has_mikoto(mqo):\r
- #for o in mqo.objects:\r
- # if o.getName().startswith('bone'):\r
- # return True\r
- # if o.getName().startswith('sdef'):\r
- # return True\r
- # if o.getName().startswith('anchor'):\r
- # return True\r
- return False\r
-\r
-\r
-def __createMaterials(mqo, directory):\r
- """\r
- create blender materials and renturn material list.\r
- """\r
- materials = []\r
- textureMap={}\r
- imageMap={}\r
- if len(mqo.materials)>0:\r
- for material_index, m in enumerate(mqo.materials):\r
- # material\r
- material=createMqoMaterial(m)\r
- materials.append(material)\r
- # texture\r
- texture_name=m.getTexture()\r
- if texture_name!='':\r
- if texture_name in textureMap:\r
- texture=textureMap[texture_name]\r
- else:\r
- # load texture image\r
- if os.path.isabs(texture_name):\r
- # absolute\r
- path = texture_name\r
- else:\r
- # relative\r
- path = os.path.join(directory, texture_name)\r
- # texture\r
- path=path.replace("\\", "/")\r
- if os.path.exists(path):\r
- print("create texture:", path)\r
- texture, image=bl.texture.create(path)\r
- textureMap[texture_name]=texture\r
- imageMap[material_index]=image\r
- else:\r
- print("%s not exits" % path)\r
- continue\r
- bl.material.addTexture(material, texture)\r
- else:\r
- # default material\r
- pass\r
- return materials, imageMap\r
-\r
-\r
-def __createObjects(mqo, root, materials, imageMap, scale):\r
- """\r
- create blender mesh objects.\r
- """\r
- # tree stack\r
- stack=[root] \r
- objects=[]\r
- for o in mqo.objects:\r
- mesh, mesh_object=bl.mesh.create(o.getName())\r
-\r
- # add hierarchy\r
- stack_depth=len(stack)-1\r
- #print(o.depth, stack_depth)\r
- if o.depth<stack_depth:\r
- for i in range(stack_depth-o.depth):\r
- stack.pop()\r
- bl.object.makeParent(stack[-1], mesh_object)\r
- stack.append(mesh_object)\r
-\r
- if o.getName().startswith('sdef'):\r
- objects.append(mesh_object)\r
- elif o.getName().startswith('anchor'):\r
- bl.object.setLayerMask(mesh_object, [0, 1])\r
- elif o.getName().startswith('bone'):\r
- bl.object.setLayerMask(mesh_object, [0, 1])\r
-\r
- # geometry\r
- vertices=[(v.x * scale, -v.z * scale, v.y * scale) for v in o.vertices]\r
- faces=[]\r
- materialMap={}\r
- for f in o.faces:\r
- face_indices=[]\r
- # flip face\r
- for i in reversed(range(f.index_count)):\r
- face_indices.append(f.getIndex(i))\r
- faces.append(face_indices)\r
- materialMap[f.material_index]=True\r
- bl.mesh.addGeometry(mesh, vertices, faces)\r
-\r
- # blender limits 16 materials per mesh\r
- for i, material_index in enumerate(materialMap.keys()):\r
- if i>=16:\r
- # split a mesh ?\r
- print("over 16 materials!")\r
- break\r
- bl.mesh.addMaterial(mesh, materials[material_index])\r
- materialMap[material_index]=i\r
- \r
- # set face params\r
- assert(len(o.faces)==len(mesh.faces))\r
- bl.mesh.addUV(mesh)\r
- for i, (f, face) in enumerate(zip(o.faces, mesh.faces)):\r
- uv_array=[]\r
- # ToDo FIX\r
- # flip face\r
- for j in reversed(range(f.index_count)):\r
- uv_array.append((f.getUV(j).x, 1.0-f.getUV(j).y))\r
- bl.mesh.setFaceUV(mesh, i, face, uv_array, \r
- imageMap.get(f.material_index, None))\r
- if f.material_index in materialMap:\r
- bl.face.setMaterial(face, materialMap[f.material_index])\r
- bl.face.setSmooth(face, True)\r
-\r
- # mirror modifier\r
- if o.mirror:\r
- bl.modifier.addMirror(mesh_object)\r
-\r
- # set smoothing\r
- bl.mesh.setSmooth(mesh, o.smoothing)\r
-\r
- # calc normal\r
- bl.mesh.recalcNormals(mesh_object)\r
-\r
- return objects\r
-\r
-\r
-###############################################################################\r
-# for mqo mikoto bone.\r
-###############################################################################\r
-class MikotoBone(object):\r
- __slots__=[\r
- 'name',\r
- 'iHead', 'iTail', 'iUp',\r
- 'vHead', 'vTail', 'vUp',\r
- 'parent', 'isFloating',\r
- 'children',\r
- ]\r
- def __init__(self, face=None, vertices=None, materials=None):\r
- self.parent=None\r
- self.isFloating=False\r
- self.children=[]\r
- if not face:\r
- self.name='root'\r
- return\r
-\r
- self.name=materials[face.material_index].name.encode('utf-8')\r
-\r
- i0=face.getIndex(0)\r
- i1=face.getIndex(1)\r
- i2=face.getIndex(2)\r
- v0=vertices[i0]\r
- v1=vertices[i1]\r
- v2=vertices[i2]\r
- e01=v1-v0\r
- e12=v2-v1\r
- e20=v0-v2\r
- sqNorm0=e01.getSqNorm()\r
- sqNorm1=e12.getSqNorm()\r
- sqNorm2=e20.getSqNorm()\r
- if sqNorm0>sqNorm1:\r
- if sqNorm1>sqNorm2:\r
- # e01 > e12 > e20\r
- self.iHead=i2\r
- self.iTail=i1\r
- self.iUp=i0\r
- else:\r
- if sqNorm0>sqNorm2:\r
- # e01 > e20 > e12\r
- self.iHead=i2\r
- self.iTail=i0\r
- self.iUp=i1\r
- else:\r
- # e20 > e01 > e12\r
- self.iHead=i1\r
- self.iTail=i0\r
- self.iUp=i2\r
- else:\r
- # 0 < 1\r
- if sqNorm1<sqNorm2:\r
- # e20 > e12 > e01\r
- self.iHead=i1\r
- self.iTail=i2\r
- self.iUp=i0\r
- else:\r
- if sqNorm0<sqNorm2:\r
- # e12 > e20 > e01\r
- self.iHead=i0\r
- self.iTail=i2\r
- self.iUp=i1\r
- else:\r
- # e12 > e01 > e20\r
- self.iHead=i0\r
- self.iTail=i1\r
- self.iUp=i2\r
- self.vHead=vertices[self.iHead]\r
- self.vTail=vertices[self.iTail]\r
- self.vUp=vertices[self.iUp]\r
-\r
- if self.name.endswith('[]'):\r
- basename=self.name[0:-2]\r
- # expand LR name\r
- if self.vTail.x>0:\r
- self.name="%s_L" % basename\r
- else:\r
- self.name="%s_R" % basename\r
-\r
-\r
- def setParent(self, parent, floating=False):\r
- if floating:\r
- self.isFloating=True\r
- self.parent=parent\r
- parent.children.append(self)\r
-\r
- def printTree(self, indent=''):\r
- print("%s%s" % (indent, self.name))\r
- for child in self.children:\r
- child.printTree(indent+' ')\r
-\r
-\r
-def build_armature(armature, mikotoBone, parent=None):\r
- """\r
- create a armature bone.\r
- """\r
- bone = Armature.Editbone()\r
- bone.name = mikotoBone.name.encode('utf-8')\r
- armature.bones[bone.name] = bone\r
-\r
- bone.head = Mathutils.Vector(*mikotoBone.vHead.to_a())\r
- bone.tail = Mathutils.Vector(*mikotoBone.vTail.to_a())\r
- if parent:\r
- bone.parent=parent\r
- if mikotoBone.isFloating:\r
- pass\r
- else:\r
- bone.options=[Armature.CONNECTED]\r
-\r
- for child in mikotoBone.children:\r
- build_armature(armature, child, bone)\r
-\r
-\r
-def create_armature(mqo):\r
- """\r
- create armature\r
- """\r
- boneObject=None\r
- for o in mqo.objects:\r
- if o.name.startswith('bone'):\r
- boneObject=o\r
- break\r
- if not boneObject:\r
- return\r
-\r
- tailMap={}\r
- for f in boneObject.faces:\r
- if f.index_count!=3:\r
- print("invalid index_count: %d" % f.index_count)\r
- continue\r
- b=MikotoBone(f, boneObject.vertices, mqo.materials)\r
- tailMap[b.iTail]=b\r
-\r
- #################### \r
- # build mikoto bone tree\r
- #################### \r
- mikotoRoot=MikotoBone()\r
-\r
- for b in tailMap.values():\r
- # each bone has unique parent or is root bone.\r
- if b.iHead in tailMap:\r
- b.setParent(tailMap[b.iHead])\r
- else: \r
- isFloating=False\r
- for e in boneObject.edges:\r
- if b.iHead==e.indices[0]:\r
- # floating bone\r
- if e.indices[1] in tailMap:\r
- b.setParent(tailMap[e.indices[1]], True)\r
- isFloating=True\r
- break\r
- elif b.iHead==e.indices[1]:\r
- # floating bone\r
- if e.indices[0] in tailMap:\r
- b.setParent(tailMap[e.indices[0]], True)\r
- isFloating=True\r
- break\r
- if isFloating:\r
- continue\r
-\r
- # no parent bone\r
- b.setParent(mikotoRoot, True)\r
-\r
- if len(mikotoRoot.children)==0:\r
- print("no root bone")\r
- return\r
-\r
- if len(mikotoRoot.children)==1:\r
- # single root\r
- mikotoRoot=mikotoRoot.children[0]\r
- mikotoRoot.parent=None\r
- else:\r
- mikotoRoot.vHead=Vector3(0, 10, 0)\r
- mikotoRoot.vTail=Vector3(0, 0, 0)\r
-\r
- #################### \r
- # create armature\r
- #################### \r
- armature = Armature.New()\r
- # link to object\r
- armature_object = scene.objects.new(armature)\r
- # create action\r
- act = Armature.NLA.NewAction()\r
- act.setActive(armature_object)\r
- # set XRAY\r
- armature_object.drawMode |= Object.DrawModes.XRAY\r
- # armature settings\r
- armature.drawType = Armature.OCTAHEDRON\r
- armature.envelopes = False\r
- armature.vertexGroups = True\r
- armature.mirrorEdit = True\r
- armature.drawNames=True\r
-\r
- # edit bones\r
- armature.makeEditable()\r
- build_armature(armature, mikotoRoot)\r
- armature.update()\r
-\r
- return armature_object\r
- \r
-\r
-class TrianglePlane(object):\r
- """\r
- mikoto\e$BJ}<0%\!<%s$N%"%s%+!<%&%'%$%H7W;;MQ!#\e(B\r
- (\e$BIT40A4\e(B)\r
- """\r
- __slots__=['normal', \r
- 'v0', 'v1', 'v2',\r
- ]\r
- def __init__(self, v0, v1, v2):\r
- self.v0=v0\r
- self.v1=v1\r
- self.v2=v2\r
-\r
- def isInsideXY(self, p):\r
- v0=Vector2(self.v0.x, self.v0.y)\r
- v1=Vector2(self.v1.x, self.v1.y)\r
- v2=Vector2(self.v2.x, self.v2.y)\r
- e01=v1-v0\r
- e12=v2-v1\r
- e20=v0-v2\r
- c0=Vector2.cross(e01, p-v0)\r
- c1=Vector2.cross(e12, p-v1)\r
- c2=Vector2.cross(e20, p-v2)\r
- if c0>=0 and c1>=0 and c2>=0:\r
- return True\r
- if c0<=0 and c1<=0 and c2<=0:\r
- return True\r
-\r
- def isInsideYZ(self, p):\r
- v0=Vector2(self.v0.y, self.v0.z)\r
- v1=Vector2(self.v1.y, self.v1.z)\r
- v2=Vector2(self.v2.y, self.v2.z)\r
- e01=v1-v0\r
- e12=v2-v1\r
- e20=v0-v2\r
- c0=Vector2.cross(e01, p-v0)\r
- c1=Vector2.cross(e12, p-v1)\r
- c2=Vector2.cross(e20, p-v2)\r
- if c0>=0 and c1>=0 and c2>=0:\r
- return True\r
- if c0<=0 and c1<=0 and c2<=0:\r
- return True\r
-\r
- def isInsideZX(self, p):\r
- v0=Vector2(self.v0.z, self.v0.x)\r
- v1=Vector2(self.v1.z, self.v1.x)\r
- v2=Vector2(self.v2.z, self.v2.x)\r
- e01=v1-v0\r
- e12=v2-v1\r
- e20=v0-v2\r
- c0=Vector2.cross(e01, p-v0)\r
- c1=Vector2.cross(e12, p-v1)\r
- c2=Vector2.cross(e20, p-v2)\r
- if c0>=0 and c1>=0 and c2>=0:\r
- return True\r
- if c0<=0 and c1<=0 and c2<=0:\r
- return True\r
-\r
-\r
-class MikotoAnchor(object):\r
- """\r
- mikoto\e$BJ}<0%9%1%k%H%s$N%"%s%+!<!#\e(B\r
- """\r
- __slots__=[\r
- "triangles", "bbox",\r
- ]\r
- def __init__(self):\r
- self.triangles=[]\r
- self.bbox=None\r
-\r
- def push(self, face, vertices):\r
- if face.index_count==3:\r
- self.triangles.append(TrianglePlane(\r
- vertices[face.indices[0]],\r
- vertices[face.indices[1]],\r
- vertices[face.indices[2]]\r
- ))\r
- elif face.index_count==4:\r
- self.triangles.append(TrianglePlane(\r
- vertices[face.indices[0]],\r
- vertices[face.indices[1]],\r
- vertices[face.indices[2]]\r
- ))\r
- self.triangles.append(TrianglePlane(\r
- vertices[face.indices[2]],\r
- vertices[face.indices[3]],\r
- vertices[face.indices[0]]\r
- ))\r
- # bounding box\r
- if not self.bbox:\r
- self.bbox=BoundingBox(vertices[face.indices[0]])\r
- for i in face.indices:\r
- self.bbox.expand(vertices[i])\r
-\r
-\r
- def calcWeight(self, v):\r
- if not self.bbox.isInside(v):\r
- return 0\r
-\r
- if self.anyXY(v.x, v.y) and self.anyYZ(v.y, v.z) and self.anyZX(v.z, v.x):\r
- return 1.0\r
- else:\r
- return 0\r
- \r
- def anyXY(self, x, y):\r
- for t in self.triangles:\r
- if t.isInsideXY(Vector2(x, y)):\r
- return True\r
- return False\r
-\r
- def anyYZ(self, y, z):\r
- for t in self.triangles:\r
- if t.isInsideYZ(Vector2(y, z)):\r
- return True\r
- return False\r
-\r
- def anyZX(self, z, x):\r
- for t in self.triangles:\r
- if t.isInsideZX(Vector2(z, x)):\r
- return True\r
- return False\r
-\r
-\r
-def create_bone_weight(scene, mqo, armature_object, objects):\r
- """\r
- create mikoto bone weight.\r
- """\r
- anchorMap={}\r
- # setup mikoto anchors\r
- for o in mqo.objects:\r
- if o.name.startswith("anchor"):\r
- for f in o.faces:\r
- name=mqo.materials[f.material_index].name\r
- if name.endswith('[]'):\r
- basename=name[0:-2]\r
- v=o.vertices[f.indices[0]]\r
- if(v.x>0):\r
- # L\r
- name_L=basename+'_L'\r
- if not name_L in anchorMap:\r
- anchorMap[name_L]=MikotoAnchor()\r
- anchorMap[name_L].push(f, o.vertices)\r
- elif(v.x<0):\r
- # R\r
- name_R=basename+'_R'\r
- if not name_R in anchorMap:\r
- anchorMap[name_R]=MikotoAnchor()\r
- anchorMap[name_R].push(f, o.vertices)\r
- else:\r
- print("no side", v)\r
- else:\r
- if not name in anchorMap:\r
- anchorMap[name]=MikotoAnchor()\r
- anchorMap[name].push(f, o.vertices)\r
-\r
- for o in objects:\r
- # add armature modifier\r
- mod=o.modifiers.append(Modifier.Types.ARMATURE)\r
- mod[Modifier.Settings.OBJECT] = armature_object\r
- mod[Modifier.Settings.ENVELOPES] = False\r
- o.makeDisplayList()\r
- # create vertex group\r
- mesh=o.getData(mesh=True)\r
- for name in anchorMap.keys():\r
- mesh.addVertGroup(name)\r
- mesh.update()\r
- \r
- # assing vertices to vertex group\r
- for o in objects:\r
- mesh=o.getData(mesh=True)\r
- for i, mvert in enumerate(mesh.verts):\r
- hasWeight=False\r
- for name, anchor in anchorMap.items():\r
- weight=anchor.calcWeight(mvert.co)\r
- if weight>0:\r
- mesh.assignVertsToGroup(\r
- name, [i], weight, Mesh.AssignModes.ADD)\r
- hasWeight=True\r
- if not hasWeight:\r
- # debug orphan vertex\r
- print('orphan', mvert)\r
- mesh.update()\r
-\r
-\r
-def __execute(filename, scene, scale=0.1):\r
- # parse file\r
- io=mqo.IO()\r
- if not io.read(filename):\r
- bl.message("fail to load %s" % filename)\r
- return\r
-\r
- # create materials\r
- materials, imageMap=__createMaterials(io, os.path.dirname(filename))\r
- if len(materials)==0:\r
- materials.append(bl.material.create('default'))\r
-\r
- # create objects\r
- root=bl.object.createEmpty(os.path.basename(filename))\r
- objects=__createObjects(io, root, materials, imageMap, scale)\r
-\r
- if has_mikoto(io):\r
- # create mikoto bone\r
- armature_object=create_armature(io)\r
- if armature_object:\r
- root.makeParent([armature_object])\r
-\r
- # create bone weight\r
- create_bone_weight(io, armature_object, objects)\r
-\r
- \r
-###############################################################################\r
-# register\r
-###############################################################################\r
-if isBlender24():\r
- # for 2.4\r
- def execute_24(filename):\r
- scene=Blender.Scene.GetCurrent()\r
- bl.initialize('mqo_import', scene)\r
- __execute(\r
- filename.decode(bl.INTERNAL_ENCODING), \r
- scene)\r
- bl.finalize()\r
-\r
- # execute\r
- Blender.Window.FileSelector(execute_24, 'Import MQO', '*.mqo')\r
-\r
-else:\r
- # for 2.5\r
- def execute_25(filename, scene, scale):\r
- bl.initialize('mqo_import', scene)\r
- __execute(filename, scene, scale)\r
- bl.finalize()\r
-\r
- # operator\r
- class IMPORT_OT_mqo(bpy.types.Operator):\r
- '''Import from Metasequoia file format (.mqo)'''\r
- bl_idname = "import_scene.mqo"\r
- bl_label = 'Import MQO'\r
-\r
- # List of operator properties, the attributes will be assigned\r
- # to the class instance from the operator settings before calling.\r
- filepath = bpy.props.StringProperty()\r
- filename = bpy.props.StringProperty()\r
- directory = bpy.props.StringProperty()\r
-\r
- scale = bpy.props.FloatProperty(\r
- name="Scale", \r
- description="Scale the MQO by this value", \r
- min=0.0001, max=1000000.0, \r
- soft_min=0.001, soft_max=100.0, default=0.1)\r
-\r
- def execute(self, context):\r
- execute_25(\r
- self.properties.filepath, \r
- context.scene, \r
- self.properties.scale)\r
- return 'FINISHED'\r
-\r
- def invoke(self, context, event):\r
- wm=context.window_manager\r
- try:\r
- wm.fileselect_add(self)\r
- except:\r
- wm.add_fileselect(self)\r
- return 'RUNNING_MODAL'\r
-\r
-\r
- # register menu\r
- def menu_func(self, context): \r
- self.layout.operator(\r
- IMPORT_OT_mqo.bl_idname, \r
- text="Metasequoia (.mqo)",\r
- icon='PLUGIN'\r
- )\r
-\r
- def register():\r
- bpy.types.INFO_MT_file_import.append(menu_func)\r
-\r
- def unregister():\r
- bpy.types.INFO_MT_file_import.remove(menu_func)\r
-\r
- if __name__=="__main__":\r
- register()\r
-\r
OSDN Git Service
