pymeshio/pymeshio/mqo.py

   1 #!BPY\r
   2 """ \r
   3 Name: 'Metasequoia(.mqo)...'\r
   4 Blender: 245\r
   5 Group: 'Import'\r
   6 Tooltip: 'Import from Metasequoia file format (.mqo)'\r
   7 """\r
   8 __author__= 'ousttrue'\r
   9 __url__ = ["http://gunload.web.fc2.com/blender/"]\r
  10 __version__= '0.4 2009/11/25'\r
  11 __bpydoc__= '''\\r
  12 \r
  13 MQO Importer\r
  14 \r
  15 This script imports a mqo file.\r
  16 \r
  17 0.2 20080123: update.\r
  18 0.3 20091125: modify for linux.\r
  19 0.4 20100310: rewrite.\r
  20 0.5 20100311: create armature from mikoto bone.\r
  21 '''\r
  22 \r
  23 import os\r
  24 import sys\r
  25 import math\r
  26 \r
  27 \r
  28 class RGBA(object):\r
  29     __slots__=['r', 'g', 'b', 'a']\r
  30     def __init__(self, r=0, g=0, b=0, a=0):\r
  31         self.r=r\r
  32         self.g=g\r
  33         self.b=b\r
  34         self.a=a\r
  35 \r
  36 class Vector3(object):\r
  37     __slots__=['x', 'y', 'z']\r
  38     def __init__(self, x=0, y=0, z=0):\r
  39         self.x=x\r
  40         self.y=y\r
  41         self.z=z\r
  42 \r
  43     def __str__(self):\r
  44         return "[%f, %f, %f]" % (self.x, self.y, self.z)\r
  45 \r
  46     def __sub__(self, rhs):\r
  47         return Vector3(self.x-rhs.x, self.y-rhs.y, self.z-rhs.z)\r
  48 \r
  49     def getSqNorm(self):\r
  50         return self.x*self.x + self.y*self.y + self.z*self.z\r
  51 \r
  52     def getNorm(self):\r
  53         return math.sqrt(self.getSqNorm())\r
  54 \r
  55     def normalize(self):\r
  56         factor=1.0/self.getNorm()\r
  57         self.x*=factor\r
  58         self.y*=factor\r
  59         self.z*=factor\r
  60         return self\r
  61 \r
  62     def to_a(self):\r
  63         return [self.x, self.y, self.z]\r
  64 \r
  65     @staticmethod\r
  66     def dot(lhs, rhs):\r
  67         return lhs.x*rhs.x + lhs.y*rhs.y + lhs.z*rhs.z\r
  68 \r
  69     @staticmethod\r
  70     def cross(lhs, rhs):\r
  71         return Vector3(\r
  72                 lhs.y*rhs.z - rhs.y*lhs.z,\r
  73                 lhs.z*rhs.x - rhs.z*lhs.x,\r
  74                 lhs.x*rhs.y - rhs.x*lhs.y,\r
  75                 )\r
  76 \r
  77 \r
  78 class Vector2(object):\r
  79     __slots__=['x', 'y']\r
  80     def __init__(self, x=0, y=0):\r
  81         self.x=x\r
  82         self.y=y\r
  83 \r
  84     def __str__(self):\r
  85         return "[%f, %f]" % (self.x, self.y)\r
  86 \r
  87     def __sub__(self, rhs):\r
  88         return Vector3(self.x-rhs.x, self.y-rhs.y)\r
  89 \r
  90     @staticmethod\r
  91     def cross(lhs, rhs):\r
  92         return lhs.x*rhs.y-lhs.y*rhs.x\r
  93 \r
  94 \r
  95 ###############################################################################\r
  96 # MQO loader\r
  97 ###############################################################################\r
  98 class Material(object):\r
  99     __slots__=[\r
 100             "name", "shader", "color", "diffuse", \r
 101             "ambient", "emit", "specular", "power",\r
 102             "tex",\r
 103             ]\r
 104     def __init__(self, name):\r
 105         self.name=name\r
 106         self.shader=3\r
 107         self.color=RGBA(0.5, 0.5, 0.5, 1.0)\r
 108         self.diffuse=1.0\r
 109         self.ambient=0.0\r
 110         self.emit=0.0\r
 111         self.specular=0.0\r
 112         self.power=5.0\r
 113         self.tex=""\r
 114 \r
 115     def getName(self): return self.name\r
 116     def getTexture(self): return self.tex\r
 117 \r
 118     def parse(self, line):\r
 119         offset=0\r
 120         while True:\r
 121             leftParenthesis=line.find("(", offset)\r
 122             if leftParenthesis==-1:\r
 123                 break\r
 124             key=line[offset:leftParenthesis]\r
 125             rightParenthesis=line.find(")", leftParenthesis+1)\r
 126             if rightParenthesis==-1:\r
 127                 raise ValueError("assert")\r
 128 \r
 129             param=line[leftParenthesis+1:rightParenthesis]\r
 130             if key=="shader":\r
 131                 self.shader=int(param)\r
 132             elif key=="col":\r
 133                 self.color=RGBA(*[float(e) for e in param.split()])\r
 134             elif key=="dif":\r
 135                 self.diffuse=float(param)\r
 136             elif key=="amb":\r
 137                 self.ambient=float(param)\r
 138             elif key=="emi":\r
 139                 self.emit=float(param)\r
 140             elif key=="spc":\r
 141                 self.specular=float(param)\r
 142             elif key=="power":\r
 143                 self.power=float(param)\r
 144             elif key=="tex":\r
 145                 self.tex=param[1:-1]\r
 146             else:\r
 147                 print(\r
 148                         "%s#parse" % self.name, \r
 149                         "unknown key: %s" %  key\r
 150                         )\r
 151 \r
 152             offset=rightParenthesis+2\r
 153 \r
 154     def __str__(self):\r
 155         return "<Material %s shader: %d [%f, %f, %f, %f] %f>" % (\r
 156                 self.name, self.shader,\r
 157                 self.color[0], self.color[1], self.color[2], self.color[3],\r
 158                 self.diffuse)\r
 159 \r
 160 \r
 161 class Obj(object):\r
 162     __slots__=["name", "depth", "folding", \r
 163             "scale", "rotation", "translation",\r
 164             "visible", "locking", "shading", "facet",\r
 165             "color", "color_type", "mirror", "mirror_axis",\r
 166             "vertices", "faces", "edges", "smoothing",\r
 167             ]\r
 168 \r
 169     def __init__(self, name):\r
 170         self.name=name\r
 171         self.vertices=[]\r
 172         self.faces=[]\r
 173         self.edges=[]\r
 174         self.depth=0\r
 175         self.folding=0\r
 176         self.scale=[1, 1, 1]\r
 177         self.rotation=[0, 0, 0]\r
 178         self.translation=[0, 0, 0]\r
 179         self.visible=15\r
 180         self.locking=0\r
 181         self.shading=0\r
 182         self.facet=59.5\r
 183         self.color=[1, 1, 1]\r
 184         self.color_type=0\r
 185         self.mirror=0\r
 186         self.smoothing=0\r
 187 \r
 188     def getName(self): return self.name\r
 189 \r
 190     def addVertex(self, x, y, z):\r
 191         self.vertices.append(Vector3(x, y, z))\r
 192 \r
 193     def addFace(self, face):\r
 194         if face.index_count==2:\r
 195             self.edges.append(face)\r
 196         else:\r
 197             self.faces.append(face)\r
 198 \r
 199     def __str__(self):\r
 200         return "<Object %s, %d vertices, %d faces>" % (\r
 201                 self.name, len(self.vertices), len(self.faces))\r
 202 \r
 203 \r
 204 class Face(object):\r
 205     __slots__=[\r
 206             "index_count",\r
 207             "indices", "material_index", "col", "uv",\r
 208             ]\r
 209     def __init__(self, index_count, line):\r
 210         if index_count<2 or index_count>4:\r
 211             raise ValueError("invalid vertex count: %d" % index_count)\r
 212         self.material_index=0\r
 213         self.col=[]\r
 214         self.uv=[Vector2(0, 0)]*4\r
 215         self.index_count=index_count\r
 216         offset=0\r
 217         while True:\r
 218             leftParenthesis=line.find("(", offset)\r
 219             if leftParenthesis==-1:\r
 220                 break\r
 221             key=line[offset:leftParenthesis]\r
 222             rightParenthesis=line.find(")", leftParenthesis+1)\r
 223             if rightParenthesis==-1:\r
 224                 raise ValueError("assert")\r
 225             params=line[leftParenthesis+1:rightParenthesis].split()\r
 226             if key=="V":\r
 227                 self.indices=[int(e) for e in params]\r
 228             elif key=="M":\r
 229                 self.material_index=int(params[0])\r
 230             elif key=="UV":\r
 231                 uv_list=[float(e) for e in params]\r
 232                 self.uv=[]\r
 233                 for i in range(0, len(uv_list), 2):\r
 234                     self.uv.append(Vector2(uv_list[i], uv_list[i+1]))\r
 235             elif key=="COL":\r
 236                 for n in params:\r
 237                     d=int(n)\r
 238                     # R\r
 239                     d, m=divmod(d, 256)\r
 240                     self.col.append(m)\r
 241                     # G\r
 242                     d, m=divmod(d, 256)\r
 243                     self.col.append(m)\r
 244                     # B\r
 245                     d, m=divmod(d, 256)\r
 246                     self.col.append(m)\r
 247                     # A\r
 248                     d, m=divmod(d, 256)\r
 249                     self.col.append(m)\r
 250             else:\r
 251                 print("Face#__init__:unknown key: %s" % key)\r
 252 \r
 253             offset=rightParenthesis+2\r
 254 \r
 255     def getIndex(self, i): return self.indices[i]\r
 256     def getUV(self, i): return self.uv[i] if i<len(self.uv) else Vector2(0, 0)\r
 257 \r
 258 \r
 259 def withio(method):\r
 260     def new(self, path):\r
 261         self.io=open(path, encoding='cp932')\r
 262         result=method(self)\r
 263         self.io=None\r
 264         return result\r
 265     return new\r
 266 \r
 267 \r
 268 class IO(object):\r
 269     __slots__=[\r
 270             "has_mikoto",\r
 271             "eof", "io", "lines",\r
 272             "materials", "objects",\r
 273             ]\r
 274     def __init__(self):\r
 275         self.has_mikoto=False\r
 276         self.eof=False\r
 277         self.io=None\r
 278         self.lines=0\r
 279         self.materials=[]\r
 280         self.objects=[]\r
 281 \r
 282     def __str__(self):\r
 283         return "<MQO %d lines, %d materials, %d objects>" % (\r
 284                 self.lines, len(self.materials), len(self.objects))\r
 285 \r
 286     def getline(self):\r
 287         line=self.io.readline()\r
 288         self.lines+=1\r
 289         if line=="":\r
 290             self.eof=True\r
 291             return None\r
 292         return line.strip()\r
 293 \r
 294     def printError(self, method, msg):\r
 295         print("%s:%s:%d" % (method, msg, self.lines))\r
 296 \r
 297     @withio\r
 298     def read(self):\r
 299         line=self.getline()\r
 300         if line!="Metasequoia Document":\r
 301             print("invalid signature")\r
 302             return False\r
 303 \r
 304         line=self.getline()\r
 305         if line!="Format Text Ver 1.0":\r
 306             print("unknown version: %s" % line)\r
 307 \r
 308         while True:\r
 309             line=self.getline()\r
 310             if line==None:\r
 311                 # eof\r
 312                 break;\r
 313             if line=="":\r
 314                 # empty line\r
 315                 continue\r
 316 \r
 317             tokens=line.split()\r
 318             key=tokens[0]\r
 319 \r
 320             if key=="Eof":\r
 321                 return True\r
 322             elif key=="Scene":\r
 323                 if not self.readChunk():\r
 324                     return False\r
 325             elif key=="Material":\r
 326                 if not self.readMaterial():\r
 327                     return False\r
 328             elif key=="Object":\r
 329                 firstQuote=line.find('"')\r
 330                 secondQuote=line.find('"', firstQuote+1)\r
 331                 if not self.readObject(line[firstQuote+1:secondQuote]):\r
 332                     return False\r
 333             elif key=="BackImage":\r
 334                 if not self.readChunk():\r
 335                     return False\r
 336             elif key=="IncludeXml":\r
 337                 firstQuote=line.find('"')\r
 338                 secondQuote=line.find('"', firstQuote+1)\r
 339                 print("IncludeXml", line[firstQuote+1:secondQuote])\r
 340             else:\r
 341                 print("unknown key: %s" % key)\r
 342                 if not self.readChunk():\r
 343                     return False\r
 344 \r
 345         self.printError("parse", "invalid eof")\r
 346         return False\r
 347 \r
 348     def readObject(self, name):\r
 349         obj=Obj(name)\r
 350         if name.startswith('bone'):\r
 351             self.has_mikoto=True\r
 352         self.objects.append(obj)\r
 353         while(True):\r
 354             line=self.getline()\r
 355             if line==None:\r
 356                 # eof\r
 357                 break;\r
 358             if line=="":\r
 359                 # empty line\r
 360                 continue\r
 361 \r
 362             if line=="}":\r
 363                 return True\r
 364             else:\r
 365                 tokens=line.split()\r
 366                 key=tokens[0]\r
 367                 if key=="vertex":\r
 368                     if not self.readVertex(obj):\r
 369                         return False\r
 370                 elif key=="face":\r
 371                     if not self.readFace(obj):\r
 372                         return False\r
 373                 elif key=="depth":\r
 374                     obj.depth=int(tokens[1])\r
 375                 else:\r
 376                     print(\r
 377                             "%s#readObject" % name,\r
 378                             "unknown key: %s" % name\r
 379                             )\r
 380 \r
 381         self.printError("readObject", "invalid eof")\r
 382         return False\r
 383 \r
 384     def readFace(self, obj):\r
 385         while(True):\r
 386             line=self.getline()\r
 387             if line==None:\r
 388                 # eof\r
 389                 break;\r
 390             if line=="":\r
 391                 # empty line\r
 392                 continue\r
 393 \r
 394             if line=="}":\r
 395                 return True\r
 396             else:\r
 397                 # face\r
 398                 tokens=line.split(' ', 1)\r
 399                 try:\r
 400                     obj.addFace(Face(int(tokens[0]), tokens[1]))\r
 401                 except ValueError as ex:\r
 402                     self.printError("readFace", ex)\r
 403                     #return False\r
 404 \r
 405         self.printError("readFace", "invalid eof")\r
 406         return False\r
 407 \r
 408     def readVertex(self, obj):\r
 409         while(True):\r
 410             line=self.getline()\r
 411             if line==None:\r
 412                 # eof\r
 413                 break;\r
 414             if line=="":\r
 415                 # empty line\r
 416                 continue\r
 417 \r
 418             if line=="}":\r
 419                 return True\r
 420             else:\r
 421                 # vertex\r
 422                 obj.addVertex(*[float(v) for v in line.split()])\r
 423 \r
 424         self.printError("readVertex", "invalid eof")\r
 425         return False\r
 426 \r
 427     def readMaterial(self):\r
 428         while(True):\r
 429             line=self.getline()\r
 430             if line==None:\r
 431                 # eof\r
 432                 break;\r
 433             if line=="":\r
 434                 # empty line\r
 435                 continue\r
 436 \r
 437             if line=="}":\r
 438                 return True\r
 439             else:\r
 440                 # material\r
 441                 secondQuaote=line.find('"', 1)                \r
 442                 material=Material(line[1:secondQuaote])\r
 443                 try:\r
 444                     material.parse(line[secondQuaote+2:])\r
 445                 except ValueError as ex:\r
 446                     self.printError("readMaterial", ex)\r
 447 \r
 448                 self.materials.append(material)\r
 449 \r
 450         self.printError("readMaterial", "invalid eof")\r
 451         return False\r
 452 \r
 453     def readChunk(self):\r
 454         level=1\r
 455         while(True):\r
 456             line=self.getline()\r
 457             if line==None:\r
 458                 # eof\r
 459                 break;\r
 460             if line=="":\r
 461                 # empty line\r
 462                 continue\r
 463 \r
 464             if line=="}":\r
 465                 level-=1\r
 466                 if level==0:\r
 467                     return True\r
 468             elif line.find("{")!=-1:\r
 469                 level+=1\r
 470 \r
 471         self.printError("readChunk", "invalid eof")\r
 472         return False\r
 473 \r