self.max_strip_len = 1024
self.optimize_cache = True
self.cache_size = 64
- self.export_lines = False
- self.export_uv = "UNIT0"
- self.tbn_vecs = False
- self.tbn_uvtex = ""
self.compound = False
self.material_tex = False
- self.smoothing = "MSPGL"
- self.export_groups = False
- self.max_groups = 2
def stripify(self, mesh, progress=None):
for f in mesh.faces:
cache = VertexCache(self.cache_size)
island = []
+ face_neighbors = []
island_strips = []
while 1:
if not island:
face = queue.pop(0)
island.append(face)
- for n in f.get_neighbors():
+ for n in face.get_neighbors():
if not n.flag:
n.flag = True
queue.append(n)
+ face_neighbors = [f.get_neighbors() for f in island]
+
# Unflag the island for the next phase
for f in island:
f.flag = False
# or along borders of a non-closed island.
best = 5
face = None
- for f in island:
+ for i, f in enumerate(island):
if f.flag:
continue
- score = sum(not n.flag for n in f.get_neighbors())
+ score = sum(not n.flag for n in face_neighbors[i])
if score>0 and score<best:
face = f
best = score
for o, m in objs:
if o.data.winding_test:
winding_test = True
+ if o.material_tex:
+ self.material_tex = True
bmesh = o.to_mesh(context.scene, True, "PREVIEW")
bmeshes.append(bmesh)
me = Mesh(bmesh)
if progress:
progress.set_task("Smoothing", 0.05, 0.35)
- if self.smoothing=="NONE":
+ if mesh.smoothing=="NONE":
mesh.flatten_faces()
mesh.split_smooth(progress)
- if self.smoothing!="BLENDER":
+ if mesh.smoothing!="BLENDER":
mesh.compute_normals()
- if self.export_groups:
- mesh.sort_vertex_groups(self.max_groups)
+ if mesh.vertex_groups:
+ mesh.sort_vertex_groups(mesh.max_groups_per_vertex)
# Create a mapping from vertex group indices to bone indices
first_obj = objs[0][0]
texunits = []
force_unit0 = False
- if mesh.uv_layers and (self.export_uv!="NONE" or self.material_tex):
+ if mesh.uv_layers and (mesh.use_uv!="NONE" or self.material_tex):
# Figure out which UV layers to export
- if self.export_uv=="ALL":
+ if mesh.use_uv=="ALL":
texunits = range(len(mesh.uv_layers))
elif self.material_tex:
# The material UV layer is always the last one
texunits = [(i, mesh.uv_layers[i]) for i in texunits]
texunits = [u for u in texunits if not u[1].hidden]
- if self.tbn_vecs:
+ if mesh.tbn_vecs:
# TBN coordinates must be generated before vertices are split by any other layer
uv_names = [u.name for i, u in texunits]
- if self.tbn_uvtex in uv_names:
- tbn_index = uv_names.index(self.tbn_uvtex)
+ if mesh.tbn_uvtex in uv_names:
+ tbn_index = uv_names.index(mesh.tbn_uvtex)
unit = texunits[tbn_index]
del texunits[tbn_index]
texunits.insert(0, unit)
if progress:
progress.set_task("Splitting UVs", 0.35+0.3*i/len(texunits), 0.35+0.3*(i+1)/len(texunits))
mesh.split_uv(i, progress)
- if self.tbn_vecs and u.name==self.tbn_uvtex:
+ if mesh.tbn_vecs and u.name==mesh.tbn_uvtex:
mesh.compute_uv()
mesh.compute_tbn(i)
fmt.append("TEXCOORD"+size)
else:
fmt.append("TEXCOORD%s_%d"%(size, u.unit))
- if self.tbn_vecs:
+ if mesh.tbn_vecs:
fmt += ["TANGENT3", "BINORMAL3"]
- if self.export_groups:
- fmt.append("ATTRIB%d_5"%(self.max_groups*2))
+ if mesh.vertex_groups:
+ fmt.append("ATTRIB%d_5"%(mesh.max_groups_per_vertex*2))
fmt.append("VERTEX3")
out_file.begin("vertices", *fmt)
normal = None
else:
out_file.write("multitexcoord"+size, u.unit, *v.uvs[i])
uvs[i] = v.uvs[i]
- if self.tbn_vecs:
+ if mesh.tbn_vecs:
if v.tan!=tan:
out_file.write("tangent3", *v.tan)
tan = v.tan
if v.bino!=bino:
out_file.write("binormal3", *v.bino)
bino = v.bino
- if self.export_groups:
- group_attr = [(group_index_map[g.group], g.weight*v.group_weight_scale) for g in v.groups[:self.max_groups]]
- while len(group_attr)<self.max_groups:
+ if mesh.vertex_groups:
+ group_attr = [(group_index_map[g.group], g.weight*v.group_weight_scale) for g in v.groups[:mesh.max_groups_per_vertex]]
+ while len(group_attr)<mesh.max_groups_per_vertex:
group_attr.append((0, 0.0))
group_attr = list(itertools.chain(*group_attr))
if group_attr!=group:
out_file.write("indices", f.vertices[0].index, f.vertices[i-1].index, f.vertices[i].index)
out_file.end()
- if self.export_lines and mesh.lines:
+ if mesh.use_lines and mesh.lines:
out_file.begin("batch", "LINES")
for l in mesh.lines:
out_file.write("indices", l.vertices[0].index, l.vertices[1].index)