blender/io_mesh_mspgl/mesh.py

   1 import math
   2 import mathutils
   3
   4 def make_edge_key(i1, i2):
   5         return (min(i1, i2), max(i1, i2))
   6
   7 class Edge:
   8         def __init__(self, me):
   9                 if me.__class__==Edge:
  10                         self._medge = me._medge
  11                         self.vertices = me.vertices[:]
  12                         self.smooth = me.smooth
  13                 else:
  14                         self._medge = me
  15                         self.smooth = False
  16                 self.faces = []
  17
  18         def __getattr__(self, attr):
  19                 return getattr(self._medge, attr)
  20
  21         def check_smooth(self, limit):
  22                 if len(self.faces)!=2:
  23                         return
  24
  25                 d = self.faces[0].normal.dot(self.faces[1].normal)
  26                 self.smooth = ((d>limit and self.faces[0].use_smooth and self.faces[1].use_smooth) or d>0.99995)
  27
  28         def other_face(self, f):
  29                 if f.index==self.faces[0].index:
  30                         if len(self.faces)>=2:
  31                                 return self.faces[1]
  32                         else:
  33                                 return None
  34                 else:
  35                         return self.faces[0]
  36
  37
  38 class Vertex:
  39         def __init__(self, mv):
  40                 if mv.__class__==Vertex:
  41                         self._mvert = mv._mvert
  42                         self.normal = mv.normal
  43                         self.uvs = mv.uvs[:]
  44                 else:
  45                         self._mvert = mv
  46                         self.uvs = []
  47                 self.flag = False
  48                 self.faces = []
  49                 self.tan = None
  50                 self.bino = None
  51
  52         def __getattr__(self, attr):
  53                 return getattr(self._mvert, attr)
  54
  55         def __cmp__(self, other):
  56                 if other is None:
  57                         return 1
  58                 return cmp(self.index, other.index)
  59
  60
  61 class Face:
  62         def __init__(self, mf):
  63                 self._mface = mf
  64                 self.edges = []
  65                 self.vertices = mf.vertices[:]
  66                 self.uvs = []
  67                 self.flag = False
  68                 self.material = None
  69
  70         def __getattr__(self, attr):
  71                 return getattr(self._mface, attr)
  72
  73         def __cmp__(self, other):
  74                 if other is None:
  75                         return 1
  76                 return cmp(self.index, other.index)
  77
  78         def pivot_vertices(self, *vt):
  79                 flags = [(v in vt) for v in self.vertices]
  80                 l = len(self.vertices)
  81                 for i in range(l):
  82                         if flags[i] and not flags[(i+l-1)%l]:
  83                                 return self.vertices[i:]+self.vertices[:i]
  84
  85         def get_edge(self, v1, v2):
  86                 key = make_edge_key(v1.index, v2.index)
  87                 for e in self.edges:
  88                         if e.key==key:
  89                                 return e
  90                 raise KeyError("No edge %s"%(key,))
  91
  92
  93 class Line:
  94         def __init__(self, e):
  95                 self.edge = e
  96                 self.vertices = e.vertices[:]
  97                 self.flag = False
  98
  99
 100 def uvtex_unit_number(uvtex):
 101         dot = uvtex.name.find('.')
 102         if dot!=-1 and uvtex.name[dot+1:dot+5]=="unit" and uvtex.name[dot+5:].isdigit():
 103                 return int(uvtex.name[dot+5])
 104         else:
 105                 return 1000
 106
 107 class Mesh:
 108         def __init__(self, m):
 109                 self._mesh = m
 110
 111                 self.vertices = [Vertex(v) for v in self.vertices]
 112                 self.faces = [Face(f) for f in self.faces]
 113
 114                 self.materials = self.materials[:]
 115
 116                 self.uv_textures = [u for u in self.uv_textures if not u.name.endswith(".hidden")]
 117                 self.uv_textures.sort(key=uvtex_unit_number)
 118
 119                 for f in self.faces:
 120                         f.vertices = [self.vertices[i] for i in f.vertices]
 121                         for v in f.vertices:
 122                                 v.faces.append(f)
 123                         for u in self.uv_textures:
 124                                 r = u.data[f.index].uv_raw;
 125                                 f.uvs.append([(r[i], r[i+1]) for i in range(0, 8, 2)])
 126
 127                 self.edges = dict([(e.key, Edge(e)) for e in self.edges])
 128                 for f in self.faces:
 129                         for k in f.edge_keys:
 130                                 e = self.edges[k]
 131                                 e.faces.append(self.faces[f.index])
 132                                 f.edges.append(e)
 133
 134                 self.lines = [Line(e) for e in self.edges.values() if not e.faces]
 135
 136                 if self.use_auto_smooth:
 137                         smooth_limit = math.cos(self.auto_smooth_angle*math.pi/180)
 138                 else:
 139                         smooth_limit = -1
 140
 141                 for e in self.edges.values():
 142                         e.vertices = [self.vertices[i] for i in e.vertices]
 143                         e.check_smooth(smooth_limit)
 144
 145         def __getattr__(self, attr):
 146                 return getattr(self._mesh, attr)
 147
 148         def splice(self, other):
 149                 material_map = []
 150                 for m in other.materials:
 151                         if m in self.materials:
 152                                 material_map.append(self.materials.index(m))
 153                         else:
 154                                 material_map.append(len(self.materials))
 155                                 self.materials.append(m)
 156
 157                 offset = len(self.vertices)
 158                 for v in other.vertices:
 159                         v.index += offset
 160                         self.vertices.append(v)
 161
 162                 offset = len(self.faces)
 163                 for f in other.faces:
 164                         f.index += offset
 165                         f.material = material_map[f.material_index]
 166                         self.faces.append(f)
 167
 168                 for e in other.edges.values():
 169                         e.key = make_edge_key(e.vertices[0].index, e.vertices[1].index)
 170                         self.edges[e.key] = e
 171
 172                 self.lines += other.lines
 173
 174         def flatten_faces(self):
 175                 for f in self.faces:
 176                         f.use_smooth = False
 177
 178                 for e in self.edges.values():
 179                         e.check_smooth(1)
 180
 181         def generate_material_uv(self):
 182                 for f in self.faces:
 183                         f.uv = ([(f.material_index+0.5)/len(self.materials), 0.5],)*len(f.vertices)
 184                 self.has_uv = True
 185
 186         def split_vertices(self, find_group_func, progress, *args):
 187                 groups = []
 188                 for i in range(len(self.vertices)):
 189                         v = self.vertices[i]
 190                         for f in v.faces:
 191                                 f.flag = False
 192
 193                         vg = []
 194                         for f in v.faces:
 195                                 if not f.flag:
 196                                         vg.append(find_group_func(v, f, *args))
 197
 198                         groups.append(vg)
 199
 200                         if progress:
 201                                 progress.set_progress(i*0.5/len(self.vertices))
 202
 203                 for i in range(len(self.vertices)):
 204                         if len(groups[i])==1:
 205                                 continue
 206
 207                         for g in groups[i][1:]:
 208                                 v = Vertex(self.vertices[i])
 209                                 v.index = len(self.vertices)
 210                                 self.vertices.append(v)
 211
 212                                 for f in g:
 213                                         for j in range(len(f.edges)):
 214                                                 e = f.edges[j]
 215
 216                                                 if self.vertices[i] not in e.vertices:
 217                                                         continue
 218
 219                                                 if e.other_face(f) not in g and len(e.faces)>=2:
 220                                                         e.faces.remove(f)
 221                                                         e = Edge(e)
 222                                                         f.edges[j] = e
 223                                                         e.faces.append(f)
 224                                                 else:
 225                                                         del self.edges[e.key]
 226
 227                                                 e.vertices[e.vertices.index(self.vertices[i])] = v
 228
 229                                                 e.key = make_edge_key(e.vertices[0].index, e.vertices[1].index)
 230                                                 self.edges[e.key] = e
 231
 232                                         self.vertices[i].faces.remove(f)
 233                                         f.vertices[f.vertices.index(self.vertices[i])] = v
 234                                         v.faces.append(f)
 235
 236                         if progress:
 237                                 progress.set_progress(0.5+i*0.5/len(self.vertices))
 238
 239         def split_smooth(self, progress = None):
 240                 self.split_vertices(self.find_smooth_group, progress)
 241
 242         def split_uv(self, index, progress = None):
 243                 self.split_vertices(self.find_uv_group, progress, index)
 244
 245         def find_smooth_group(self, vertex, face):
 246                 face.flag = True
 247                 queue = [face]
 248
 249                 for f in queue:
 250                         for e in f.edges:
 251                                 other = e.other_face(f)
 252                                 if other not in vertex.faces:
 253                                         continue
 254
 255                                 if e.smooth:
 256                                         if not other.flag:
 257                                                 other.flag = True
 258                                                 queue.append(other)
 259
 260                 return queue
 261
 262         def find_uv_group(self, vertex, face, index):
 263                 uv = face.uvs[index][face.vertices.index(vertex)]
 264                 face.flag = True
 265                 group = [face]
 266                 for f in vertex.faces:
 267                         if not f.flag and f.uvs[index][f.vertices.index(vertex)]==uv:
 268                                 f.flag = True
 269                                 group.append(f)
 270                 return group
 271
 272         def compute_normals(self):
 273                 for v in self.vertices:
 274                         if v.faces:
 275                                 v.normal = mathutils.Vector()
 276                                 for f in v.faces:
 277                                         fv = f.pivot_vertices(v)
 278                                         edge1 = fv[1].co-fv[0].co
 279                                         edge2 = fv[-1].co-fv[0].co
 280                                         weight = 1
 281                                         if len(f.get_edge(fv[0], fv[1]).faces)==1:
 282                                                 weight += 1
 283                                         if len(f.get_edge(fv[0], fv[-1]).faces)==1:
 284                                                 weight += 1
 285                                         v.normal += f.normal*edge1.angle(edge2)*weight
 286                                 v.normal.normalize()
 287                         else:
 288                                 # XXX Should use edges to compute normal
 289                                 v.normal = mathutils.Vector(0, 0, 1)
 290
 291         def compute_uv(self):
 292                 for v in self.vertices:
 293                         if v.faces:
 294                                 f = v.faces[0]
 295                                 i = f.vertices.index(v)
 296                                 v.uvs = [u[i] for u in f.uvs]
 297
 298         def compute_tbn(self, uvtex):
 299                 if not self.uv_textures:
 300                         return
 301
 302                 uvtex_names = [u.name for u in self.uv_textures]
 303                 if uvtex in uvtex_names:
 304                         uvtex_index = uvtex_names.index(uvtex)
 305                 else:
 306                         uvtex_index = 0
 307
 308                 for v in self.vertices:
 309                         v.tan = mathutils.Vector()
 310                         v.bino = mathutils.Vector()
 311                         for f in v.faces:
 312                                 fv = f.pivot_vertices(v)
 313                                 uv0 = fv[0].uvs[uvtex_index]
 314                                 uv1 = fv[1].uvs[uvtex_index]
 315                                 uv2 = fv[-1].uvs[uvtex_index]
 316                                 du1 = uv1[0]-uv0[0]
 317                                 du2 = uv2[0]-uv0[0]
 318                                 dv1 = uv1[1]-uv0[1]
 319                                 dv2 = uv2[1]-uv0[1]
 320                                 edge1 = fv[1].co-fv[0].co
 321                                 edge2 = fv[-1].co-fv[0].co
 322                                 div = (du1*dv2-du2*dv1)
 323                                 if div:
 324                                         mul = edge1.angle(edge2)/div
 325                                         v.tan += (edge1*dv2-edge2*dv1)*mul
 326                                         v.bino += (edge2*du1-edge1*du2)*mul
 327
 328                         if v.tan.length:
 329                                 v.tan.normalize()
 330                         if v.bino.length:
 331                                 v.bino.normalize()
 332
 333         def create_strip(self, face, max_len):
 334                 edge = None
 335                 for e in face.edges:
 336                         other = e.other_face(face)
 337                         if other and not other.flag:
 338                                 edge = e
 339                                 break
 340
 341                 if not edge:
 342                         return None
 343
 344                 vertices = face.pivot_vertices(*edge.vertices)
 345                 if len(vertices)==3:
 346                         result = [vertices[-1], vertices[0]]
 347                 else:
 348                         result = [vertices[-2], vertices[-1]]
 349
 350                 while 1:
 351                         vertices = face.pivot_vertices(*result[-2:])
 352                         k = len(result)%2
 353
 354                         face.flag = True
 355                         if len(vertices)==4 and not k:
 356                                 result.append(vertices[3])
 357                         result.append(vertices[2])
 358                         if len(vertices)==4 and k:
 359                                 result.append(vertices[3])
 360
 361                         if len(result)>=max_len:
 362                                 break
 363
 364                         edge = face.get_edge(*result[-2:])
 365
 366                         next = edge.other_face(face)
 367                         if not next or next.flag:
 368                                 break
 369                         face = next
 370
 371                 return result