Refactor strip generation code and add comments

[libs/gl.git] / blender / io_mesh_mspgl / export_mspgl.py

diff --git a/blender/io_mesh_mspgl/export_mspgl.py b/blender/io_mesh_mspgl/export_mspgl.py
index 0e96c4249631ebc17844f1e3267beab1469c49f7..124114e5fe60cb1111cf0385428bb149c749cd26 100644 (file)
--- a/blender/io_mesh_mspgl/export_mspgl.py
+++ b/blender/io_mesh_mspgl/export_mspgl.py
@@ -94,6 +94,7 @@ class Exporter:
                island_strips = []
                while 1:
                        if not island:
+                               # No current island; find any unused face to start from
                                queue = []
                                for f in mesh.faces:
                                        if not f.flag:
@@ -104,38 +105,46 @@ class Exporter:
                                if not queue:
                                        break
 
+                               # Find all faces connected to the first one
                                while queue:
-                                       f = queue[0]
-                                       del queue[0]
-                                       island.append(f)
+                                       face = queue.pop(0)
+                                       island.append(face)
 
-                                       for e in f.edges:
-                                               other = e.other_face(f)
-                                               if other and not other.flag:
-                                                       other.flag = True
-                                                       queue.append(other)
+                                       for n in f.get_neighbors():
+                                               n.flag = True
+                                               queue.append(n)
 
+                               # Unflag the island for the next phase
                                for f in island:
                                        f.flag = False
 
+                       # Find an unused face with as few unused neighbors as possible, but
+                       # at least one.  This heuristic gives a preference to faces in corners
+                       # or along borders of a non-closed island.
                        best = 5
                        face = None
                        for f in island:
                                if f.flag:
                                        continue
-                               score = 0
-                               for e in f.edges:
-                                       other = e.other_face(f)
-                                       if other and not other.flag:
-                                               score += 1
+
+                               score = sum(n.flag for n in f.get_neighbors())
                                if score>0 and score<best:
                                        face = f
                                        best = score
 
-                       if not face:
+                       if face:
+                               # Create a strip starting from the face.  This will flag the faces.
+                               strip = mesh.create_strip(face, self.max_strip_len)
+                               if strip:
+                                       island_strips.append(strip)
+                       else:
+                               # Couldn't find a candidate face for starting a strip, so we're
+                               # done with this island
                                while island_strips:
                                        best = 0
                                        if cache:
+                                               # Find the strip that benefits the most from the current
+                                               # contents of the vertex cache
                                                best_hits = 0
                                                for i in range(len(island_strips)):
                                                        hits = cache.test_strip(island_strips[i])
@@ -143,28 +152,23 @@ class Exporter:
                                                                best = i
                                                                best_hits = hits
 
-                                       s = island_strips[best]
-                                       del island_strips[best]
-                                       strips.append(s)
+                                       strip = island_strips.pop(best)
+                                       strips.append(strip)
 
                                        if cache:
-                                               cache.fetch_strip(s)
+                                               cache.fetch_strip(strip)
 
                                faces_done += len(island)
                                if progress:
                                        progress.set_progress(float(faces_done)/len(mesh.faces))
 
+                               # Collect any faces that weren't used in strips
                                loose += [f for f in island if not f.flag]
                                for f in island:
                                        f.flag = True
 
                                island = []
                                island_strips = []
-                               continue
-
-                       strip = mesh.create_strip(face, self.max_strip_len)
-                       if strip:
-                               island_strips.append(strip)
 
                if cache:
                        cache = VertexCache(self.cache_size)
@@ -175,6 +179,8 @@ class Exporter:
 
                        for s in strips:
                                if big_strip:
+                                       # Generate glue elements, ensuring that the next strip begins at
+                                       # an even position
                                        glue = [big_strip[-1], s[0]]
                                        if len(big_strip)%2:
                                                glue += [s[0]]
@@ -188,6 +194,8 @@ class Exporter:
                                        total_hits += cache.fetch_strip(s)
 
                        for f in loose:
+                               # Add loose faces to the end.  This wastes space, using five
+                               # elements per triangle and six elements per quad.
                                if len(big_strip)%2:
                                        order = (-1, -2, 0, 1)
                                else: