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.v1 = me.v1
  24                         self.v2 = me.v2
  25                         self.smooth = me.smooth
  26                 else:
  27                         self._medge = me
  28                         self.smooth = False
  29                 self.faces = []
  30
  31         def __getattr__(self, attr):
  32                 return getattr(self._medge, attr)
  33
  34         def check_smooth(self, limit):
  35                 if len(self.faces)!=2:
  36                         return
  37
  38                 d = Blender.Mathutils.DotVecs(self.faces[0].no, self.faces[1].no)
  39                 if (d>limit and self.faces[0].smooth and self.faces[1].smooth) or d>0.999:
  40                         self.smooth = True
  41
  42         def other_face(self, f):
  43                 if f.index==self.faces[0].index:
  44                         if len(self.faces)>=2:
  45                                 return self.faces[1]
  46                         else:
  47                                 return None
  48                 else:
  49                         return self.faces[0]
  50
  51
  52 class Vertex:
  53         def __init__(self, mv):
  54                 if mv.__class__==Vertex:
  55                         self._mvert = mv._mvert
  56                         self.no = mv.no
  57                         self.uv = mv.uv
  58                 else:
  59                         self._mvert = mv
  60                         self.uv = None
  61                 self.flag = False
  62                 self.faces = []
  63                 self.tan = None
  64                 self.bino = None
  65
  66         def __getattr__(self, attr):
  67                 return getattr(self._mvert, attr)
  68
  69         def __cmp__(self, other):
  70                 if other is None:
  71                         return 1
  72                 return cmp(self.index, other.index)
  73
  74         def __str__(self):
  75                 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])
  76
  77         __repr__ = __str__
  78
  79
  80 class Face:
  81         def __init__(self, mf):
  82                 self._mface = mf
  83                 self.edges = []
  84                 self.verts = [v for v in mf.verts]
  85                 self.flag = False
  86
  87         def __getattr__(self, attr):
  88                 return getattr(self._mface, attr)
  89
  90         def __cmp__(self, other):
  91                 if other is None:
  92                         return 1
  93                 return cmp(self.index, other.index)
  94
  95         def __str__(self):
  96                 return "<Face %d (%s)>"%(self.index, " ".join([str(v.index) for v in self.verts]))
  97
  98         __repr__ = __str__
  99
 100         def pivot_vertices(self, *vt):
 101                 flags = [(v in vt) for v in self.verts]
 102                 l = len(self.verts)
 103                 for i in range(l):
 104                         if flags[i] and not flags[(i+l-1)%l]:
 105                                 return self.verts[i:]+self.verts[:i]
 106
 107         def get_edge(self, v1, v2):
 108                 key = make_edge_key(v1.index, v2.index)
 109                 for e in self.edges:
 110                         if e.key==key:
 111                                 return e
 112                 raise KeyError, "No edge %s"%(key,)
 113
 114
 115 class Line:
 116         def __init__(self, e):
 117                 self.edge = e
 118                 self.verts = [e.v1, e.v2]
 119                 self.flag = False
 120
 121         def __str__(self):
 122                 return "<Line (%d %d)>"%(self.verts[0].index, self.verts[1].index)
 123
 124         __repr__ = __str__
 125
 126
 127 class Mesh:
 128         def __init__(self, m):
 129                 self._mesh = m
 130                 self.verts = [Vertex(v) for v in m.verts]
 131                 self.faces = [Face(f) for f in m.faces]
 132                 self.materials = m.materials[:]
 133
 134                 for f in self.faces:
 135                         for i in range(len(f.verts)):
 136                                 f.verts[i] = self.verts[f.verts[i].index]
 137                                 f.verts[i].faces.append(f)
 138
 139                 self.edges = dict([(e.key, Edge(e)) for e in m.edges])
 140                 for f in self.faces:
 141                         for k in f.edge_keys:
 142                                 e = self.edges[k]
 143                                 e.faces.append(self.faces[f.index])
 144                                 f.edges.append(e)
 145
 146                 self.lines = [Line(e) for e in self.edges.itervalues() if not e.faces]
 147
 148                 if m.mode&Blender.Mesh.Modes.AUTOSMOOTH:
 149                         smooth_limit = math.cos(m.degr*math.pi/180)
 150                 else:
 151                         smooth_limit = -1
 152
 153                 for e in self.edges.itervalues():
 154                         e.v1 = self.verts[e.v1.index]
 155                         e.v2 = self.verts[e.v2.index]
 156                         e.check_smooth(smooth_limit)
 157
 158         def __getattr__(self, attr):
 159                 return getattr(self._mesh, attr)
 160
 161         def splice(self, other):
 162                 material_map = []
 163                 for m in other.materials:
 164                         if m in self.materials:
 165                                 material_map.append(self.materials.index(m))
 166                         else:
 167                                 material_map.append(len(self.materials))
 168                                 self.materials.append(m)
 169
 170                 offset = len(self.verts)
 171                 for v in other.verts:
 172                         v.index += offset
 173                         self.verts.append(v)
 174
 175                 offset = len(self.faces)
 176                 for f in other.faces:
 177                         f.index += offset
 178                         f.mat = material_map[f.mat]
 179                         self.faces.append(f)
 180
 181                 for e in other.edges.itervalues():
 182                         e.key = make_edge_key(e.v1.index, e.v2.index)
 183                         self.edges[e.key] = e
 184
 185                 self.lines += other.lines
 186
 187         def generate_material_uv(self):
 188                 for f in self.faces:
 189                         f.uv = ([(f.mat+0.5)/len(self.materials), 0.5],)*len(f.verts)
 190                 self.faceUV = True
 191
 192         def split_vertices(self, find_group_func, debug):
 193                 groups = []
 194                 for v in self.verts:
 195                         for f in v.faces:
 196                                 f.flag = False
 197
 198                         vg = []
 199                         for f in v.faces:
 200                                 if not f.flag:
 201                                         vg.append(find_group_func(v, f))
 202
 203                         groups.append(vg)
 204
 205                 for i in range(len(self.verts)):
 206                         if len(groups[i])==1:
 207                                 continue
 208
 209                         if debug:
 210                                 print "Vertex %s has %d groups"%(self.verts[i], len(groups[i]))
 211
 212                         for g in groups[i][1:]:
 213                                 v = Vertex(self.verts[i])
 214                                 v.index = len(self.verts)
 215                                 self.verts.append(v)
 216
 217                                 if debug:
 218                                         print "  -> %d %s"%(v.index, [f.index for f in g])
 219
 220                                 for f in g:
 221                                         for j in range(len(f.edges)):
 222                                                 e = f.edges[j]
 223
 224                                                 if e.v1!=self.verts[i] and e.v2!=self.verts[i]:
 225                                                         continue
 226
 227                                                 if debug:
 228                                                         print "  Splitting edge %s with faces %s"%(e.key, e.faces)
 229
 230                                                 if e.other_face(f) not in g and len(e.faces)>=2:
 231                                                         k = e.faces.index(f)
 232                                                         e.faces.remove(f)
 233                                                         e = Edge(e)
 234                                                         f.edges[j] = e
 235                                                         e.faces.append(f)
 236                                                 else:
 237                                                         del self.edges[e.key]
 238
 239                                                 if e.v1==self.verts[i]:
 240                                                         e.v1 = v
 241                                                 elif e.v2==self.verts[i]:
 242                                                         e.v2 = v
 243
 244                                                 e.key = make_edge_key(e.v1.index, e.v2.index)
 245                                                 self.edges[e.key] = e
 246
 247                                         self.verts[i].faces.remove(f)
 248                                         f.verts[f.verts.index(self.verts[i])] = v
 249                                         v.faces.append(f)
 250
 251         def split_smooth(self, debug = False):
 252                 self.split_vertices(self.find_smooth_group, debug)
 253
 254         def split_uv(self, debug = False):
 255                 self.split_vertices(self.find_uv_group, debug)
 256
 257         def find_smooth_group(self, vert, face):
 258                 face.flag = True
 259                 queue = [face]
 260
 261                 for f in queue:
 262                         for e in f.edges:
 263                                 other = e.other_face(f)
 264                                 #if not other or other.index not in face_indices:
 265                                 if other not in vert.faces:
 266                                         continue
 267
 268                                 if e.smooth:
 269                                         if not other.flag:
 270                                                 other.flag = True
 271                                                 queue.append(other)
 272
 273                 return queue
 274
 275         def find_uv_group(self, vert, face):
 276                 uv = face.uv[face.verts.index(vert)]
 277                 face.flag = True
 278                 group = [face]
 279                 for f in vert.faces:
 280                         if not f.flag and f.uv[f.verts.index(vert)]==uv:
 281                                 f.flag = True
 282                                 group.append(f)
 283                 return group
 284
 285         def compute_normals(self):
 286                 for v in self.verts:
 287                         if v.faces:
 288                                 v.no = Blender.Mathutils.Vector()
 289                                 for f in v.faces:
 290                                         v.no += f.no
 291                                 v.no.normalize()
 292                         else:
 293                                 # XXX Should use edges to compute normal
 294                                 v.no = Blender.Mathutils.Vector(0, 0, 1)
 295
 296         def compute_uv(self):
 297                 for v in self.verts:
 298                         if v.faces:
 299                                 v.uv = v.faces[0].uv[v.faces[0].verts.index(v)]
 300
 301         def compute_tbn(self):
 302                 for v in self.verts:
 303                         v.tan = Blender.Mathutils.Vector()
 304                         v.bino = Blender.Mathutils.Vector()
 305                         for f in v.faces:
 306                                 fverts = f.pivot_vertices(False, v)
 307                                 v1 = fverts[1]
 308                                 v2 = fverts[-1]
 309                                 du1 = v1.uv[0]-v.uv[0]
 310                                 du2 = v2.uv[0]-v.uv[0]
 311                                 dv1 = v1.uv[1]-v.uv[1]
 312                                 dv2 = v2.uv[1]-v.uv[1]
 313                                 div = du1*dv2-du2*dv1
 314                                 edge1 = fverts[1].co-fverts[0].co
 315                                 edge2 = fverts[-1].co-fverts[0].co
 316                                 v.tan += (edge1*dv2-edge2*dv1)/div
 317                                 v.bino += (edge2*du1-edge1*du2)/div
 318                         v.tan.normalize()
 319                         v.bino.normalize()
 320
 321         def create_strip(self, face, max_len, debug):
 322                 edge = None
 323                 for e in face.edges:
 324                         other = e.other_face(face)
 325                         if other and not other.flag:
 326                                 edge = e
 327                                 break
 328
 329                 if not edge:
 330                         return None
 331
 332                 if debug:
 333                         print "Starting strip from %s, edge %s"%([v.index for v in face.verts], (edge.v1.index, edge.v2.index))
 334
 335                 verts = face.pivot_vertices(edge.v1, edge.v2)
 336                 if len(verts)==3:
 337                         result = [verts[-1], verts[0]]
 338                 else:
 339                         result = [verts[-2], verts[-1]]
 340
 341                 while 1:
 342                         if debug:
 343                                 print "  Adding %s"%face
 344
 345                         verts = face.pivot_vertices(*result[-2:])
 346                         k = len(result)%2
 347
 348                         face.flag = True
 349                         if len(verts)==4 and not k:
 350                                 result.append(verts[3])
 351                         result.append(verts[2])
 352                         if len(verts)==4 and k:
 353                                 result.append(verts[3])
 354
 355                         if len(result)>=max_len:
 356                                 if debug:
 357                                         print "  Max length exceeded"
 358                                 break
 359
 360                         edge = face.get_edge(*result[-2:])
 361
 362                         if debug:
 363                                 print "  Next edge is %s"%(edge.key, )
 364
 365                         next = edge.other_face(face)
 366                         if not next or next.flag:
 367                                 break
 368                         face = next
 369
 370                 if debug:
 371                         print "  %s"%[v.index for v in result]
 372
 373                 return result
 374
 375
 376 class VertexCache:
 377         def __init__(self, size):
 378                 self.size = size
 379                 self.slots = [-1]*self.size
 380
 381         def fetch(self, v):
 382                 hit = v.index in self.slots
 383                 if hit:
 384                         self.slots.remove(v.index)
 385                 self.slots.append(v.index)
 386                 if not hit:
 387                         del self.slots[0]
 388                 return hit
 389
 390         def fetch_strip(self, strip):
 391                 hits = 0
 392                 for v in strip:
 393                         if self.fetch(v):
 394                                 hits += 1
 395                 return hits
 396
 397         def test_strip(self, strip):
 398                 hits = 0
 399                 for i in range(len(strip)):
 400                         if i>=self.size:
 401                                 break
 402                         if strip[i].index in self.slots[i:]:
 403                                 hits += 1
 404                 return hits
 405
 406
 407 class OutFile:
 408         def __init__(self, fn):
 409                 if fn==None:
 410                         self.file = sys.stdout
 411                 else:
 412                         self.file = open(fn, "w")
 413                 self.indent = 0
 414
 415         def make(self, kwd, *params):
 416                 pstr = ""
 417                 for p in params:
 418                         if type(p)==float:
 419                                 pstr += " %.6g"%p
 420                         else:
 421                                 pstr += " %s"%p
 422                 return "%s%s"%(kwd, pstr)
 423
 424         def write(self, kwd, *params):
 425                 self.file.write("%s%s;\n"%('\t'*self.indent, self.make(kwd, *params)))
 426
 427         def begin(self, kwd, *params):
 428                 i = '\t'*self.indent
 429                 self.file.write("%s%s\n%s{\n"%(i, self.make(kwd, *params), i))
 430                 self.indent += 1
 431
 432         def end(self):
 433                 self.indent -= 1
 434                 self.file.write("%s};\n"%('\t'*self.indent))
 435
 436
 437 class Exporter:
 438         def __init__(self, fn):
 439                 self.out_file = OutFile(fn)
 440                 self.use_strips = True
 441                 self.use_degen_tris = True
 442                 self.max_strip_len = 1024
 443                 self.optimize_cache = False
 444                 self.cache_size = 64
 445                 self.export_lines = True
 446                 self.tbn_vecs = False
 447                 self.compound = False
 448                 self.object = False
 449                 self.material_tex = False
 450                 self.debug = False
 451                 self.strip_debug = False
 452                 self.split_debug = False
 453
 454         def stripify(self, mesh):
 455                 for f in mesh.faces:
 456                         f.flag = False
 457
 458                 strips = []
 459
 460                 while 1:
 461                         best = 5
 462                         face = None
 463                         for f in mesh.faces:
 464                                 if f.flag:
 465                                         continue
 466                                 score = 0
 467                                 for e in f.edges:
 468                                         other = e.other_face(f)
 469                                         if other and not other.flag:
 470                                                 score += 1
 471                                 if score>0 and score<best:
 472                                         face = f
 473                                         best = score
 474
 475                         if not face:
 476                                 break
 477
 478                         strip = mesh.create_strip(face, self.max_strip_len, self.strip_debug)
 479                         if strip:
 480                                 strips.append(strip)
 481
 482                 loose = [f for f in mesh.faces if not f.flag]
 483
 484                 if self.debug:
 485                         print "%d strips:"%len(strips)
 486                         for i in range(len(strips)):
 487                                 print "  %d: %d indices"%(i, len(strips[i]))
 488                         print "%d loose faces"%len([f for f in mesh.faces if not f.flag])
 489                         nind = sum([len(s) for s in strips])+sum([len(f.verts) for f in loose])
 490                         print "%d indices total"%nind
 491
 492                 if self.use_degen_tris and strips:
 493                         big_strip = []
 494
 495                         cache = None
 496                         total_hits = 0
 497                         if self.optimize_cache:
 498                                 cache = VertexCache(self.cache_size)
 499
 500                         while strips:
 501                                 best = 0
 502                                 if cache:
 503                                         best_hits = 0
 504                                         for i in range(len(strips)):
 505                                                 hits = cache.test_strip(strips[i])
 506                                                 if hits>best_hits:
 507                                                         best = i
 508                                                         best_hits = hits
 509
 510                                 s = strips[best]
 511
 512                                 if big_strip:
 513                                         glue = [big_strip[-1], s[0]]
 514                                         if len(big_strip)%2:
 515                                                 glue += [s[0]]
 516
 517                                         big_strip += glue
 518                                         if cache:
 519                                                 total_hits += cache.fetch_strip(glue)
 520
 521                                 big_strip += s
 522                                 if cache:
 523                                         total_hits += cache.fetch_strip(s)
 524
 525                                 del strips[best]
 526
 527                         for f in loose:
 528                                 if len(big_strip)%2:
 529                                         order = (-1, -2, 0, 1)
 530                                 else:
 531                                         order = (0, 1, -1, -2)
 532                                 verts = [f.verts[i] for i in order[:len(f.verts)]]
 533                                 if big_strip:
 534                                         glue = [big_strip[-1], verts[0]]
 535                                         big_strip += glue
 536                                         if cache:
 537                                                 total_hits += cache.fetch_strip(glue)
 538                                 big_strip += verts
 539                                 if cache:
 540                                         total_hits += cache.fetch_strip(verts)
 541
 542                         strips = [big_strip]
 543                         loose = []
 544
 545                         if self.debug:
 546                                 nind = len(big_strip)
 547                                 print "Big strip has %d indices"%nind
 548                                 if self.optimize_cache:
 549                                         print "%d cache hits"%total_hits
 550
 551                 if self.debug:
 552                         ntris = sum([len(f.verts)-2 for f in mesh.faces])
 553                         print "%.2f indices per triangle"%(float(nind)/max(ntris, 1))
 554
 555                 return strips, loose
 556
 557         def export(self):
 558                 scene = bpy.data.scenes.active
 559
 560                 objs = Blender.Object.GetSelected()
 561                 if not objs:
 562                         raise Exception, "Nothing to export"
 563                 for o in objs:
 564                         if o.getType()!="Mesh":
 565                                 raise Exception, "Can only export Mesh data"
 566
 567                 mesh = Blender.Mesh.New("export_tmp")
 568                 mesh.getFromObject(objs[0])
 569                 mesh = Mesh(mesh)
 570                 if self.compound:
 571                         # Must keep a ref to each Blender mesh
 572                         bmeshes = []
 573                         for o in objs[1:]:
 574                                 bmesh = Blender.Mesh.New("export_tmp")
 575                                 bmesh.getFromObject(o)
 576                                 bmeshes.append(bmesh)
 577                                 mesh.splice(Mesh(bmesh))
 578
 579                 if self.debug:
 580                         ntris = sum([len(f.verts)-2 for f in mesh.faces])
 581                         print "Starting with %d vertices, %d faces (%d triangles) and %d edges"%(len(mesh.verts), len(mesh.faces), ntris, len(mesh.edges))
 582
 583                 mesh.split_smooth(self.split_debug)
 584
 585                 if self.debug:
 586                         print "After smooth splitting %d vertices and %d edges"%(len(mesh.verts), len(mesh.edges))
 587
 588                 mesh.compute_normals()
 589
 590                 if self.material_tex:
 591                         mesh.generate_material_uv()
 592
 593                 if mesh.faceUV:
 594                         mesh.split_uv(self.split_debug)
 595                         if self.debug:
 596                                 print "After UV splitting %d vertices and %d edges"%(len(mesh.verts), len(mesh.edges))
 597
 598                         mesh.compute_uv()
 599                         if self.tbn_vecs:
 600                                 mesh.compute_tbn()
 601
 602                 strips = []
 603                 loose = mesh.faces
 604                 if self.use_strips:
 605                         strips, loose = self.stripify(mesh)
 606
 607                 if self.object:
 608                         self.out_file.begin("mesh")
 609
 610                 fmt = "NORMAL3"
 611                 if mesh.faceUV:
 612                         fmt += "_TEXCOORD2"
 613                         if self.tbn_vecs:
 614                                 fmt += "_ATTRIB33_ATTRIB34"
 615                 fmt += "_VERTEX3"
 616                 self.out_file.begin("vertices", fmt)
 617                 norm = None
 618                 uv = None
 619                 tan = None
 620                 bino = None
 621                 for v in mesh.verts:
 622                         if v.no!=norm:
 623                                 self.out_file.write("normal3", *v.no)
 624                                 norm = v.no
 625                         if v.uv!=uv:
 626                                 self.out_file.write("texcoord2", *v.uv)
 627                                 uv = v.uv
 628                         if v.tan!=tan:
 629                                 self.out_file.write("attrib3", 3, *v.tan)
 630                                 tan = v.tan
 631                         if v.bino!=bino:
 632                                 self.out_file.write("attrib3", 4, *v.bino)
 633                                 bino = v.bino
 634                         self.out_file.write("vertex3", *v.co)
 635                 self.out_file.end()
 636                 for s in strips:
 637                         self.out_file.begin("batch", "TRIANGLE_STRIP")
 638                         indices = []
 639                         n = 0
 640                         for v in s:
 641                                 indices.append(v.index)
 642                                 if len(indices)>=32:
 643                                         self.out_file.write("indices", *indices)
 644                                         indices = []
 645                         if indices:
 646                                 self.out_file.write("indices", *indices)
 647                         self.out_file.end()
 648
 649                 if loose:
 650                         self.out_file.begin("batch", "TRIANGLES")
 651                         for f in loose:
 652                                 for i in range(2, len(f.verts)):
 653                                         self.out_file.write("indices", f.verts[0].index, f.verts[i-1].index, f.verts[i].index)
 654                         self.out_file.end()
 655
 656                 if self.export_lines and mesh.lines:
 657                         self.out_file.write("batch", "LINES")
 658                         for l in mesh.lines:
 659                                 self.out_file.write("indices", l.verts[0].index, l.verts[1].index)
 660                         self.out_file.end()
 661
 662                 if self.object:
 663                         self.out_file.end()
 664                         self.out_file.begin("technique")
 665                         self.out_file.begin("pass", '""')
 666                         if self.material_tex:
 667                                 self.out_file.begin("material")
 668                                 self.out_file.write("diffuse", 1.0, 1.0, 1.0, 1.0)
 669                                 self.out_file.end()
 670                                 self.out_file.begin("texunit", 0)
 671                                 self.out_file.begin("texture2d")
 672                                 self.out_file.write("min_filter", "NEAREST")
 673                                 self.out_file.write("mag_filter", "NEAREST")
 674                                 self.out_file.write("storage", "RGB", len(mesh.materials), 1)
 675                                 texdata = '"'
 676                                 for m in mesh.materials:
 677                                         texdata += "\\x%02X\\x%02X\\x%02X"%(int(m.R*255), int(m.G*255), int(m.B*255))
 678                                 texdata += '"'
 679                                 self.out_file.write("raw_data", texdata)
 680                                 self.out_file.end()
 681                                 self.out_file.end()
 682                         elif mesh.materials:
 683                                 m = mesh.materials[0]
 684                                 self.out_file.begin("material")
 685                                 self.out_file.write("diffuse", m.R, m.G, m.B, 1.0)
 686                                 self.out_file.write("ambient", m.R*m.amb, m.G*m.amb, m.B*m.amb, 1.0)
 687                                 self.out_file.write("specular", m.specR*m.spec, m.specG*m.spec, m.specB*m.spec, 1.0)
 688                                 self.out_file.write("shininess", m.hard);
 689                                 self.out_file.end()
 690                         self.out_file.end()
 691                         self.out_file.end()
 692
 693
 694 class FrontEnd:
 695         def __init__(self):
 696                 self.config = Blender.Registry.GetKey('mspgl_export', True) or {}
 697                 self.temp_config = Blender.Registry.GetKey('mspgl_export_temp') or {}
 698
 699         def run(self):
 700                 self.use_strips = Blender.Draw.Create(self.config.get('use_strips', True))
 701                 self.use_degen_tris = Blender.Draw.Create(self.config.get('use_degen_tris', True))
 702                 self.max_strip_len = Blender.Draw.Create(self.config.get('max_strip_len', 1024))
 703                 self.optimize_cache = Blender.Draw.Create(self.config.get('optimize_cache', False))
 704                 self.cache_size = Blender.Draw.Create(self.config.get('cache_size', 64))
 705                 self.export_lines = Blender.Draw.Create(self.config.get('export_lines', False))
 706                 self.tbn_vecs = Blender.Draw.Create(self.config.get('tbn_vecs', False))
 707                 self.compound = Blender.Draw.Create(self.config.get('compound', False))
 708                 self.object = Blender.Draw.Create(self.config.get('object', False))
 709                 self.material_tex = Blender.Draw.Create(self.config.get('material_tex', False))
 710                 self.debug = Blender.Draw.Create(self.config.get('debug', False))
 711                 self.strip_debug = Blender.Draw.Create(self.config.get('strip_debug', False))
 712                 self.split_debug = Blender.Draw.Create(self.config.get('split_debug', False))
 713                 ret = Blender.Draw.PupBlock("Export MSP GL mesh",
 714                         [("Use strips", self.use_strips, "Generage OpenGL triangle strips"),
 715                                 ("Use degen tris", self.use_degen_tris, "Use degenerate triangles to combine triangle strips"),
 716                                 ("Max strip len", self.max_strip_len, 4, 16384, "Maximum length of a triangle strip"),
 717                                 ("Optimize cache", self.optimize_cache, "Optimize for vertex cache"),
 718                                 ("Cache size", self.cache_size, 8, 1024, "Cache size to optimize for"),
 719                                 ("Export lines", self.export_lines, "Export lone edges as lines"),
 720                                 ("Compute T/B vecs", self.tbn_vecs, "Compute tangent/binormal vectors for bumpmapping"),
 721                                 ("Compound", self.compound, "Create a compound mesh of all selected objects"),
 722                                 ("Object", self.object, "Export as an object"),
 723                                 ("Material texture", self.material_tex, "Create a texture from material data"),
 724                                 ("Debugging options"),
 725                                 ("Debug", self.debug),
 726                                 ("Debug strips", self.strip_debug),
 727                                 ("Debug splitting", self.split_debug)])
 728                 if ret:
 729                         dirname = self.temp_config.get("dirname", Blender.sys.dirname(Blender.Get("filename")))
 730                         obj = Blender.Object.GetSelected()[0]
 731                         ext = "mesh"
 732                         if self.object.val:
 733                                 ext = "object"
 734                         Blender.Window.FileSelector(self.export, "Export MSP GL mesh", "%s/%s.%s"%(dirname, obj.name, ext))
 735
 736         def draw(self):
 737                 pass
 738
 739         def export(self, fn):
 740                 self.config['use_strips'] = self.use_strips.val
 741                 self.config['use_degen_tris'] = self.use_degen_tris.val
 742                 self.config['max_strip_len'] = self.max_strip_len.val
 743                 self.config['optimize_cache'] = self.optimize_cache.val
 744                 self.config['cache_size'] = self.cache_size.val
 745                 self.config['export_lines'] = self.export_lines.val
 746                 self.config['tbn_vecs'] = self.tbn_vecs.val
 747                 self.config['compound'] = self.compound.val
 748                 self.config['object'] = self.object.val
 749                 self.config['material_tex'] = self.material_tex.val
 750                 self.config['debug'] = self.debug.val
 751                 self.config['strip_debug'] = self.strip_debug.val
 752                 self.config['split_debug'] = self.split_debug.val
 753                 Blender.Registry.SetKey('mspgl_export', self.config, True)
 754
 755                 import os
 756                 self.temp_config["dirname"] = os.path.dirname(fn)
 757                 Blender.Registry.SetKey('mspgl_export_temp', self.temp_config)
 758
 759                 exp = Exporter(fn)
 760                 exp.use_strips = self.use_strips.val
 761                 exp.use_degen_tris = self.use_degen_tris.val
 762                 exp.max_strip_len = self.max_strip_len.val
 763                 exp.optimize_cache = self.optimize_cache.val
 764                 exp.cache_size = self.cache_size.val
 765                 exp.export_lines = self.export_lines.val
 766                 exp.tbn_vecs = self.tbn_vecs.val
 767                 exp.compound = self.compound.val
 768                 exp.object = self.object.val
 769                 exp.material_tex = self.material_tex.val
 770                 exp.debug = self.debug.val
 771                 exp.strip_debug = self.strip_debug.val
 772                 exp.split_debug = self.split_debug.val
 773                 exp.export()
 774
 775
 776 if __name__=="__main__":
 777         fe = FrontEnd()
 778         fe.run()