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