mesh_export.py

   1 #!BPY
   2 # $Id$
   3
   4 """
   5 Name: 'MSP GL Mesh (.mesh)...'
   6 Blender: 244
   7 Group: 'Export'
   8 """
   9
  10 import sys
  11 import math
  12 import bpy
  13 import Blender
  14
  15 def make_edge_key(i1, i2):
  16         return (min(i1, i2), max(i1, i2))
  17
  18
  19 class Edge:
  20         def __init__(self, me):
  21                 if me.__class__==Edge:
  22                         self._medge=me._medge
  23                         self.smooth=me.smooth
  24                 else:
  25                         self._medge=me
  26                         self.smooth=False
  27                 self.faces=[]
  28
  29         def __getattr__(self, attr):
  30                 return getattr(self._medge, attr)
  31
  32         def __cmp__(self, other):
  33                 return self is other
  34
  35         def check_smooth(self, limit):
  36                 if len(self.faces)!=2:
  37                         return
  38
  39                 d=Blender.Mathutils.DotVecs(self.faces[0].no, self.faces[1].no)
  40                 if (d>limit and self.faces[0].smooth and self.faces[1].smooth) or d>0.999:
  41                         self.smooth=True
  42
  43         def other_face(self, f):
  44                 if f.index==self.faces[0].index:
  45                         if len(self.faces)>=2:
  46                                 return self.faces[1]
  47                         else:
  48                                 return None
  49                 else:
  50                         return self.faces[0]
  51
  52
  53 class Vertex:
  54         def __init__(self, mv):
  55                 if mv.__class__==Vertex:
  56                         self._mvert=mv._mvert
  57                         self.uv=mv.uv
  58                 else:
  59                         self._mvert=mv
  60                         self.uv=None
  61                 self.orig_index=self._mvert.index
  62                 self.flag=False
  63                 self.faces=[]
  64
  65         def __getattr__(self, attr):
  66                 return getattr(self._mvert, attr)
  67
  68         def __cmp__(self, other):
  69                 return cmp(self.index, other.index)
  70
  71         def __str__(self):
  72                 return "<Vert %d (%.4f, %.4f, %.4f) (%.4f, %.4f, %.4f)>"%(self.index, self.co[0], self.co[1], self.co[2], self.no[0], self.no[1], self.no[2])
  73
  74         __repr__=__str__
  75
  76
  77 class Face:
  78         def __init__(self, mf):
  79                 self._mface=mf
  80                 self.edges=[]
  81                 self.verts=[v for v in mf.verts]
  82                 self.flag=False
  83
  84         def __getattr__(self, attr):
  85                 return getattr(self._mface, attr)
  86
  87         def __cmp__(self, other):
  88                 return cmp(self.index, other.index)
  89
  90         def __str__(self):
  91                 return "<Face %d (%s)>"%(self.index, " ".join([str(v.index) for v in self.verts]))
  92
  93         __repr__=__str__
  94
  95         def get_vertices_from(self, reverse, *vt):
  96                 verts=self.verts[:]
  97                 if reverse:
  98                         verts.reverse()
  99                 indices=[u.index for u in vt]
 100                 flags=[(v.index in indices) for v in verts]
 101                 l=len(verts)
 102                 for i in range(l):
 103                         if flags[i] and not flags[(i+l-1)%l]:
 104                                 return verts[i:]+verts[:i]
 105
 106         def get_edge(self, v1, v2):
 107                 key=make_edge_key(v1.index, v2.index)
 108                 for e in self.edges:
 109                         if e.key==key:
 110                                 return e
 111
 112
 113 class Line:
 114         def __init__(self, e):
 115                 self.edge=e
 116                 self.verts=[e.v1, e.v2]
 117                 self.flag=False
 118
 119         def __str__(self):
 120                 return "<Line (%d %d)>"%(self.verts[0].index, self.verts[1].index)
 121
 122         __repr__=__str__
 123
 124
 125 class Mesh:
 126         def __init__(self, m):
 127                 self._mesh=m
 128                 self.verts=[Vertex(v) for v in m.verts]
 129                 self.faces=[Face(f) for f in m.faces]
 130
 131                 for f in self.faces:
 132                         for i in range(len(f.verts)):
 133                                 f.verts[i]=self.verts[f.verts[i].index]
 134                                 f.verts[i].faces.append(f)
 135
 136                 self.edges=dict([(e.key, Edge(e)) for e in m.edges])
 137                 for f in self.faces:
 138                         for k in f.edge_keys:
 139                                 e=self.edges[k]
 140                                 e.faces.append(self.faces[f.index])
 141                                 f.edges.append(e)
 142
 143                 self.lines=[Line(e) for e in self.edges.itervalues() if not e.faces]
 144
 145                 smooth_limit=math.cos(m.degr*math.pi/180)
 146                 for e in self.edges.itervalues():
 147                         e.v1=self.verts[e.v1.index]
 148                         e.v2=self.verts[e.v2.index]
 149                         e.check_smooth(smooth_limit)
 150
 151         def __getattr__(self, attr):
 152                 return getattr(self._mesh, attr)
 153
 154         def split_vertices(self, debug=False):
 155                 groups=[]
 156                 for v in self.verts:
 157                         for f in v.faces:
 158                                 f.flag=False
 159
 160                         vg=[]
 161                         for f in v.faces:
 162                                 if not f.flag:
 163                                         vg.append(self.find_group(v, f))
 164
 165                         groups.append(vg)
 166
 167                 for i in range(len(self.verts)):
 168                         if len(groups[i])==1:
 169                                 continue
 170
 171                         if debug:
 172                                 print "Vertex %s has %d groups"%(self.verts[i], len(groups[i]))
 173
 174                         for g in groups[i][1:]:
 175                                 v=Vertex(self.verts[i])
 176                                 v.index=len(self.verts)
 177                                 self.verts.append(v)
 178
 179                                 if debug:
 180                                         print "  -> %d"%v.index
 181
 182                                 for f in g:
 183                                         for j in range(len(f.edges)):
 184                                                 e=f.edges[j]
 185
 186                                                 if e.v1!=self.verts[i] and e.v2!=self.verts[i]:
 187                                                         continue
 188
 189                                                 if debug:
 190                                                         print "  Splitting edge %s with faces %s"%(e.key, e.faces)
 191
 192                                                 if not e.smooth:
 193                                                         if len(e.faces)>=2:
 194                                                                 k=e.faces.index(f)
 195                                                                 e.faces.remove(f)
 196                                                                 e=Edge(e)
 197                                                                 f.edges[j]=e
 198                                                                 e.faces.append(f)
 199                                                         else:
 200                                                                 del self.edges[e.key]
 201
 202                                                 if e.v1==self.verts[i]:
 203                                                         e.v1=v
 204                                                 elif e.v2==self.verts[i]:
 205                                                         e.v2=v
 206
 207                                                 e.key=make_edge_key(e.v1.index, e.v2.index)
 208                                                 if not e.smooth:
 209                                                         self.edges[e.key]=e
 210
 211                                         self.verts[i].faces.remove(f)
 212                                         f.verts[f.verts.index(self.verts[i])]=v
 213                                         v.faces.append(f)
 214
 215         def find_group(self, vert, face):
 216                 face_indices=[f.index for f in vert.faces]
 217
 218                 face.flag=True
 219                 queue=[face]
 220
 221                 for f in queue:
 222                         for e in f.edges:
 223                                 other=e.other_face(f)
 224                                 if not other or other.index not in face_indices:
 225                                         continue
 226
 227                                 if e.smooth:
 228                                         if not other.flag:
 229                                                 other.flag=True
 230                                                 queue.append(other)
 231
 232                 return queue
 233
 234         def compute_normals(self):
 235                 for v in self.verts:
 236                         if v.faces:
 237                                 v.no=Blender.Mathutils.Vector()
 238                                 for f in v.faces:
 239                                         v.no+=f.no
 240                                 v.no.normalize()
 241                         else:
 242                                 # XXX Should use edges to compute normal
 243                                 v.no=Blender.Mathutils.Vector(0, 0, 1)
 244
 245         def create_strip(self, face, reverse, debug):
 246                 edge=None
 247                 for e in face.edges:
 248                         other=e.other_face(face)
 249                         if other and not other.flag:
 250                                 edge=e
 251                                 break
 252
 253                 if not edge:
 254                         return None
 255
 256                 if debug:
 257                         print "Starting strip from %s, edge %s, reverse=%s"%([v.index for v in face.verts], (edge.v1.index, edge.v2.index), reverse)
 258
 259                 verts=face.get_vertices_from(reverse, edge.v1, edge.v2)
 260                 if len(verts)==3:
 261                         result=[verts[-1], verts[0]]
 262                 else:
 263                         result=[verts[-2], verts[-1]]
 264
 265                 while 1:
 266                         verts=face.get_vertices_from(reverse, *result[-2:])
 267                         k=len(result)%2
 268                         if debug:
 269                                 print "  Adding %s"%face
 270
 271                         face.flag=True
 272                         if len(verts)==4 and not k:
 273                                 result.append(verts[3])
 274                         result.append(verts[2])
 275                         if len(verts)==4 and k:
 276                                 result.append(verts[3])
 277
 278                         edge=face.get_edge(*result[-2:])
 279
 280                         if debug:
 281                                 print "  Next edge is %s"%(edge.key, )
 282
 283                         next=edge.other_face(face)
 284                         if not next or next.flag:
 285                                 break
 286                         face=next
 287
 288                 if debug:
 289                         print "  %s"%[v.index for v in result]
 290
 291                 return result
 292
 293
 294 class Exporter:
 295         def __init__(self, fn):
 296                 self.filename=fn
 297                 if fn==None:
 298                         self.out_file=sys.stdout
 299                 else:
 300                         self.out_file=file(fn, "w")
 301                 self.use_strips=True
 302                 self.use_degen_tris=True
 303                 self.optimize_locality=True
 304                 self.export_lines=True
 305                 self.debug=False
 306                 self.strip_debug=False
 307                 self.smooth_debug=False
 308
 309         def get_locality(self, strip):
 310                 total=0
 311                 for i in range(1, len(strip)):
 312                         if strip[i].index!=strip[i-1].index:
 313                                 total+=1.0/(abs(strip[i].index-strip[i-1].index))
 314                 return total/len(strip)
 315
 316         def get_followers(self, strip):
 317                 result={}
 318                 for i in range(len(strip)-1):
 319                         v=strip[i]
 320                         n=strip[i+1]
 321                         if v.index!=n.index:
 322                                 if v.index not in result:
 323                                         result[v.index]={}
 324                                 if n.index not in result[v.index]:
 325                                         result[v.index][n.index]=1
 326                                 else:
 327                                         result[v.index][n.index]+=1
 328                 return result
 329
 330         def export(self):
 331                 scene=bpy.data.scenes.active
 332
 333                 obj=scene.objects.active
 334                 if obj.getType()!="Mesh":
 335                         raise Exception, "Can only export Mesh data"
 336
 337                 mesh=Mesh(obj.getData(mesh=True))
 338
 339                 if self.debug:
 340                         ntris=sum([len(f.verts)-2 for f in mesh.faces])
 341                         print "Starting with %d vertices, %d faces (%d triangles) and %d edges"%(len(mesh.verts), len(mesh.faces), ntris, len(mesh.edges))
 342
 343                 mesh.split_vertices(self.smooth_debug)
 344
 345                 if self.debug:
 346                         ntris=sum([len(f.verts)-2 for f in mesh.faces])
 347                         print "After splitting %d vertices, %d faces (%d triangles) and %d edges"%(len(mesh.verts), len(mesh.faces), ntris, len(mesh.edges))
 348
 349                 mesh.compute_normals()
 350
 351                 strips=[]
 352                 if self.use_strips:
 353                         for f in mesh.faces:
 354                                 f.flag=False
 355
 356                         while 1:
 357                                 best=5
 358                                 face=None
 359                                 for f in mesh.faces:
 360                                         if f.flag:
 361                                                 continue
 362                                         score=0
 363                                         for e in f.edges:
 364                                                 other=e.other_face(f)
 365                                                 if other and not other.flag:
 366                                                         score+=1
 367                                         if score>0 and score<best:
 368                                                 face=f
 369                                                 best=score
 370
 371                                 if not face:
 372                                         break
 373
 374                                 strip=mesh.create_strip(face, self.use_degen_tris and sum([len(s) for s in strips])%2, self.strip_debug)
 375                                 if strip:
 376                                         strips.append(strip)
 377
 378                         if self.debug:
 379                                 print "%d strips:"%len(strips)
 380                                 for i in range(len(strips)):
 381                                         print "  %d: %d indices"%(i, len(strips[i]))
 382                                 print "%d loose faces"%len([f for f in mesh.faces if not f.flag])
 383                                 nind=sum([len(s) for s in strips])+sum([len(f.verts) for f in mesh.faces if not f.flag])
 384                                 print "%d indices total"%nind
 385
 386                         if self.use_degen_tris and strips:
 387                                 big_strip=[]
 388                                 for s in strips:
 389                                         if big_strip:
 390                                                 big_strip+=[big_strip[-1], s[0]]
 391                                         big_strip+=s
 392
 393                                 for f in mesh.faces:
 394                                         if not f.flag:
 395                                                 if len(big_strip)%2:
 396                                                         order=(-1, -2, 0, 1)
 397                                                 else:
 398                                                         order=(0, 1, -1, -2)
 399                                                 if big_strip:
 400                                                         big_strip+=[big_strip[-1], f.verts[order[0]]]
 401                                                 big_strip+=[f.verts[i] for i in order[:len(f.verts)]]
 402                                                 f.flag=True
 403
 404                                 strips=[big_strip]
 405
 406                                 if self.debug:
 407                                         nind=len(big_strip)
 408                                         print "Big strip has %d indices"%len(big_strip)
 409
 410                 if self.debug:
 411                         print "%.2f indices per triangle"%(float(nind)/max(ntris, 1))
 412                         print "Locality before optimization: "+" ".join(["%.3f"%self.get_locality(s) for s in strips])
 413
 414                 if self.optimize_locality and self.use_strips and strips:
 415                         followers={}
 416                         for s in strips:
 417                                 followers.update(self.get_followers(s))
 418
 419                         verts2=[]
 420                         vert=strips[0][0]
 421                         while 1:
 422                                 vert.flag=True
 423                                 verts2.append(vert)
 424
 425                                 next=None
 426                                 if vert.index in followers:
 427                                         flw=followers[vert.index]
 428                                         best=0
 429                                         for n in flw:
 430                                                 if flw[n]>best and not mesh.verts[n].flag:
 431                                                         next=mesh.verts[n]
 432                                                         best=flw[n]+0.9/abs(vert.index-n)
 433
 434                                 if not next:
 435                                         for v in mesh.verts:
 436                                                 if not v.flag:
 437                                                         next=v
 438                                                         break
 439                                         if not next:
 440                                                 break
 441
 442                                 vert=next
 443
 444                         mesh.verts=verts2
 445
 446                         for i in range(len(mesh.verts)):
 447                                 mesh.verts[i].index=i
 448
 449                         if self.debug:
 450                                 print "Locality after optimization: "+" ".join(["%.3f"%self.get_locality(s) for s in strips])
 451
 452                 self.out_file.write("vertices NORMAL3")
 453                 if mesh.faceUV:
 454                         self.out_file.write("_TEXCOORD2")
 455                 self.out_file.write("_VERTEX3\n{\n")
 456                 norm=None
 457                 uv=None
 458                 for v in mesh.verts:
 459                         if v.no!=norm:
 460                                 self.out_file.write("\tnormal3 %f %f %f;\n"%tuple(v.no))
 461                                 norm=v.no
 462                         if v.uv!=uv:
 463                                 self.out_file.write("\ttexcoord2 %f %f;\n"%tuple(v.uv))
 464                                 uv=v.uv
 465                         self.out_file.write("\tvertex3 %f %f %f;\n"%tuple(v.co))
 466                 self.out_file.write("};\n")
 467                 for s in strips:
 468                         self.out_file.write("batch TRIANGLE_STRIP\n{\n\tindices")
 469                         n=0
 470                         for v in s:
 471                                 self.out_file.write(" %u"%v.index)
 472                                 n+=1;
 473                                 if n%32==0:
 474                                         self.out_file.write(";\n\tindices")
 475                         self.out_file.write(";\n};\n")
 476
 477                 first=True
 478                 for f in mesh.faces:
 479                         if not f.flag:
 480                                 if first:
 481                                         self.out_file.write("batch TRIANGLES\n{\n")
 482                                         first=False
 483                                 for i in range(2, len(f.verts)):
 484                                         self.out_file.write("\tindices %u %u %u;\n"%(f.verts[0].index, f.verts[i-1].index, f.verts[i].index))
 485                 if not first:
 486                         self.out_file.write("};\n")
 487
 488                 if self.export_lines and mesh.lines:
 489                         self.out_file.write("batch LINES\n{\n")
 490                         for l in mesh.lines:
 491                                 self.out_file.write("\tindices %u %u;\n"%(l.verts[0].index, l.verts[1].index))
 492                         self.out_file.write("};\n")
 493
 494
 495 class FrontEnd:
 496         def __init__(self):
 497                 self.config=Blender.Registry.GetKey('mspgl_export', True) or {}
 498                 self.temp_config=Blender.Registry.GetKey('mspgl_export_temp') or {}
 499
 500         def run(self):
 501                 self.use_strips=Blender.Draw.Create(self.config.get('use_strips', True))
 502                 self.use_degen_tris=Blender.Draw.Create(self.config.get('use_degen_tris', True))
 503                 self.optimize_locality=Blender.Draw.Create(self.config.get('optimize_locality', True))
 504                 self.export_lines=Blender.Draw.Create(self.config.get('export_lines', False))
 505                 self.debug=Blender.Draw.Create(self.config.get('debug', False))
 506                 self.strip_debug=Blender.Draw.Create(self.config.get('strip_debug', False))
 507                 self.smooth_debug=Blender.Draw.Create(self.config.get('smooth_debug', False))
 508                 ret=Blender.Draw.PupBlock("Export MSP GL mesh",
 509                         [("Use strips", self.use_strips, "Generage OpenGL triangle strips"),
 510                                 ("Use degen tris", self.use_degen_tris, "Use degenerate triangles to combine triangle strips"),
 511                                 ("Optimize locality", self.optimize_locality),
 512                                 ("Export lines", self.export_lines),
 513                                 ("Debugging options"),
 514                                 ("Debug", self.debug),
 515                                 ("Debug strips", self.strip_debug),
 516                                 ("Debug smoothing", self.smooth_debug)])
 517                 if ret:
 518                         dirname=self.temp_config.get("dirname", Blender.sys.dirname(Blender.Get("filename")))
 519                         obj=bpy.data.scenes.active.objects.active
 520                         Blender.Window.FileSelector(self.export, "Export MSP GL mesh", "%s/%s.mesh"%(dirname, obj.name))
 521
 522         def draw(self):
 523                 pass
 524
 525         def export(self, fn):
 526                 self.config['use_strips']=self.use_strips.val
 527                 self.config['use_degen_tris']=self.use_degen_tris.val
 528                 self.config['optimize_locality']=self.optimize_locality.val
 529                 self.config['export_lines']=self.export_lines.val
 530                 self.config['debug']=self.debug.val
 531                 self.config['strip_debug']=self.strip_debug.val
 532                 self.config['smooth_debug']=self.smooth_debug.val
 533                 Blender.Registry.SetKey('mspgl_export', self.config, True)
 534
 535                 import os
 536                 self.temp_config["dirname"]=os.path.dirname(fn)
 537                 Blender.Registry.SetKey('mspgl_export_temp', self.temp_config)
 538
 539                 exp=Exporter(fn)
 540                 exp.use_strips=self.use_strips.val
 541                 exp.use_degen_tris=self.use_degen_tris.val
 542                 exp.optimize_locality=self.optimize_locality.val
 543                 exp.export_lines=self.export_lines.val
 544                 exp.debug=self.debug.val
 545                 exp.strip_debug=self.strip_debug.val
 546                 exp.smooth_debug=self.smooth_debug.val
 547                 exp.export()
 548
 549
 550 if __name__=="__main__":
 551         fe=FrontEnd()
 552         fe.run()