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                                         if not f.smooth:
  87                                                 vt.no=f.no
  88                                         self.verts.append(vt)
  89                                         vert_map[v.index]=vt
  90                                         f.verts[i]=vt
  91                                 else:
  92                                         f.verts[i]=vert_map[v.index]
  93
  94
  95 class Exporter:
  96         def __init__(self, fn):
  97                 self.filename=fn
  98                 if fn==None:
  99                         self.out_file=sys.stdout
 100                 else:
 101                         self.out_file=file(fn, "w")
 102                 self.use_strips=True
 103                 self.use_degen_tris=True
 104                 self.debug=False
 105
 106         def find_smooth_group(self, face, sg):
 107                 face.smooth_group=sg
 108                 sg.faces.append(face)
 109                 queue=[face]
 110                 while queue:
 111                         cur=queue.pop(0)
 112                         for e in cur.edges:
 113                                 if e.smooth:
 114                                         other=e.other_face(cur)
 115                                         if other and not other.smooth_group:
 116                                                 other.smooth_group=sg
 117                                                 sg.faces.append(other)
 118                                                 queue.append(other)
 119
 120         def create_strip(self, face):
 121                 edge=None
 122                 for e in face.edges:
 123                         other=e.other_face(face)
 124                         if other and other.smooth_group.index==face.smooth_group.index and not other.flag:
 125                                 edge=e
 126                                 break
 127
 128                 if not edge:
 129                         return None
 130
 131                 if self.debug:
 132                         print "Starting strip from %s"%[v.index for v in face.verts]
 133
 134                 verts=face.get_vertices_from(edge.v1, edge.v2)
 135                 result=[verts[-2], verts[-1]]
 136
 137                 while 1:
 138                         verts=face.get_vertices_from(*result[-2:])
 139                         k=len(result)%2
 140                         if self.debug:
 141                                 print "  %d %s"%(len(result), [v.index for v in verts])
 142
 143                         face.flag=True
 144                         if len(verts)==4 and not k:
 145                                 result.append(verts[3])
 146                         result.append(verts[2])
 147                         if len(verts)==4 and k:
 148                                 result.append(verts[3])
 149
 150                         i1=result[-2].index
 151                         i2=result[-1].index
 152                         ekey=(min(i1, i2), max(i1, i2))
 153                         for e in face.edges:
 154                                 if e.key==ekey:
 155                                         edge=e
 156                                         break
 157
 158                         next=edge.other_face(face)
 159                         if not next or next.smooth_group.index!=face.smooth_group.index or next.flag:
 160                                 break
 161                         face=next
 162
 163                 if self.debug:
 164                         print "  %s"%[v.index for v in result]
 165
 166                 return result
 167
 168         def export(self):
 169                 scene=bpy.data.scenes.active
 170
 171                 obj=scene.objects.active
 172                 if obj.getType()!="Mesh":
 173                         raise Exception, "Can only export Mesh data"
 174
 175                 mesh=obj.getData(mesh=True)
 176
 177                 faces=[Face(f) for f in mesh.faces]
 178
 179                 edges=dict([(e.key, Edge(e)) for e in mesh.edges])
 180                 for f in faces:
 181                         for e in f.edge_keys:
 182                                 edges[e].faces.append(f)
 183                                 f.edges.append(edges[e])
 184
 185                 smooth_limit=math.cos(mesh.degr*math.pi/180)
 186                 for e in edges.itervalues():
 187                         e.check_smooth(smooth_limit)
 188
 189                 if self.debug:
 190                         print "%d faces, %d edges"%(len(faces), len(edges))
 191
 192                 smooth_groups=[]
 193                 for f in faces:
 194                         if not f.smooth_group:
 195                                 sg=SmoothGroup(len(smooth_groups))
 196                                 smooth_groups.append(sg)
 197                                 self.find_smooth_group(f, sg)
 198
 199                 for sg in smooth_groups:
 200                         sg.find_vertices()
 201
 202                 if self.debug:
 203                         print "%d smooth groups:"
 204                         for i in range(len(smooth_groups)):
 205                                 sg=smooth_groups[i]
 206                                 print "  %d: %d faces, %d vertices"%(i, len(sg.faces), len(sg.verts))
 207
 208                 strips=[]
 209                 if self.use_strips:
 210                         for sg in smooth_groups:
 211                                 for f in sg.faces:
 212                                         if not f.flag:
 213                                                 strip=self.create_strip(f)
 214                                                 if strip:
 215                                                         strips.append(strip)
 216
 217                         if self.use_degen_tris:
 218                                 big_strip=[]
 219                                 for s in strips:
 220                                         if big_strip:
 221                                                 big_strip+=[big_strip[-1], s[0]]
 222                                         big_strip+=s
 223
 224                                 for f in faces:
 225                                         if not f.flag:
 226                                                 if big_strip:
 227                                                         big_strip+=[big_strip[-1], f.verts[0]]
 228                                                 big_strip+=[f.verts[i] for i in (0, 1, -1)]
 229                                                 if len(f.verts)==4:
 230                                                         big_strip.append(f.verts[-2])
 231                                                 f.flag=True
 232
 233                                 strips=[big_strip]
 234
 235                 verts=[]
 236                 for sg in smooth_groups:
 237                         for v in sg.verts:
 238                                 v.index=len(verts)
 239                                 verts.append(v)
 240
 241                 self.out_file.write("vertices NORMAL3_VERTEX3\n{\n")
 242                 norm=None
 243                 for v in verts:
 244                         if v.no!=norm:
 245                                 self.out_file.write("\tnormal3 %f %f %f;\n"%tuple(v.no))
 246                                 norm=v.no
 247                         self.out_file.write("\tvertex3 %f %f %f;\n"%tuple(v.co))
 248                 self.out_file.write("};\n")
 249                 for s in strips:
 250                         self.out_file.write("batch TRIANGLE_STRIP\n{\n\tindices")
 251                         n=0
 252                         for v in s:
 253                                 self.out_file.write(" %u"%v.index)
 254                                 n+=1;
 255                                 if n%32==0:
 256                                         self.out_file.write(";\n\tindices")
 257                         self.out_file.write(";\n};\n")
 258
 259                 first=True
 260                 for f in faces:
 261                         if not f.flag:
 262                                 if first:
 263                                         self.out_file.write("batch TRIANGLES\n{\n")
 264                                         first=False
 265                                 for i in range(2, len(f.verts)):
 266                                         self.out_file.write("\tindices %u %u %u;\n"%(f.verts[0].index, f.verts[i-1].index, f.verts[i].index))
 267                 if not first:
 268                         self.out_file.write("};\n")
 269
 270
 271 class FrontEnd:
 272         def run(self):
 273                 #self.export(None)
 274                 Blender.Window.FileSelector(self.export, "Export MSP GL mesh", Blender.sys.makename(ext='.mesh'))
 275
 276         def export(self, fn):
 277                 exp=Exporter(fn)
 278                 #exp.use_degen_tris=False
 279                 exp.export()
 280
 281
 282 if __name__=="__main__":
 283         fe=FrontEnd()
 284         fe.run()