"""\r
__author__=['ousttrue']\r
__url__ = ["http://gunload.web.fc2.com/blender/"]\r
-__version__= '0.6 2010/05/05'\r
+__version__= '2.0'\r
__bpydoc__= '''\\r
\r
MQO Importer\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
'''\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
+ }\r
\r
-###############################################################################\r
-# import\r
-###############################################################################\r
import os\r
import sys\r
\r
-# C extension\r
-from meshio import mqo\r
+try:\r
+ # C extension\r
+ from meshio import mqo\r
+except ImportError:\r
+ # full python\r
+ from pymeshio import mqo\r
\r
def isBlender24():\r
return sys.version_info[0]<3\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
- from bpy.props import *\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
+ return material\r
+\r
\r
def has_mikoto(mqo):\r
#for o in mqo.objects:\r
return False\r
\r
\r
-def __createMaterials(scene, mqo, directory):\r
+def __createMaterials(mqo, directory):\r
"""\r
create blender materials and renturn material list.\r
"""\r
if len(mqo.materials)>0:\r
for material_index, m in enumerate(mqo.materials):\r
# material\r
- material=bl.createMqoMaterial(m)\r
+ material=createMqoMaterial(m)\r
materials.append(material)\r
# texture\r
texture_name=m.getTexture()\r
# texture\r
if os.path.exists(path):\r
print("create texture:", path)\r
- texture, image=bl.createTexture(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.materialAddTexture(material, texture)\r
+ bl.material.addTexture(material, texture)\r
else:\r
# default material\r
pass\r
return materials, imageMap\r
\r
\r
-def __createObjects(scene, mqo, root, materials, imageMap, scale):\r
+def __createObjects(mqo, root, materials, imageMap, scale):\r
"""\r
create blender mesh objects.\r
"""\r
stack=[root] \r
objects=[]\r
for o in mqo.objects:\r
- mesh, mesh_object=bl.createMesh(scene, o.getName())\r
+ mesh, mesh_object=bl.mesh.create(o.getName())\r
\r
# add hierarchy\r
stack_depth=len(stack)-1\r
if o.depth<stack_depth:\r
for i in range(stack_depth-o.depth):\r
stack.pop()\r
- bl.objectMakeParent(stack[-1], mesh_object)\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.objectLayerMask(mesh_object, [0, 1])\r
+ bl.object.setLayerMask(mesh_object, [0, 1])\r
elif o.getName().startswith('bone'):\r
- bl.objectLayerMask(mesh_object, [0, 1])\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
face_indices.append(f.getIndex(i))\r
faces.append(face_indices)\r
materialMap[f.material_index]=True\r
- bl.meshAddGeometry(mesh, vertices, faces)\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
# split a mesh ?\r
print("over 16 materials!")\r
break\r
- bl.meshAddMaterial(mesh, materials[material_index])\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.meshAddUV(mesh)\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.meshSetFaceUv(mesh, i, face, uv_array, \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.faceSetMaterial(face, materialMap[f.material_index])\r
- bl.faceSetSmooth(face, True)\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.objectAddMirrorModifier(mesh_object)\r
+ bl.modifier.addMirror(mesh_object)\r
\r
# set smoothing\r
- bl.meshSetSmooth(mesh, o.smoothing)\r
+ bl.mesh.setSmooth(mesh, o.smoothing)\r
\r
# calc normal\r
- #bl.meshRecalcNormals(mesh_object)\r
+ bl.mesh.recalcNormals(mesh_object)\r
\r
return objects\r
\r
build_armature(armature, child, bone)\r
\r
\r
-def create_armature(scene, mqo):\r
+def create_armature(mqo):\r
"""\r
create armature\r
"""\r
# parse file\r
io=mqo.IO()\r
if not io.read(filename):\r
- print("fail to load",filename)\r
+ bl.message("fail to load %s" % filename)\r
return\r
\r
# create materials\r
- materials, imageMap=__createMaterials(scene, io, os.path.dirname(filename))\r
+ materials, imageMap=__createMaterials(io, os.path.dirname(filename))\r
if len(materials)==0:\r
- materials.append(bl.createMaterial('default'))\r
+ materials.append(bl.material.create('default'))\r
\r
# create objects\r
- root=bl.createEmptyObject(scene, os.path.basename(filename))\r
- objects=__createObjects(scene, io, root, materials, imageMap, scale)\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(scene, io)\r
+ armature_object=create_armature(io)\r
if armature_object:\r
root.makeParent([armature_object])\r
\r
# create bone weight\r
- create_bone_weight(scene, io, armature_object, objects)\r
+ create_bone_weight(io, armature_object, objects)\r
\r
\r
###############################################################################\r
if isBlender24():\r
# for 2.4\r
def execute_24(filename):\r
- """\r
- import a mqo file.\r
- """\r
- filename=filename.decode(bl.INTERNAL_ENCODING)\r
- print("##start mqo_import.py##")\r
- print(bl.INTERNAL_ENCODING, bl.FS_ENCODING)\r
- print("parse mqo file: %s" % (filename))\r
-\r
- Blender.Window.WaitCursor(1) \r
- t = Blender.sys.time() \r
-\r
- # execute\r
- scene = Blender.Scene.GetCurrent()\r
- __execute(filename, scene)\r
- scene.update(0)\r
-\r
- print('finished in %.2f seconds' % (Blender.sys.time()-t))\r
- print('')\r
- Blender.Redraw()\r
- Blender.Window.WaitCursor(0) \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(*args):\r
- __execute(*args)\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
\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
- path = StringProperty(\r
- name="File Path", \r
- description="File path used for importing the MQO file", \r
- maxlen= 1024, default= "")\r
- filename = StringProperty(\r
- name="File Name", \r
- description="Name of the file.")\r
- directory = StringProperty(\r
- name="Directory", \r
- description="Directory of the file.")\r
-\r
- scale = FloatProperty(\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.01)\r
+ soft_min=0.001, soft_max=100.0, default=0.1)\r
\r
def execute(self, context):\r
execute_25(\r
- self.properties.path, \r
+ self.properties.filepath, \r
context.scene, \r
self.properties.scale)\r
return 'FINISHED'\r
def menu_func(self, context): \r
self.layout.operator(\r
IMPORT_OT_mqo.bl_idname, \r
- text="Metasequoia (.mqo)")\r
+ text="Metasequoia (.mqo)",\r
+ icon='PLUGIN'\r
+ )\r
\r
def register():\r
bpy.types.register(IMPORT_OT_mqo)\r
OSDN Git Service
