5 Name: 'MSP GL Mesh (.mesh)...'
15 def make_edge_key(i1, i2):
16 return (min(i1, i2), max(i1, i2))
20 def __init__(self, me):
21 if me.__class__==Edge:
22 self._medge = me._medge
25 self.smooth = me.smooth
31 def __getattr__(self, attr):
32 return getattr(self._medge, attr)
34 def __cmp__(self, other):
37 def check_smooth(self, limit):
38 if len(self.faces)!=2:
41 d = Blender.Mathutils.DotVecs(self.faces[0].no, self.faces[1].no)
42 if (d>limit and self.faces[0].smooth and self.faces[1].smooth) or d>0.999:
45 def other_face(self, f):
46 if f.index==self.faces[0].index:
47 if len(self.faces)>=2:
56 def __init__(self, mv):
57 if mv.__class__==Vertex:
58 self._mvert = mv._mvert
64 self.orig_index = self._mvert.index
70 def __getattr__(self, attr):
71 return getattr(self._mvert, attr)
73 def __cmp__(self, other):
76 return cmp(self.index, other.index)
79 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])
85 def __init__(self, mf):
88 self.verts = [v for v in mf.verts]
91 def __getattr__(self, attr):
92 return getattr(self._mface, attr)
94 def __cmp__(self, other):
97 return cmp(self.index, other.index)
100 return "<Face %d (%s)>"%(self.index, " ".join([str(v.index) for v in self.verts]))
104 def pivot_vertices(self, *vt):
105 flags = [(v in vt) for v in self.verts]
108 if flags[i] and not flags[(i+l-1)%l]:
109 return self.verts[i:]+self.verts[:i]
111 def get_edge(self, v1, v2):
112 key = make_edge_key(v1.index, v2.index)
116 raise KeyError, "No edge %s"%(key,)
120 def __init__(self, e):
122 self.verts = [e.v1, e.v2]
126 return "<Line (%d %d)>"%(self.verts[0].index, self.verts[1].index)
132 def __init__(self, m):
134 self.verts = [Vertex(v) for v in m.verts]
135 self.faces = [Face(f) for f in m.faces]
138 for i in range(len(f.verts)):
139 f.verts[i] = self.verts[f.verts[i].index]
140 f.verts[i].faces.append(f)
142 self.edges = dict([(e.key, Edge(e)) for e in m.edges])
144 for k in f.edge_keys:
146 e.faces.append(self.faces[f.index])
149 self.lines = [Line(e) for e in self.edges.itervalues() if not e.faces]
151 if m.mode&Blender.Mesh.Modes.AUTOSMOOTH:
152 smooth_limit = math.cos(m.degr*math.pi/180)
155 for e in self.edges.itervalues():
156 e.v1 = self.verts[e.v1.index]
157 e.v2 = self.verts[e.v2.index]
158 e.check_smooth(smooth_limit)
160 def __getattr__(self, attr):
161 return getattr(self._mesh, attr)
163 def split_vertices(self, find_group_func, debug):
172 vg.append(find_group_func(v, f))
176 for i in range(len(self.verts)):
177 if len(groups[i])==1:
181 print "Vertex %s has %d groups"%(self.verts[i], len(groups[i]))
183 for g in groups[i][1:]:
184 v = Vertex(self.verts[i])
185 v.index = len(self.verts)
189 print " -> %d %s"%(v.index, [f.index for f in g])
192 for j in range(len(f.edges)):
195 if e.v1!=self.verts[i] and e.v2!=self.verts[i]:
199 print " Splitting edge %s with faces %s"%(e.key, e.faces)
201 if e.other_face(f) not in g and len(e.faces)>=2:
208 del self.edges[e.key]
210 if e.v1==self.verts[i]:
212 elif e.v2==self.verts[i]:
215 e.key = make_edge_key(e.v1.index, e.v2.index)
216 self.edges[e.key] = e
218 self.verts[i].faces.remove(f)
219 f.verts[f.verts.index(self.verts[i])] = v
222 def split_smooth(self, debug = False):
223 self.split_vertices(self.find_smooth_group, debug)
225 def split_uv(self, debug = False):
226 self.split_vertices(self.find_uv_group, debug)
228 def find_smooth_group(self, vert, face):
234 other = e.other_face(f)
235 #if not other or other.index not in face_indices:
236 if other not in vert.faces:
246 def find_uv_group(self, vert, face):
247 uv = face.uv[face.verts.index(vert)]
251 if not f.flag and f.uv[f.verts.index(vert)]==uv:
256 def compute_normals(self):
259 v.no = Blender.Mathutils.Vector()
264 # XXX Should use edges to compute normal
265 v.no = Blender.Mathutils.Vector(0, 0, 1)
267 def compute_uv(self):
270 v.uv = v.faces[0].uv[v.faces[0].verts.index(v)]
272 def compute_tbn(self):
274 v.tan = Blender.Mathutils.Vector()
275 v.bino = Blender.Mathutils.Vector()
277 fverts = f.pivot_vertices(False, v)
280 du1 = v1.uv[0]-v.uv[0]
281 du2 = v2.uv[0]-v.uv[0]
282 dv1 = v1.uv[1]-v.uv[1]
283 dv2 = v2.uv[1]-v.uv[1]
284 div = du1*dv2-du2*dv1
285 edge1 = fverts[1].co-fverts[0].co
286 edge2 = fverts[-1].co-fverts[0].co
287 v.tan += (edge1*dv2-edge2*dv1)/div
288 v.bino += (edge2*du1-edge1*du2)/div
292 def create_strip(self, face, max_len, debug):
295 other = e.other_face(face)
296 if other and not other.flag:
304 print "Starting strip from %s, edge %s"%([v.index for v in face.verts], (edge.v1.index, edge.v2.index))
306 verts = face.pivot_vertices(edge.v1, edge.v2)
308 result = [verts[-1], verts[0]]
310 result = [verts[-2], verts[-1]]
314 print " Adding %s"%face
316 verts = face.pivot_vertices(*result[-2:])
320 if len(verts)==4 and not k:
321 result.append(verts[3])
322 result.append(verts[2])
323 if len(verts)==4 and k:
324 result.append(verts[3])
326 if len(result)>=max_len:
328 print " Max length exceeded"
331 edge = face.get_edge(*result[-2:])
334 print " Next edge is %s"%(edge.key, )
336 next = edge.other_face(face)
337 if not next or next.flag:
342 print " %s"%[v.index for v in result]
348 def __init__(self, size):
350 self.slots = [-1]*self.size
353 hit = v.index in self.slots
355 self.slots.remove(v.index)
356 self.slots.append(v.index)
361 def fetch_strip(self, strip):
368 def test_strip(self, strip):
370 for i in range(len(strip)):
373 if strip[i].index in self.slots[i:]:
379 def __init__(self, fn):
382 self.out_file = sys.stdout
384 self.out_file = file(fn, "w")
385 self.use_strips = True
386 self.use_degen_tris = True
387 self.max_strip_len = 1024
388 self.optimize_cache = False
390 self.export_lines = True
391 self.tbn_vecs = False
393 self.strip_debug = False
394 self.split_debug = False
396 def stripify(self, mesh):
410 other = e.other_face(f)
411 if other and not other.flag:
413 if score>0 and score<best:
420 strip = mesh.create_strip(face, self.max_strip_len, self.strip_debug)
424 loose = [f for f in mesh.faces if not f.flag]
427 print "%d strips:"%len(strips)
428 for i in range(len(strips)):
429 print " %d: %d indices"%(i, len(strips[i]))
430 print "%d loose faces"%len([f for f in mesh.faces if not f.flag])
431 nind = sum([len(s) for s in strips])+sum([len(f.verts) for f in loose])
432 print "%d indices total"%nind
434 if self.use_degen_tris and strips:
439 if self.optimize_cache:
440 cache = VertexCache(self.cache_size)
446 for i in range(len(strips)):
447 hits = cache.test_strip(strips[i])
455 glue = [big_strip[-1], s[0]]
461 total_hits += cache.fetch_strip(glue)
465 total_hits += cache.fetch_strip(s)
471 order = (-1, -2, 0, 1)
473 order = (0, 1, -1, -2)
474 verts = [f.verts[i] for i in order[:len(f.verts)]]
476 glue = [big_strip[-1], verts[0]]
479 total_hits += cache.fetch_strip(glue)
482 total_hits += cache.fetch_strip(verts)
488 nind = len(big_strip)
489 print "Big strip has %d indices"%nind
490 if self.optimize_cache:
491 print "%d cache hits"%total_hits
494 ntris = sum([len(f.verts)-2 for f in mesh.faces])
495 print "%.2f indices per triangle"%(float(nind)/max(ntris, 1))
500 scene = bpy.data.scenes.active
502 obj = scene.objects.active
503 if obj.getType()!="Mesh":
504 raise Exception, "Can only export Mesh data"
506 mesh = Blender.Mesh.New("export_tmp")
507 mesh.getFromObject(obj)
511 ntris = sum([len(f.verts)-2 for f in mesh.faces])
512 print "Starting with %d vertices, %d faces (%d triangles) and %d edges"%(len(mesh.verts), len(mesh.faces), ntris, len(mesh.edges))
514 mesh.split_smooth(self.split_debug)
517 print "After smooth splitting %d vertices and %d edges"%(len(mesh.verts), len(mesh.edges))
519 mesh.compute_normals()
522 mesh.split_uv(self.split_debug)
524 print "After UV splitting %d vertices and %d edges"%(len(mesh.verts), len(mesh.edges))
532 strips, loose = self.stripify(mesh)
534 self.out_file.write("vertices NORMAL3")
536 self.out_file.write("_TEXCOORD2")
538 self.out_file.write("_ATTRIB33_ATTRIB34")
539 self.out_file.write("_VERTEX3\n{\n")
546 self.out_file.write("\tnormal3 %f %f %f;\n"%tuple(v.no))
549 self.out_file.write("\ttexcoord2 %f %f;\n"%tuple(v.uv))
552 self.out_file.write("\tattrib3 3 %f %f %f;\n"%tuple(v.tan))
555 self.out_file.write("\tattrib3 4 %f %f %f;\n"%tuple(v.bino))
557 self.out_file.write("\tvertex3 %f %f %f;\n"%tuple(v.co))
558 self.out_file.write("};\n")
560 self.out_file.write("batch TRIANGLE_STRIP\n{\n\tindices")
563 self.out_file.write(" %u"%v.index)
566 self.out_file.write(";\n\tindices")
567 self.out_file.write(";\n};\n")
572 self.out_file.write("batch TRIANGLES\n{\n")
574 for i in range(2, len(f.verts)):
575 self.out_file.write("\tindices %u %u %u;\n"%(f.verts[0].index, f.verts[i-1].index, f.verts[i].index))
577 self.out_file.write("};\n")
579 if self.export_lines and mesh.lines:
580 self.out_file.write("batch LINES\n{\n")
582 self.out_file.write("\tindices %u %u;\n"%(l.verts[0].index, l.verts[1].index))
583 self.out_file.write("};\n")
588 self.config = Blender.Registry.GetKey('mspgl_export', True) or {}
589 self.temp_config = Blender.Registry.GetKey('mspgl_export_temp') or {}
592 self.use_strips = Blender.Draw.Create(self.config.get('use_strips', True))
593 self.use_degen_tris = Blender.Draw.Create(self.config.get('use_degen_tris', True))
594 self.max_strip_len = Blender.Draw.Create(self.config.get('max_strip_len', 1024))
595 self.optimize_cache = Blender.Draw.Create(self.config.get('optimize_cache', False))
596 self.cache_size = Blender.Draw.Create(self.config.get('cache_size', 64))
597 self.export_lines = Blender.Draw.Create(self.config.get('export_lines', False))
598 self.tbn_vecs = Blender.Draw.Create(self.config.get('tbn_vecs', False))
599 self.debug = Blender.Draw.Create(self.config.get('debug', False))
600 self.strip_debug = Blender.Draw.Create(self.config.get('strip_debug', False))
601 self.split_debug = Blender.Draw.Create(self.config.get('split_debug', False))
602 ret = Blender.Draw.PupBlock("Export MSP GL mesh",
603 [("Use strips", self.use_strips, "Generage OpenGL triangle strips"),
604 ("Use degen tris", self.use_degen_tris, "Use degenerate triangles to combine triangle strips"),
605 ("Max strip len", self.max_strip_len, 4, 16384, "Maximum length of a triangle strip"),
606 ("Optimize cache", self.optimize_cache, "Optimize for vertex cache"),
607 ("Cache size", self.cache_size, 8, 1024, "Cache size to optimize for"),
608 ("Export lines", self.export_lines, "Export lone edges as lines"),
609 ("Compute T/B vecs", self.tbn_vecs, "Compute tangent/binormal vectors for bumpmapping"),
610 ("Debugging options"),
611 ("Debug", self.debug),
612 ("Debug strips", self.strip_debug),
613 ("Debug splitting", self.split_debug)])
615 dirname = self.temp_config.get("dirname", Blender.sys.dirname(Blender.Get("filename")))
616 obj = bpy.data.scenes.active.objects.active
617 Blender.Window.FileSelector(self.export, "Export MSP GL mesh", "%s/%s.mesh"%(dirname, obj.name))
622 def export(self, fn):
623 self.config['use_strips'] = self.use_strips.val
624 self.config['use_degen_tris'] = self.use_degen_tris.val
625 self.config['max_strip_len'] = self.max_strip_len.val
626 self.config['optimize_cache'] = self.optimize_cache.val
627 self.config['cache_size'] = self.cache_size.val
628 self.config['export_lines'] = self.export_lines.val
629 self.config['tbn_vecs'] = self.tbn_vecs.val
630 self.config['debug'] = self.debug.val
631 self.config['strip_debug'] = self.strip_debug.val
632 self.config['split_debug'] = self.split_debug.val
633 Blender.Registry.SetKey('mspgl_export', self.config, True)
636 self.temp_config["dirname"] = os.path.dirname(fn)
637 Blender.Registry.SetKey('mspgl_export_temp', self.temp_config)
640 exp.use_strips = self.use_strips.val
641 exp.use_degen_tris = self.use_degen_tris.val
642 exp.max_strip_len = self.max_strip_len.val
643 exp.optimize_cache = self.optimize_cache.val
644 exp.cache_size = self.cache_size.val
645 exp.export_lines = self.export_lines.val
646 exp.tbn_vecs = self.tbn_vecs.val
647 exp.debug = self.debug.val
648 exp.strip_debug = self.strip_debug.val
649 exp.split_debug = self.split_debug.val
653 if __name__=="__main__":