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 class Edge:
  16         def __init__(self, me):
  17                 self._medge=me
  18                 self.faces=[]
  19                 self.smooth=False
  20
  21         def __getattr__(self, attr):
  22                 return getattr(self._medge, attr)
  23
  24         def check_smooth(self, limit):
  25                 if len(self.faces)!=2:
  26                         return
  27
  28                 d=Blender.Mathutils.DotVecs(self.faces[0].no, self.faces[1].no)
  29                 if (d>limit and self.faces[0].smooth and self.faces[1].smooth) or d>0.999:
  30                         self.smooth=1
  31
  32         def other_face(self, f):
  33                 if f.index==self.faces[0].index:
  34                         if len(self.faces)>=2:
  35                                 return self.faces[1]
  36                         else:
  37                                 return None
  38                 else:
  39                         return self.faces[0]
  40
  41
  42 class Vertex:
  43         def __init__(self, mv):
  44                 if mv.__class__==Vertex:
  45                         self._mvert=mv._mvert
  46                 else:
  47                         self._mvert=mv
  48
  49         def __getattr__(self, attr):
  50                 return getattr(self._mvert, attr)
  51
  52
  53 class Face:
  54         def __init__(self, mf):
  55                 self._mface=mf
  56                 self.smooth_group=None
  57                 self.edges=[]
  58                 self.verts=[v for v in mf.verts]
  59                 self.flag=False
  60
  61         def __getattr__(self, attr):
  62                 return getattr(self._mface, attr)
  63
  64         def get_vertices_from(self, *vt):
  65                 indices=[u.index for u in vt]
  66                 flags=[(v.index in indices) for v in self.verts]
  67                 l=len(self.verts)
  68                 for i in range(l):
  69                         if flags[i] and not flags[(i+l-1)%l]:
  70                                 return self.verts[i:]+self.verts[:i]
  71
  72
  73 class SmoothGroup:
  74         def __init__(self, index):
  75                 self.index=index
  76                 self.faces=[]
  77                 self.verts=[]
  78
  79         def find_vertices(self):
  80                 vert_map={}
  81                 for f in self.faces:
  82                         for i in range(len(f.verts)):
  83                                 v=f.verts[i]
  84                                 if v.index not in vert_map:
  85                                         vt=Vertex(v)
  86                                         vt.no=Blender.Mathutils.Vector(f.no)
  87                                         self.verts.append(vt)
  88                                         vert_map[v.index]=vt
  89                                         f.verts[i]=vt
  90                                 else:
  91                                         f.verts[i]=vert_map[v.index]
  92                                         vert_map[v.index].no+=f.no
  93
  94                 for v in self.verts:
  95                         v.no.normalize()
  96
  97
  98 class Exporter:
  99         def __init__(self, fn):
 100                 self.filename=fn
 101                 if fn==None:
 102                         self.out_file=sys.stdout
 103                 else:
 104                         self.out_file=file(fn, "w")
 105                 self.use_strips=True
 106                 self.use_degen_tris=True
 107                 self.debug=False
 108
 109         def find_smooth_group(self, face, sg):
 110                 face.smooth_group=sg
 111                 sg.faces.append(face)
 112                 queue=[face]
 113                 while queue:
 114                         cur=queue.pop(0)
 115                         for e in cur.edges:
 116                                 if e.smooth:
 117                                         other=e.other_face(cur)
 118                                         if other and not other.smooth_group:
 119                                                 other.smooth_group=sg
 120                                                 sg.faces.append(other)
 121                                                 queue.append(other)
 122
 123         def create_strip(self, face):
 124                 edge=None
 125                 for e in face.edges:
 126                         other=e.other_face(face)
 127                         if other and other.smooth_group.index==face.smooth_group.index and not other.flag:
 128                                 edge=e
 129                                 break
 130
 131                 if not edge:
 132                         return None
 133
 134                 if self.debug:
 135                         print "Starting strip from %s"%[v.index for v in face.verts]
 136
 137                 verts=face.get_vertices_from(edge.v1, edge.v2)
 138                 result=[verts[-2], verts[-1]]
 139
 140                 while 1:
 141                         verts=face.get_vertices_from(*result[-2:])
 142                         k=len(result)%2
 143                         if self.debug:
 144                                 print "  %d %s"%(len(result), [v.index for v in verts])
 145
 146                         face.flag=True
 147                         if len(verts)==4 and not k:
 148                                 result.append(verts[3])
 149                         result.append(verts[2])
 150                         if len(verts)==4 and k:
 151                                 result.append(verts[3])
 152
 153                         i1=result[-2].index
 154                         i2=result[-1].index
 155                         ekey=(min(i1, i2), max(i1, i2))
 156                         for e in face.edges:
 157                                 if e.key==ekey:
 158                                         edge=e
 159                                         break
 160
 161                         next=edge.other_face(face)
 162                         if not next or next.smooth_group.index!=face.smooth_group.index or next.flag:
 163                                 break
 164                         face=next
 165
 166                 if self.debug:
 167                         print "  %s"%[v.index for v in result]
 168
 169                 return result
 170
 171         def export(self):
 172                 scene=bpy.data.scenes.active
 173
 174                 obj=scene.objects.active
 175                 if obj.getType()!="Mesh":
 176                         raise Exception, "Can only export Mesh data"
 177
 178                 mesh=obj.getData(mesh=True)
 179
 180                 faces=[Face(f) for f in mesh.faces]
 181
 182                 edges=dict([(e.key, Edge(e)) for e in mesh.edges])
 183                 for f in faces:
 184                         for e in f.edge_keys:
 185                                 edges[e].faces.append(f)
 186                                 f.edges.append(edges[e])
 187
 188                 smooth_limit=math.cos(mesh.degr*math.pi/180)
 189                 for e in edges.itervalues():
 190                         e.check_smooth(smooth_limit)
 191
 192                 if self.debug:
 193                         print "%d faces, %d edges"%(len(faces), len(edges))
 194
 195                 smooth_groups=[]
 196                 for f in faces:
 197                         if not f.smooth_group:
 198                                 sg=SmoothGroup(len(smooth_groups))
 199                                 smooth_groups.append(sg)
 200                                 self.find_smooth_group(f, sg)
 201
 202                 for sg in smooth_groups:
 203                         sg.find_vertices()
 204
 205                 if self.debug:
 206                         print "%d smooth groups:"
 207                         for i in range(len(smooth_groups)):
 208                                 sg=smooth_groups[i]
 209                                 print "  %d: %d faces, %d vertices"%(i, len(sg.faces), len(sg.verts))
 210
 211                 strips=[]
 212                 if self.use_strips:
 213                         for sg in smooth_groups:
 214                                 for f in sg.faces:
 215                                         if not f.flag:
 216                                                 strip=self.create_strip(f)
 217                                                 if strip:
 218                                                         strips.append(strip)
 219
 220                         if self.use_degen_tris:
 221                                 big_strip=[]
 222                                 for s in strips:
 223                                         if big_strip:
 224                                                 big_strip+=[big_strip[-1], s[0]]
 225                                         big_strip+=s
 226
 227                                 for f in faces:
 228                                         if not f.flag:
 229                                                 if big_strip:
 230                                                         big_strip+=[big_strip[-1], f.verts[0]]
 231                                                 big_strip+=[f.verts[i] for i in (0, 1, -1)]
 232                                                 if len(f.verts)==4:
 233                                                         big_strip.append(f.verts[-2])
 234                                                 f.flag=True
 235
 236                                 strips=[big_strip]
 237
 238                 verts=[]
 239                 for sg in smooth_groups:
 240                         for v in sg.verts:
 241                                 v.index=len(verts)
 242                                 verts.append(v)
 243
 244                 self.out_file.write("vertices NORMAL3_VERTEX3\n{\n")
 245                 norm=None
 246                 for v in verts:
 247                         if v.no!=norm:
 248                                 self.out_file.write("\tnormal3 %f %f %f;\n"%tuple(v.no))
 249                                 norm=v.no
 250                         self.out_file.write("\tvertex3 %f %f %f;\n"%tuple(v.co))
 251                 self.out_file.write("};\n")
 252                 for s in strips:
 253                         self.out_file.write("batch TRIANGLE_STRIP\n{\n\tindices")
 254                         n=0
 255                         for v in s:
 256                                 self.out_file.write(" %u"%v.index)
 257                                 n+=1;
 258                                 if n%32==0:
 259                                         self.out_file.write(";\n\tindices")
 260                         self.out_file.write(";\n};\n")
 261
 262                 first=True
 263                 for f in faces:
 264                         if not f.flag:
 265                                 if first:
 266                                         self.out_file.write("batch TRIANGLES\n{\n")
 267                                         first=False
 268                                 for i in range(2, len(f.verts)):
 269                                         self.out_file.write("\tindices %u %u %u;\n"%(f.verts[0].index, f.verts[i-1].index, f.verts[i].index))
 270                 if not first:
 271                         self.out_file.write("};\n")
 272
 273
 274 class FrontEnd:
 275         def run(self):
 276                 #self.export(None)
 277                 Blender.Window.FileSelector(self.export, "Export MSP GL mesh", Blender.sys.makename(ext='.mesh'))
 278
 279         def export(self, fn):
 280                 exp=Exporter(fn)
 281                 #exp.use_degen_tris=False
 282                 exp.export()
 283
 284
 285 if __name__=="__main__":
 286         fe=FrontEnd()
 287         fe.run()