+ steps = -1
+ split_done = 0
+ marked_face = 0
+
+ while len(facelist):
+ print "\n----------------------"
+ P = facelist[0]
+
+ #steps += 1
+ #if steps == 3:
+ # maplist = facelist
+ # break
+ print len(facelist)
+ if len(facelist) == 33:
+ #maplist = facelist
+ break
+
+
+ #pSign = 1
+ #if P.normal[2] < 0:
+ # pSign = -1
+ pSign = sign(P.normal[2])
+
+ # We can discard faces thar are perpendicular to the view
+ if pSign == 0:
+ facelist.remove(P)
+ continue
+
+
+ split_done = 0
+ face_marked = 0
+
+ for Q in facelist[1:]:
+
+ debug("P.smooth: " + str(P.smooth) + "\n")
+ debug("Q.smooth: " + str(Q.smooth) + "\n")
+ debug("\n")
+
+ #qSign = 1
+ #if Q.normal[2] < 0:
+ # qSign = -1
+ qSign = sign(Q.normal[2])
+
+ # We need to test only those Qs whose furthest vertex
+ # is closer to the observer than the closest vertex of P.
+
+ zP = [v.co[2] for v in P.v]
+ zQ = [v.co[2] for v in Q.v]
+ ZOverlap = min(zP) < max(zQ)
+
+ if not ZOverlap:
+ debug("\nTest 0\n")
+ debug("NOT Z OVERLAP!\n")
+ if Q.smooth == 0:
+ # If Q is not marked then we can safely print P
+ break
+ else:
+ debug("met a marked face\n")
+ continue
+
+ # Test 1: X extent overlapping
+ xP = [v.co[0] for v in P.v]
+ xQ = [v.co[0] for v in Q.v]
+ notXOverlap = (max(xP) <= min(xQ)) or (max(xQ) <= min(xP))
+
+ if notXOverlap:
+ debug("\nTest 1\n")
+ debug("NOT X OVERLAP!\n")
+ continue
+
+ # Test 2: Y extent Overlapping
+ yP = [v.co[1] for v in P.v]
+ yQ = [v.co[1] for v in Q.v]
+ notYOverlap = (max(yP) <= min(yQ)) or (max(yQ) <= min(yP))
+
+ if notYOverlap:
+ debug("\nTest 2\n")
+ debug("NOT Y OVERLAP!\n")
+ continue
+
+
+ # Test 3: P vertices are all behind the plane of Q
+ n = 0
+ for Pi in P:
+ d = qSign * Distance(Vector(Pi), Q)
+ if d >= -EPS:
+ n += 1
+ pVerticesBehindPlaneQ = (n == len(P))
+
+ if pVerticesBehindPlaneQ:
+ debug("\nTest 3\n")
+ debug("P BEHIND Q!\n")
+ continue
+
+
+ # Test 4: Q vertices in front of the plane of P
+ n = 0
+ for Qi in Q:
+ d = pSign * Distance(Vector(Qi), P)
+ if d <= EPS:
+ n += 1
+ qVerticesInFrontPlaneP = (n == len(Q))
+
+ if qVerticesInFrontPlaneP:
+ debug("\nTest 4\n")
+ debug("Q IN FRONT OF P!\n")
+ continue
+
+ # Test 5: Line Intersections... TODO
+ # Check if polygons effectively overlap each other, not only
+ # boundig boxes as done before.
+ # Since we We are working in normalized projection coordinates
+ # we kust check if polygons intersect.
+
+ if not projectionsOverlap(P, Q):
+ debug("\nTest 5\n")
+ debug("Projections do not overlap!\n")
+ continue
+
+
+ # We still do not know if P obscures Q.
+
+ # But if Q is marked we do a split trying to resolve a
+ # difficulty (maybe a visibility cycle).
+ if Q.smooth == 1:
+ # Split P or Q
+ debug("Possibly a cycle detected!\n")
+ debug("Split here!!\n")
+ old_facelist = facelist[:]
+ facelist = facesplit(P, Q, facelist, nmesh)
+ split_done = 1
+ break
+
+
+ # The question now is: Does Q obscure P?
+
+ # Test 3bis: Q vertices are all behind the plane of P
+ n = 0
+ for Qi in Q:
+ d = pSign * Distance(Vector(Qi), P)
+ if d >= -EPS:
+ n += 1
+ qVerticesBehindPlaneP = (n == len(Q))
+
+ if qVerticesBehindPlaneP:
+ debug("\nTest 3bis\n")
+ debug("Q BEHIND P!\n")
+
+
+ # Test 4bis: P vertices in front of the plane of Q
+ n = 0
+ for Pi in P:
+ d = qSign * Distance(Vector(Pi), Q)
+ if d <= EPS:
+ n += 1
+ pVerticesInFrontPlaneQ = (n == len(P))
+
+ if pVerticesInFrontPlaneQ:
+ debug("\nTest 4bis\n")
+ debug("P IN FRONT OF Q!\n")
+
+
+ # We don't even know if Q does obscure P, so they should
+ # intersect each other, split one of them in two parts.
+ if not qVerticesBehindPlaneP and not pVerticesInFrontPlaneQ:
+ debug("\nSimple Intersection?\n")
+ debug("Test 3bis or 4bis failed\n")
+ debug("Split here!!2\n")
+
+ old_facelist = facelist[:]
+ facelist = facesplit(P, Q, facelist, nmesh)
+
+ steps += 1
+ if steps == 2:
+ maplist = [P, Q]
+ print P, Q
+ split_done = 1
+ break
+
+
+ facelist.remove(Q)
+ facelist.insert(0, Q)
+ Q.smooth = 1
+ face_marked = 1
+
+ # Make merked faces BLUE. so to see them
+ #for c in Q.col:
+ # c.r = 0
+ # c.g = 0
+ # c.b = 255
+ # c.a = 255
+
+ debug("Q marked!\n")
+ print [f.smooth for f in facelist]
+ break
+
+ # Write P!
+ if split_done == 0 and face_marked == 0:
+ P = facelist[0]
+ facelist.remove(P)
+ maplist.append(P)
+
+ progress.update()
+ #if progress.progressModel.getProgress() == 100:
+ # break
+ if steps == 2:
+ """
+ for c in Q.col:
+ c.r = 0
+ c.g = 0
+ c.b = 255
+ c.a = 255
+ for c in P.col:
+ c.r = 0
+ c.g = 0
+ c.b = 255
+ c.a = 255
+ """
+ print steps
+ #maplist.append(P)
+ #maplist.append(Q)
+
+ # for f in facelist:
+ # if f not in old_facelist:
+ # print "splitted?"
+ # maplist.append(f)
+
+ break
+ """
+ """
+
+
+
+ nmesh.faces = maplist
+
+ for f in nmesh.faces:
+ f.sel = 1
+ nmesh.update()
+ print nmesh.faces
+
+ def _doHiddenSurfaceRemoval(self, mesh):
+ """Do HSR for the given mesh.
+ """
+ if len(mesh.faces) == 0:
+ return
+
+ if config.polygons['HSR'] == 'PAINTER':
+ print "\nUsing the Painter algorithm for HSR."
+ self.__simpleDepthSort(mesh)
+
+ elif config.polygons['HSR'] == 'NEWELL':
+ print "\nUsing the Newell's algorithm for HSR."
+ self.__newellDepthSort(mesh)
+
projects / vrm.git / blobdiff