X-Git-Url: https://git.ao2.it/vrm.git/blobdiff_plain/50d03fe3eb45bdc4a82144565911695a58e82f85..58b487476c46b70b9900d613bd875a3d9d42a515:/vrm.py diff --git a/vrm.py b/vrm.py index f7382a7..0338065 100755 --- a/vrm.py +++ b/vrm.py @@ -8,7 +8,7 @@ Tooltip: 'Vector Rendering Method script' __author__ = "Antonio Ospite" __url__ = ["http://projects.blender.org/projects/vrm"] -__version__ = "0.3" +__version__ = "0.3.beta" __bpydoc__ = """\ Render the scene and save the result in vector format. @@ -42,8 +42,6 @@ __bpydoc__ = """\ # --------------------------------------------------------------------- # # Things TODO for a next release: -# - Use multiple lighting sources in color calculation, -# (this is part of the "shading refactor") and use light color! # - FIX the issue with negative scales in object tranformations! # - Use a better depth sorting algorithm # - Implement clipping of primitives and do handle object intersections. @@ -56,26 +54,49 @@ __bpydoc__ = """\ # - Consider SMIL for animation handling instead of ECMA Script? (Firefox do # not support SMIL for animations) # - Switch to the Mesh structure, should be considerably faster -# (partially done, but with Mesh we cannot sort faces, yet) +# (partially done, but with Mesh we cannot sort faces, yet) # - Implement Edge Styles (silhouettes, contours, etc.) (partially done). -# - Implement Shading Styles? (for now we use Flat Shading) (partially done). +# - Implement Shading Styles? (partially done, to make more flexible). # - Add Vector Writers other than SVG. +# - set the background color! +# - Check memory use!! # # --------------------------------------------------------------------- # # Changelog: # -# vrm-0.3.py - 2006-05-19 -# * First release after code restucturing. -# Now the script offers a useful set of functionalities -# and it can render animations, too. +# vrm-0.3.py - ... +# * First release after code restucturing. +# Now the script offers a useful set of functionalities +# and it can render animations, too. +# * Optimization in Renderer.doEdgeStyle(), build a topology cache +# so to speed up the lookup of adjacent faces of an edge. +# Thanks ideasman42. +# * The SVG output is now SVG 1.0 valid. +# Checked with: http://jiggles.w3.org/svgvalidator/ValidatorURI.html +# * Progress indicator during HSR. +# * Initial SWF output support (using ming) +# * Fixed a bug in the animation code, now the projection matrix is +# recalculated at each frame! +# * PDF output (using reportlab) +# * Fixed another problem in the animation code the current frame was off +# by one +# * Use fps as specified in blender when VectorWriter handles animation +# * Remove the real file opening in the abstract VectorWriter # # --------------------------------------------------------------------- import Blender -from Blender import Scene, Object, Mesh, NMesh, Material, Lamp, Camera +from Blender import Scene, Object, Mesh, NMesh, Material, Lamp, Camera, Window from Blender.Mathutils import * from math import * +import sys, time + +# Constants +EPS = 10e-5 + +# We use a global progress Indicator Object +progress = None # Some global settings @@ -83,14 +104,17 @@ from math import * class config: polygons = dict() polygons['SHOW'] = True - polygons['SHADING'] = 'TOON' + polygons['SHADING'] = 'FLAT' # FLAT or TOON + polygons['HSR'] = 'NEWELL' # PAINTER or NEWELL # Hidden to the user for now polygons['EXPANSION_TRICK'] = True + polygons['TOON_LEVELS'] = 2 + edges = dict() - edges['SHOW'] = True + edges['SHOW'] = False edges['SHOW_HIDDEN'] = False - edges['STYLE'] = 'SILHOUETTE' + edges['STYLE'] = 'MESH' # MESH or SILHOUETTE edges['WIDTH'] = 2 edges['COLOR'] = [0, 0, 0] @@ -100,37 +124,664 @@ class config: output['JOIN_OBJECTS'] = True +# Utility functions +print_debug = False + +def dumpfaces(flist, filename): + """Dump a single face to a file. + """ + if not print_debug: + return + + class tmpmesh: + pass + + m = tmpmesh() + m.faces = flist + + writerobj = SVGVectorWriter(filename) + + writerobj.open() + writerobj._printPolygons(m) + + writerobj.close() + +def debug(msg): + if print_debug: + sys.stderr.write(msg) + +def EQ(v1, v2): + return (abs(v1[0]-v2[0]) < EPS and + abs(v1[1]-v2[1]) < EPS ) +by_furthest_z = (lambda f1, f2: + cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2])+EPS) + ) + +def sign(x): + + if x < -EPS: + #if x < 0: + return -1 + elif x > EPS: + #elif x > 0: + return 1 + else: + return 0 + # --------------------------------------------------------------------- # -## Utility Mesh class +## HSR Utility class # # --------------------------------------------------------------------- -class MeshUtils: - def getEdgeAdjacentFaces(edge, mesh): - """Get the faces adjacent to a given edge. +EPS = 10e-5 +INF = 10e5 + +class HSR: + """A utility class for HSR processing. + """ + + def is_nonplanar_quad(face): + """Determine if a quad is non-planar. + + From: http://mathworld.wolfram.com/Coplanar.html - There can be 0, 1 or more (usually 2) faces adjacent to an edge. + Geometric objects lying in a common plane are said to be coplanar. + Three noncollinear points determine a plane and so are trivially coplanar. + Four points are coplanar iff the volume of the tetrahedron defined by them is + 0, + + | x_1 y_1 z_1 1 | + | x_2 y_2 z_2 1 | + | x_3 y_3 z_3 1 | + | x_4 y_4 z_4 1 | == 0 + + Coplanarity is equivalent to the statement that the pair of lines + determined by the four points are not skew, and can be equivalently stated + in vector form as (x_3-x_1).[(x_2-x_1)x(x_4-x_3)]==0. + + An arbitrary number of n points x_1, ..., x_n can be tested for + coplanarity by finding the point-plane distances of the points + x_4, ..., x_n from the plane determined by (x_1,x_2,x_3) + and checking if they are all zero. + If so, the points are all coplanar. + + We here check only for 4-point complanarity. """ - adjface_list = [] + n = len(face) - for f in mesh.faces: - if (edge.v1 in f.v) and (edge.v2 in f.v): - adjface_list.append(f) + # assert(n>4) + if n < 3 or n > 4: + print "ERROR a mesh in Blender can't have more than 4 vertices or less than 3" + raise AssertionError + + elif n == 3: + # three points must be complanar + return False + else: # n == 4 + x1 = Vector(face[0].co) + x2 = Vector(face[1].co) + x3 = Vector(face[2].co) + x4 = Vector(face[3].co) + + v = (x3-x1) * CrossVecs((x2-x1), (x4-x3)) + if v != 0: + return True + + return False + + is_nonplanar_quad = staticmethod(is_nonplanar_quad) + + def pointInPolygon(poly, v): + return False + + pointInPolygon = staticmethod(pointInPolygon) + + def edgeIntersection(s1, s2, do_perturbate=False): + + (x1, y1) = s1[0].co[0], s1[0].co[1] + (x2, y2) = s1[1].co[0], s1[1].co[1] + + (x3, y3) = s2[0].co[0], s2[0].co[1] + (x4, y4) = s2[1].co[0], s2[1].co[1] + + #z1 = s1[0].co[2] + #z2 = s1[1].co[2] + #z3 = s2[0].co[2] + #z4 = s2[1].co[2] + + + # calculate delta values (vector components) + dx1 = x2 - x1; + dx2 = x4 - x3; + dy1 = y2 - y1; + dy2 = y4 - y3; + + #dz1 = z2 - z1; + #dz2 = z4 - z3; + + C = dy2 * dx1 - dx2 * dy1 # /* cross product */ + if C == 0: #/* parallel */ + return None + + dx3 = x1 - x3 # /* combined origin offset vector */ + dy3 = y1 - y3 + + a1 = (dy3 * dx2 - dx3 * dy2) / C; + a2 = (dy3 * dx1 - dx3 * dy1) / C; + + # check for degeneracies + #print_debug("\n") + #print_debug(str(a1)+"\n") + #print_debug(str(a2)+"\n\n") + + if (a1 == 0 or a1 == 1 or a2 == 0 or a2 == 1): + # Intersection on boundaries, we consider the point external? + return None + + elif (a1>0.0 and a1<1.0 and a2>0.0 and a2<1.0): # /* lines cross */ + x = x1 + a1*dx1 + y = y1 + a1*dy1 + + #z = z1 + a1*dz1 + z = 0 + return (NMesh.Vert(x, y, z), a1, a2) + + else: + # lines have intersections but not those segments + return None + + edgeIntersection = staticmethod(edgeIntersection) + + def isVertInside(self, v): + winding_number = 0 + coincidence = False + + # Create point at infinity + point_at_infinity = NMesh.Vert(-INF, v.co[1], -INF) + + for i in range(len(self.v)): + s1 = (point_at_infinity, v) + s2 = (self.v[i-1], self.v[i]) + + if EQ(v.co, s2[0].co) or EQ(v.co, s2[1].co): + coincidence = True + + if HSR.edgeIntersection(s1, s2, do_perturbate=False): + winding_number += 1 + + # Check even or odd + if winding_number % 2 == 0 : + return False + else: + if coincidence: + return False + return True + + isVertInside = staticmethod(isVertInside) + + + def det(a, b, c): + return ((b[0] - a[0]) * (c[1] - a[1]) - + (b[1] - a[1]) * (c[0] - a[0]) ) + + det = staticmethod(det) + + def pointInPolygon(q, P): + is_in = False + + point_at_infinity = NMesh.Vert(-INF, q.co[1], -INF) + + det = HSR.det + + for i in range(len(P.v)): + p0 = P.v[i-1] + p1 = P.v[i] + if (det(q.co, point_at_infinity.co, p0.co)<0) != (det(q.co, point_at_infinity.co, p1.co)<0): + if det(p0.co, p1.co, q.co) == 0 : + #print "On Boundary" + return False + elif (det(p0.co, p1.co, q.co)<0) != (det(p0.co, p1.co, point_at_infinity.co)<0): + is_in = not is_in + + return is_in + + pointInPolygon = staticmethod(pointInPolygon) + + def projectionsOverlap(f1, f2): + """ If you have nonconvex, but still simple polygons, an acceptable method + is to iterate over all vertices and perform the Point-in-polygon test[1]. + The advantage of this method is that you can compute the exact + intersection point and collision normal that you will need to simulate + collision. When you have the point that lies inside the other polygon, you + just iterate over all edges of the second polygon again and look for edge + intersections. Note that this method detects collsion when it already + happens. This algorithm is fast enough to perform it hundreds of times per + sec. """ + + for i in range(len(f1.v)): + + + # If a point of f1 in inside f2, there is an overlap! + v1 = f1.v[i] + #if HSR.isVertInside(f2, v1): + if HSR.pointInPolygon(v1, f2): + return True + + # If not the polygon can be ovelap as well, so we check for + # intersection between an edge of f1 and all the edges of f2 + + v0 = f1.v[i-1] + + for j in range(len(f2.v)): + v2 = f2.v[j-1] + v3 = f2.v[j] + + e1 = v0, v1 + e2 = v2, v3 + + intrs = HSR.edgeIntersection(e1, e2) + if intrs: + #print_debug(str(v0.co) + " " + str(v1.co) + " " + + # str(v2.co) + " " + str(v3.co) ) + #print_debug("\nIntersection\n") + + return True + + return False + + projectionsOverlap = staticmethod(projectionsOverlap) + + def midpoint(p1, p2): + """Return the midpoint of two vertices. + """ + m = MidpointVecs(Vector(p1), Vector(p2)) + mv = NMesh.Vert(m[0], m[1], m[2]) + + return mv + + midpoint = staticmethod(midpoint) + + def facesplit(P, Q, facelist, nmesh): + """Split P or Q according to the strategy illustrated in the Newell's + paper. + """ + + by_furthest_z = (lambda f1, f2: + cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2])+EPS) + ) + + # Choose if split P on Q plane or vice-versa + + n = 0 + for Pi in P: + d = HSR.Distance(Vector(Pi), Q) + if d <= EPS: + n += 1 + pIntersectQ = (n != len(P)) + + n = 0 + for Qi in Q: + d = HSR.Distance(Vector(Qi), P) + if d >= -EPS: + n += 1 + qIntersectP = (n != len(Q)) + + newfaces = [] + + # 1. If parts of P lie in both half-spaces of Q + # then splice P in two with the plane of Q + if pIntersectQ: + #print "We split P" + f = P + plane = Q + + newfaces = HSR.splitOn(plane, f) + + # 2. Else if parts of Q lie in both half-space of P + # then splice Q in two with the plane of P + if qIntersectP and newfaces == None: + #print "We split Q" + f = Q + plane = P + + newfaces = HSR.splitOn(plane, f) + #print "After" + + # 3. Else slice P in half through the mid-point of + # the longest pair of opposite sides + if newfaces == None: + + print "We ignore P..." + facelist.remove(P) + return facelist + + #f = P + + #if len(P)==3: + # v1 = midpoint(f[0], f[1]) + # v2 = midpoint(f[1], f[2]) + #if len(P)==4: + # v1 = midpoint(f[0], f[1]) + # v2 = midpoint(f[2], f[3]) + #vec3 = (Vector(v2)+10*Vector(f.normal)) + # + #v3 = NMesh.Vert(vec3[0], vec3[1], vec3[2]) + + #plane = NMesh.Face([v1, v2, v3]) + # + #newfaces = splitOn(plane, f) + + + if newfaces == None: + print "Big FAT problem, we weren't able to split POLYGONS!" + raise AssertionError + + #print newfaces + if newfaces: + #for v in f: + # if v not in plane and v in nmesh.verts: + # nmesh.verts.remove(v) + for nf in newfaces: + + nf.mat = f.mat + nf.sel = f.sel + nf.col = [f.col[0]] * len(nf.v) + + nf.smooth = 0 + + for v in nf: + nmesh.verts.append(v) + # insert pieces in the list + facelist.append(nf) + + facelist.remove(f) + + # and resort the faces + facelist.sort(by_furthest_z) + facelist.sort(lambda f1, f2: cmp(f1.smooth, f2.smooth)) + facelist.reverse() + + #print [ f.smooth for f in facelist ] + + return facelist + + facesplit = staticmethod(facesplit) + + def isOnSegment(v1, v2, p, extremes_internal=False): + """Check if point p is in segment v1v2. + """ + + l1 = (v1-p).length + l2 = (v2-p).length + + # Should we consider extreme points as internal ? + # The test: + # if p == v1 or p == v2: + if l1 < EPS or l2 < EPS: + return extremes_internal + + l = (v1-v2).length + + # if the sum of l1 and l2 is circa l, then the point is on segment, + if abs(l - (l1+l2)) < EPS: + return True + else: + return False + + isOnSegment = staticmethod(isOnSegment) + + def Distance(point, face): + """ Calculate the distance between a point and a face. + + An alternative but more expensive method can be: + + ip = Intersect(Vector(face[0]), Vector(face[1]), Vector(face[2]), + Vector(face.no), Vector(point), 0) + + d = Vector(ip - point).length + + See: http://mathworld.wolfram.com/Point-PlaneDistance.html + """ + + p = Vector(point) + plNormal = Vector(face.no) + plVert0 = Vector(face.v[0]) + + d = (plVert0 * plNormal) - (p * plNormal) + + #d = plNormal * (plVert0 - p) + + #print "\nd: %.10f - sel: %d, %s\n" % (d, face.sel, str(point)) + + return d + + Distance = staticmethod(Distance) + + def makeFaces(vl): + # + # make one or two new faces based on a list of vertex-indices + # + newfaces = [] + + if len(vl) <= 4: + nf = NMesh.Face() + + for v in vl: + nf.v.append(v) + + newfaces.append(nf) + + else: + nf = NMesh.Face() + + nf.v.append(vl[0]) + nf.v.append(vl[1]) + nf.v.append(vl[2]) + nf.v.append(vl[3]) + newfaces.append(nf) + + nf = NMesh.Face() + nf.v.append(vl[3]) + nf.v.append(vl[4]) + nf.v.append(vl[0]) + newfaces.append(nf) + + return newfaces - return adjface_list + makeFaces = staticmethod(makeFaces) - def isMeshEdge(e, mesh): + def splitOn(Q, P, return_positive_faces=True, return_negative_faces=True): + """Split P using the plane of Q. + Logic taken from the knife.py python script + """ + + # Check if P and Q are parallel + u = CrossVecs(Vector(Q.no),Vector(P.no)) + ax = abs(u[0]) + ay = abs(u[1]) + az = abs(u[2]) + + if (ax+ay+az) < EPS: + print "PARALLEL planes!!" + return + + + # The final aim is to find the intersection line between P + # and the plane of Q, and split P along this line + + nP = len(P.v) + + # Calculate point-plane Distance between vertices of P and plane Q + d = [] + for i in range(0, nP): + d.append(HSR.Distance(P.v[i], Q)) + + newVertList = [] + + posVertList = [] + negVertList = [] + for i in range(nP): + d0 = d[i-1] + V0 = P.v[i-1] + + d1 = d[i] + V1 = P.v[i] + + #print "d0:", d0, "d1:", d1 + + # if the vertex lies in the cutplane + if abs(d1) < EPS: + #print "d1 On cutplane" + posVertList.append(V1) + negVertList.append(V1) + else: + # if the previous vertex lies in cutplane + if abs(d0) < EPS: + #print "d0 on Cutplane" + if d1 > 0: + #print "d1 on positive Halfspace" + posVertList.append(V1) + else: + #print "d1 on negative Halfspace" + negVertList.append(V1) + else: + # if they are on the same side of the plane + if d1*d0 > 0: + #print "On the same half-space" + if d1 > 0: + #print "d1 on positive Halfspace" + posVertList.append(V1) + else: + #print "d1 on negative Halfspace" + negVertList.append(V1) + + # the vertices are not on the same side of the plane, so we have an intersection + else: + #print "Intersection" + + e = Vector(V0), Vector(V1) + tri = Vector(Q[0]), Vector(Q[1]), Vector(Q[2]) + + inters = Intersect(tri[0], tri[1], tri[2], e[1]-e[0], e[0], 0) + if inters == None: + print "Split Break" + break + + #print "Intersection", inters + + nv = NMesh.Vert(inters[0], inters[1], inters[2]) + newVertList.append(nv) + + posVertList.append(nv) + negVertList.append(nv) + + if d1 > 0: + posVertList.append(V1) + else: + negVertList.append(V1) + + + # uniq + posVertList = [ u for u in posVertList if u not in locals()['_[1]'] ] + negVertList = [ u for u in negVertList if u not in locals()['_[1]'] ] + + + # If vertex are all on the same half-space, return + #if len(posVertList) < 3: + # print "Problem, we created a face with less that 3 vertices??" + # posVertList = [] + #if len(negVertList) < 3: + # print "Problem, we created a face with less that 3 vertices??" + # negVertList = [] + + if len(posVertList) < 3 or len(negVertList) < 3: + #print "RETURN NONE, SURE???" + return None + + if not return_positive_faces: + posVertList = [] + if not return_negative_faces: + negVertList = [] + + newfaces = HSR.addNewFaces(posVertList, negVertList) + + return newfaces + + splitOn = staticmethod(splitOn) + + def addNewFaces(posVertList, negVertList): + # Create new faces resulting from the split + outfaces = [] + if len(posVertList) or len(negVertList): + + #newfaces = [posVertList] + [negVertList] + newfaces = ( [[ NMesh.Vert(v[0], v[1], v[2]) for v in posVertList]] + + [[ NMesh.Vert(v[0], v[1], v[2]) for v in negVertList]] ) + + for nf in newfaces: + if nf and len(nf)>2: + outfaces += HSR.makeFaces(nf) + + return outfaces + + + addNewFaces = staticmethod(addNewFaces) + + +# --------------------------------------------------------------------- +# +## Mesh Utility class +# +# --------------------------------------------------------------------- + +class MeshUtils: + + def buildEdgeFaceUsersCache(me): + ''' + Takes a mesh and returns a list aligned with the meshes edges. + Each item is a list of the faces that use the edge + would be the equiv for having ed.face_users as a property + + Taken from .blender/scripts/bpymodules/BPyMesh.py, + thanks to ideasman_42. + ''' + + def sorted_edge_indicies(ed): + i1= ed.v1.index + i2= ed.v2.index + if i1>i2: + i1,i2= i2,i1 + return i1, i2 + + + face_edges_dict= dict([(sorted_edge_indicies(ed), (ed.index, [])) for ed in me.edges]) + for f in me.faces: + fvi= [v.index for v in f.v]# face vert idx's + for i in xrange(len(f)): + i1= fvi[i] + i2= fvi[i-1] + + if i1>i2: + i1,i2= i2,i1 + + face_edges_dict[i1,i2][1].append(f) + + face_edges= [None] * len(me.edges) + for ed_index, ed_faces in face_edges_dict.itervalues(): + face_edges[ed_index]= ed_faces + + return face_edges + + def isMeshEdge(adjacent_faces): """Mesh edge rule. - A mesh edge is visible if _any_ of its adjacent faces is selected. + A mesh edge is visible if _at_least_one_ of its adjacent faces is selected. Note: if the edge has no adjacent faces we want to show it as well, useful for "edge only" portion of objects. """ - adjacent_faces = MeshUtils.getEdgeAdjacentFaces(e, mesh) - if len(adjacent_faces) == 0: return True @@ -141,7 +792,7 @@ class MeshUtils: else: return False - def isSilhouetteEdge(e, mesh): + def isSilhouetteEdge(adjacent_faces): """Silhuette selection rule. An edge is a silhuette edge if it is shared by two faces with @@ -149,8 +800,6 @@ class MeshUtils: face. """ - adjacent_faces = MeshUtils.getEdgeAdjacentFaces(e, mesh) - if ((len(adjacent_faces) == 1 and adjacent_faces[0].sel == 1) or (len(adjacent_faces) == 2 and adjacent_faces[0].sel != adjacent_faces[1].sel) @@ -158,33 +807,53 @@ class MeshUtils: return True else: return False - - def toonShading(u): - levels = 2 + buildEdgeFaceUsersCache = staticmethod(buildEdgeFaceUsersCache) + isMeshEdge = staticmethod(isMeshEdge) + isSilhouetteEdge = staticmethod(isSilhouetteEdge) + + +# --------------------------------------------------------------------- +# +## Shading Utility class +# +# --------------------------------------------------------------------- + +class ShadingUtils: + + shademap = None + + def toonShadingMapSetup(): + levels = config.polygons['TOON_LEVELS'] + texels = 2*levels - 1 - map = [0.0] + [(i)/float(texels-1) for i in range(1, texels-1) ] + [1.0] - + tmp_shademap = [0.0] + [(i)/float(texels-1) for i in xrange(1, texels-1) ] + [1.0] + + return tmp_shademap + + def toonShading(u): + + shademap = ShadingUtils.shademap + + if not shademap: + shademap = ShadingUtils.toonShadingMapSetup() + v = 1.0 - for i in range(0, len(map)-1): - pivot = (map[i]+map[i+1])/2.0 + for i in xrange(0, len(shademap)-1): + pivot = (shademap[i]+shademap[i+1])/2.0 j = int(u>pivot) - v = map[i+j] + v = shademap[i+j] - if v\n" % + (framenumber, framestyle) ) + + + for obj in Objects: + + if(obj.getType() != 'Mesh'): + continue + + self.file.write("\n" % obj.getName()) + + mesh = obj.getData(mesh=1) + + if doPrintPolygons: + self._printPolygons(mesh) + + if doPrintEdges: + self._printEdges(mesh, showHiddenEdges) + + self.file.write("\n") + + self.file.write("\n") + + + ## + # Private Methods + # + + def _calcCanvasCoord(self, v): + """Convert vertex in scene coordinates to canvas coordinates. + """ + + pt = Vector([0, 0, 0]) + + mW = float(self.canvasSize[0])/2.0 + mH = float(self.canvasSize[1])/2.0 + + # rescale to canvas size + pt[0] = v.co[0]*mW + mW + pt[1] = v.co[1]*mH + mH + pt[2] = v.co[2] + + # For now we want (0,0) in the top-left corner of the canvas. + # Mirror and translate along y + pt[1] *= -1 + pt[1] += self.canvasSize[1] + + return pt + + def _printHeader(self): + """Print SVG header.""" + + self.file.write("\n") + self.file.write("\n") + self.file.write("\n\n" % + self.canvasSize) + + if self.animation: + delay = 1000/self.fps + + self.file.write("""\n\n + \n""") + + def _printFooter(self): + """Print the SVG footer.""" + + self.file.write("\n\n") + + def _printPolygons(self, mesh): + """Print the selected (visible) polygons. + """ + + if len(mesh.faces) == 0: + return + + self.file.write("\n") + + for face in mesh.faces: + if not face.sel: + continue + + self.file.write("\n") + + self.file.write("\n") + + def _printEdges(self, mesh, showHiddenEdges=False): + """Print the wireframe using mesh edges. + """ + + stroke_width = config.edges['WIDTH'] + stroke_col = config.edges['COLOR'] + + self.file.write("\n") + + for e in mesh.edges: + + hidden_stroke_style = "" + + if e.sel == 0: + if showHiddenEdges == False: + continue + else: + hidden_stroke_style = ";\n stroke-dasharray:3, 3" + + p1 = self._calcCanvasCoord(e.v1) + p2 = self._calcCanvasCoord(e.v2) + + self.file.write("\n") + + self.file.write("\n") + + +## SWF Writer + +try: + from ming import * + SWFSupported = True +except: + SWFSupported = False + +class SWFVectorWriter(VectorWriter): + """A concrete class for writing SWF output. + """ + + def __init__(self, fileName): + """Simply call the parent Contructor. + """ + VectorWriter.__init__(self, fileName) + + self.movie = None + self.sprite = None + + + ## + # Public Methods + # + + def open(self, startFrame=1, endFrame=1): + """Do some initialization operations. + """ + VectorWriter.open(self, startFrame, endFrame) + self.movie = SWFMovie() + self.movie.setDimension(self.canvasSize[0], self.canvasSize[1]) + if self.animation: + self.movie.setRate(self.fps) + numframes = endFrame - startFrame + 1 + self.movie.setFrames(numframes) + + def close(self): + """Do some finalization operation. + """ + self.movie.save(self.outputFileName) + + # remember to call the close method of the parent + VectorWriter.close(self) + + def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False, + showHiddenEdges=False): + """Convert the scene representation to SVG. + """ + context = scene.getRenderingContext() + framenumber = context.currentFrame() + + Objects = scene.getChildren() + + if self.sprite: + self.movie.remove(self.sprite) + + sprite = SWFSprite() + + for obj in Objects: + + if(obj.getType() != 'Mesh'): + continue + + mesh = obj.getData(mesh=1) + + if doPrintPolygons: + self._printPolygons(mesh, sprite) + + if doPrintEdges: + self._printEdges(mesh, sprite, showHiddenEdges) + + sprite.nextFrame() + i = self.movie.add(sprite) + # Remove the instance the next time + self.sprite = i + if self.animation: + self.movie.nextFrame() + + + ## + # Private Methods + # + + def _calcCanvasCoord(self, v): + """Convert vertex in scene coordinates to canvas coordinates. + """ + + pt = Vector([0, 0, 0]) + + mW = float(self.canvasSize[0])/2.0 + mH = float(self.canvasSize[1])/2.0 + + # rescale to canvas size + pt[0] = v.co[0]*mW + mW + pt[1] = v.co[1]*mH + mH + pt[2] = v.co[2] + + # For now we want (0,0) in the top-left corner of the canvas. + # Mirror and translate along y + pt[1] *= -1 + pt[1] += self.canvasSize[1] + + return pt + + def _printPolygons(self, mesh, sprite): + """Print the selected (visible) polygons. + """ + + if len(mesh.faces) == 0: + return + + for face in mesh.faces: + if not face.sel: + continue + + if face.col: + fcol = face.col[0] + color = [fcol.r, fcol.g, fcol.b, fcol.a] + else: + color = [255, 255, 255, 255] + + s = SWFShape() + f = s.addFill(color[0], color[1], color[2], color[3]) + s.setRightFill(f) + + # The starting point of the shape + p0 = self._calcCanvasCoord(face.verts[0]) + s.movePenTo(p0[0], p0[1]) + + for v in face.verts[1:]: + p = self._calcCanvasCoord(v) + s.drawLineTo(p[0], p[1]) + + # Closing the shape + s.drawLineTo(p0[0], p0[1]) + + s.end() + sprite.add(s) + + + def _printEdges(self, mesh, sprite, showHiddenEdges=False): + """Print the wireframe using mesh edges. + """ + + stroke_width = config.edges['WIDTH'] + stroke_col = config.edges['COLOR'] + + s = SWFShape() + + for e in mesh.edges: + + # Next, we set the line width and color for our shape. + s.setLine(stroke_width, stroke_col[0], stroke_col[1], stroke_col[2], + 255) + + if e.sel == 0: + if showHiddenEdges == False: + continue + else: + # SWF does not support dashed lines natively, so -for now- + # draw hidden lines thinner and half-trasparent + s.setLine(stroke_width/2, stroke_col[0], stroke_col[1], + stroke_col[2], 128) + + p1 = self._calcCanvasCoord(e.v1) + p2 = self._calcCanvasCoord(e.v2) + + # FIXME: this is just a qorkaround, remove that after the + # implementation of propoer Viewport clipping + if abs(p1[0]) < 3000 and abs(p2[0]) < 3000 and abs(p1[1]) < 3000 and abs(p1[2]) < 3000: + s.movePenTo(p1[0], p1[1]) + s.drawLineTo(p2[0], p2[1]) + -class SVGVectorWriter(VectorWriter): - """A concrete class for writing SVG output. + s.end() + sprite.add(s) + + +## PDF Writer + +try: + from reportlab.pdfgen import canvas + PDFSupported = True +except: + PDFSupported = False + +class PDFVectorWriter(VectorWriter): + """A concrete class for writing PDF output. """ def __init__(self, fileName): @@ -397,6 +1672,8 @@ class SVGVectorWriter(VectorWriter): """ VectorWriter.__init__(self, fileName) + self.canvas = None + ## # Public Methods @@ -406,44 +1683,31 @@ class SVGVectorWriter(VectorWriter): """Do some initialization operations. """ VectorWriter.open(self, startFrame, endFrame) - self._printHeader() + size = (self.canvasSize[0], self.canvasSize[1]) + self.canvas = canvas.Canvas(self.outputFileName, pagesize=size, bottomup=0) def close(self): """Do some finalization operation. """ - self._printFooter() + self.canvas.save() # remember to call the close method of the parent VectorWriter.close(self) - def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False, showHiddenEdges=False): """Convert the scene representation to SVG. """ - - Objects = scene.getChildren() - context = scene.getRenderingContext() framenumber = context.currentFrame() - if self.animation: - framestyle = "display:none" - else: - framestyle = "display:block" - - # Assign an id to this group so we can set properties on it using DOM - self.file.write("\n" % - (framenumber, framestyle) ) - + Objects = scene.getChildren() for obj in Objects: if(obj.getType() != 'Mesh'): continue - self.file.write("\n" % obj.getName()) - mesh = obj.getData(mesh=1) if doPrintPolygons: @@ -452,10 +1716,7 @@ class SVGVectorWriter(VectorWriter): if doPrintEdges: self._printEdges(mesh, showHiddenEdges) - self.file.write("\n") - - self.file.write("\n") - + self.canvas.showPage() ## # Private Methods @@ -481,60 +1742,7 @@ class SVGVectorWriter(VectorWriter): pt[1] += self.canvasSize[1] return pt - - def _printHeader(self): - """Print SVG header.""" - - self.file.write("\n") - self.file.write("\n") - self.file.write("\n\n" % - self.canvasSize) - - if self.animation: - - self.file.write("""\n\n - \n""" % (self.startFrame, self.endFrame, self.startFrame) ) - def _printFooter(self): - """Print the SVG footer.""" - - self.file.write("\n\n") - def _printPolygons(self, mesh): """Print the selected (visible) polygons. """ @@ -542,55 +1750,35 @@ class SVGVectorWriter(VectorWriter): if len(mesh.faces) == 0: return - self.file.write("\n") - for face in mesh.faces: if not face.sel: continue - self.file.write("\n") + for v in face.verts[1:]: + p = self._calcCanvasCoord(v) + path.lineTo(p[0], p[1]) + + # Closing the shape + path.close() - self.file.write("\n") + self.canvas.drawPath(path, stroke=0, fill=1) def _printEdges(self, mesh, showHiddenEdges=False): """Print the wireframe using mesh edges. @@ -598,31 +1786,32 @@ class SVGVectorWriter(VectorWriter): stroke_width = config.edges['WIDTH'] stroke_col = config.edges['COLOR'] - - self.file.write("\n") + + self.canvas.setLineCap(1) + self.canvas.setLineJoin(1) + self.canvas.setLineWidth(stroke_width) + self.canvas.setStrokeColorRGB(stroke_col[0]/255.0, stroke_col[1]/255.0, + stroke_col[2]/255) for e in mesh.edges: - - hidden_stroke_style = "" - + + self.canvas.setLineWidth(stroke_width) + if e.sel == 0: if showHiddenEdges == False: continue else: - hidden_stroke_style = ";\n stroke-dasharray:3, 3" + # PDF does not support dashed lines natively, so -for now- + # draw hidden lines thinner + self.canvas.setLineWidth(stroke_width/2.0) p1 = self._calcCanvasCoord(e.v1) p2 = self._calcCanvasCoord(e.v2) - - self.file.write("\n") - self.file.write("\n") + # FIXME: this is just a workaround, remove that after the + # implementation of propoer Viewport clipping + if abs(p1[0]) < 3000 and abs(p2[0]) < 3000 and abs(p1[1]) < 3000 and abs(p1[2]) < 3000: + self.canvas.line(p1[0], p1[1], p2[0], p2[1]) @@ -645,10 +1834,14 @@ edgeStyles['SILHOUETTE'] = MeshUtils.isSilhouetteEdge # A dictionary to collect the supported output formats outputWriters = dict() outputWriters['SVG'] = SVGVectorWriter +if SWFSupported: + outputWriters['SWF'] = SWFVectorWriter +if PDFSupported: + outputWriters['PDF'] = PDFVectorWriter class Renderer: - """Render a scene viewed from a given camera. + """Render a scene viewed from the active camera. This class is responsible of the rendering process, transformation and projection of the objects in the scene are invoked by the renderer. @@ -659,7 +1852,7 @@ class Renderer: def __init__(self): """Make the rendering process only for the current scene by default. - We will work on a copy of the scene, be sure that the current scene do + We will work on a copy of the scene, to be sure that the current scene do not get modified in any way. """ @@ -675,13 +1868,7 @@ class Renderer: ) # Render from the currently active camera - self.cameraObj = self._SCENE.getCurrentCamera() - - # Get a projector for this camera. - # NOTE: the projector wants object in world coordinates, - # so we should remember to apply modelview transformations - # _before_ we do projection transformations. - self.proj = Projector(self.cameraObj, self.canvasRatio) + #self.cameraObj = self._SCENE.getCurrentCamera() # Get the list of lighting sources obj_lst = self._SCENE.getChildren() @@ -724,14 +1911,28 @@ class Renderer: outputWriter.open(startFrame, endFrame) # Do the rendering process frame by frame - print "Start Rendering!" - for f in range(startFrame, endFrame+1): - context.currentFrame(f) + print "Start Rendering of %d frames" % (endFrame-startFrame+1) + for f in xrange(startFrame, endFrame+1): + print "\n\nFrame: %d" % f + + # FIXME To get the correct camera position we have to use +1 here. + # Is there a bug somewhere in the Scene module? + context.currentFrame(f+1) + self.cameraObj = self._SCENE.getCurrentCamera() # Use some temporary workspace, a full copy of the scene inputScene = self._SCENE.copy(2) - # And Set our camera accordingly - self.cameraObj = inputScene.getCurrentCamera() + + # To get the objects at this frame remove the +1 ... + ctx = inputScene.getRenderingContext() + ctx.currentFrame(f) + + + # Get a projector for this camera. + # NOTE: the projector wants object in world coordinates, + # so we should remember to apply modelview transformations + # _before_ we do projection transformations. + self.proj = Projector(self.cameraObj, self.canvasRatio) try: renderedScene = self.doRenderScene(inputScene) @@ -750,10 +1951,10 @@ class Renderer: doPrintEdges = config.edges['SHOW'], showHiddenEdges = config.edges['SHOW_HIDDEN']) - # clear the rendered scene + # delete the rendered scene self._SCENE.makeCurrent() - #Scene.unlink(renderedScene) - #del renderedScene + Scene.unlink(renderedScene) + del renderedScene outputWriter.close() print "Done!" @@ -771,7 +1972,7 @@ class Renderer: self._doSceneClipping(workScene) - self._doConvertGeometricObjToMesh(workScene) + self._doConvertGeometricObjsToMesh(workScene) if config.output['JOIN_OBJECTS']: self._joinMeshObjectsInScene(workScene) @@ -781,7 +1982,10 @@ class Renderer: # Per object activities Objects = workScene.getChildren() - for obj in Objects: + print "Total Objects: %d" % len(Objects) + for i,obj in enumerate(Objects): + print "\n\n-------" + print "Rendering Object: %d" % i if obj.getType() != 'Mesh': print "Only Mesh supported! - Skipping type:", obj.getType() @@ -795,7 +1999,17 @@ class Renderer: self._doBackFaceCulling(mesh) - self._doPerVertexLighting(mesh) + + # When doing HSR with NEWELL we may want to flip all normals + # toward the viewer + if config.polygons['HSR'] == "NEWELL": + for f in mesh.faces: + f.sel = 1-f.sel + mesh.flipNormals() + for f in mesh.faces: + f.sel = 1 + + self._doLighting(mesh) # Do "projection" now so we perform further processing # in Normalized View Coordinates @@ -803,11 +2017,10 @@ class Renderer: self._doViewFrustumClipping(mesh) - self._doMeshDepthSorting(mesh) + self._doHiddenSurfaceRemoval(mesh) self._doEdgesStyle(mesh, edgeStyles[config.edges['STYLE']]) - # Update the object data, important! :) mesh.update() @@ -887,7 +2100,7 @@ class Renderer: For now clip away only objects according to their center position. """ - cpos = self._getObjPosition(self.cameraObj) + cam_pos = self._getObjPosition(self.cameraObj) view_vect = self._cameraViewVector() near = self.cameraObj.data.clipStart @@ -901,7 +2114,10 @@ class Renderer: for o in Objects: if o.getType() != 'Mesh': continue; - obj_vect = Vector(cpos) - self._getObjPosition(o) + # TODO: use the object bounding box (that is already in WorldSpace) + # bb = o.getBoundBox() and then: for point in bb: ... + + obj_vect = Vector(cam_pos) - self._getObjPosition(o) d = obj_vect*view_vect theta = AngleBetweenVecs(obj_vect, view_vect) @@ -910,10 +2126,11 @@ class Renderer: if (d < near) or (d > far) or (theta > fovy): scene.unlink(o) - def _doConvertGeometricObjToMesh(self, scene): + def _doConvertGeometricObjsToMesh(self, scene): """Convert all "geometric" objects to mesh ones. """ geometricObjTypes = ['Mesh', 'Surf', 'Curve', 'Text'] + #geometricObjTypes = ['Mesh', 'Surf', 'Curve'] Objects = scene.getChildren() objList = [ o for o in Objects if o.getType() in geometricObjTypes ] @@ -982,7 +2199,7 @@ class Renderer: try: bigObj.join(oList) except RuntimeError: - print "\nCan't Join Objects\n" + print "\nWarning! - Can't Join Objects\n" scene.unlink(bigObj) return except TypeError: @@ -994,7 +2211,7 @@ class Renderer: scene.update() - # Per object methods + # Per object/mesh methods def _convertToRawMeshObj(self, object): """Convert geometry based object to a mesh object. @@ -1046,8 +2263,8 @@ class Renderer: if self._isFaceVisible(f): f.sel = 1 - def _doPerVertexLighting(self, mesh): - """Apply an Illumination ans shading model to the object. + def _doLighting(self, mesh): + """Apply an Illumination and shading model to the object. The model used is the Phong one, it may be inefficient, but I'm just learning about rendering and starting from Phong seemed @@ -1061,11 +2278,6 @@ class Renderer: mesh.vertexColors = 1 materials = mesh.materials - - # TODO: use multiple lighting sources - light_obj = self.lights[0] - light_pos = self._getObjPosition(light_obj) - light = light_obj.data camPos = self._getObjPosition(self.cameraObj) @@ -1084,43 +2296,72 @@ class Renderer: # A new default material if mat == None: mat = Material.New('defMat') - - L = Vector(light_pos).normalize() - V = (Vector(camPos) - Vector(f.cent)).normalize() + # Check if it is a shadeless material + elif mat.getMode() & Material.Modes['SHADELESS']: + I = mat.getRGBCol() + # Convert to a value between 0 and 255 + tmp_col = [ int(c * 255.0) for c in I] - N = Vector(f.no).normalize() + for c in f.col: + c.r = tmp_col[0] + c.g = tmp_col[1] + c.b = tmp_col[2] + #c.a = tmp_col[3] - R = 2 * (N*L) * N - L + continue - # TODO: Attenuation factor (not used for now) - a0 = 1.0; a1 = 0.0; a2 = 1.0 - d = (Vector(f.v[0].co) - Vector(light_pos)).length - fd = min(1, 1.0/(a0 + a1*d + a2*(d*d))) - # Ambient component - Ia = 1.0 - ka = mat.getAmb() * Vector([0.1, 0.1, 0.1]) - Iamb = Ia * ka - - # Diffuse component (add light.col for kd) - kd = mat.getRef() * Vector(mat.getRGBCol()) - Ip = light.getEnergy() + # do vertex color calculation + + TotDiffSpec = Vector([0.0, 0.0, 0.0]) + + for l in self.lights: + light_obj = l + light_pos = self._getObjPosition(l) + light = light_obj.getData() - if config.polygons['SHADING'] == 'FLAT': - Idiff = Ip * kd * max(0, (N*L)) - elif config.polygons['SHADING'] == 'TOON': - Idiff = Ip * kd * MeshUtils.toonShading(N*L) + L = Vector(light_pos).normalize() + + V = (Vector(camPos) - Vector(f.cent)).normalize() + + N = Vector(f.no).normalize() + + if config.polygons['SHADING'] == 'TOON': + NL = ShadingUtils.toonShading(N*L) + else: + NL = (N*L) + + # Should we use NL instead of (N*L) here? + R = 2 * (N*L) * N - L + + Ip = light.getEnergy() + + # Diffuse co-efficient + kd = mat.getRef() * Vector(mat.getRGBCol()) + for i in [0, 1, 2]: + kd[i] *= light.col[i] - # Specular component - ks = mat.getSpec() * Vector(mat.getSpecCol()) - ns = mat.getHardness() - Ispec = Ip * ks * pow(max(0, (V*R)), ns) + Idiff = Ip * kd * max(0, NL) - # Emissive component + + # Specular component + ks = mat.getSpec() * Vector(mat.getSpecCol()) + ns = mat.getHardness() + Ispec = Ip * ks * pow(max(0, (V*R)), ns) + + TotDiffSpec += (Idiff+Ispec) + + + # Ambient component + Iamb = Vector(Blender.World.Get()[0].getAmb()) + ka = mat.getAmb() + + # Emissive component (convert to a triplet) ki = Vector([mat.getEmit()]*3) - I = ki + Iamb + (Idiff + Ispec) + #I = ki + Iamb + (Idiff + Ispec) + I = ki + (ka * Iamb) + TotDiffSpec # Set Alpha component @@ -1145,11 +2386,14 @@ class Renderer: """ for v in mesh.verts: - p = projector.doProjection(v.co) + p = projector.doProjection(v.co[:]) v.co[0] = p[0] v.co[1] = p[1] v.co[2] = p[2] + #mesh.recalcNormals() + #mesh.update() + # We could reeset Camera matrix, since now # we are in Normalized Viewing Coordinates, # but doung that would affect World Coordinate @@ -1164,68 +2408,346 @@ class Renderer: """Clip faces against the View Frustum. """ - def test_extensions(self, f1, f2): - for v1, v2 in [ (v1, v2) for v1 in f1 for v2 in f2 ]: - pass + # The Canonical View Volume, 8 vertices, and 6 faces, + # We consider its face normals pointing outside + + v1 = NMesh.Vert(1, 1, -1) + v2 = NMesh.Vert(1, -1, -1) + v3 = NMesh.Vert(-1, -1, -1) + v4 = NMesh.Vert(-1, 1, -1) + v5 = NMesh.Vert(1, 1, 1) + v6 = NMesh.Vert(1, -1, 1) + v7 = NMesh.Vert(-1, -1, 1) + v8 = NMesh.Vert(-1, 1, 1) + + cvv = [] + f1 = NMesh.Face([v1, v4, v3, v2]) + cvv.append(f1) + f2 = NMesh.Face([v5, v6, v7, v8]) + cvv.append(f2) + f3 = NMesh.Face([v1, v2, v6, v5]) + cvv.append(f3) + f4 = NMesh.Face([v2, v3, v7, v6]) + cvv.append(f4) + f5 = NMesh.Face([v3, v4, v8, v7]) + cvv.append(f5) + f6 = NMesh.Face([v4, v1, v5, v8]) + cvv.append(f6) + + nmesh = NMesh.GetRaw(mesh.name) + clippedfaces = nmesh.faces[:] + facelist = clippedfaces[:] - def depth_sort(self, faces): - return - + for clipface in cvv: + + clippedfaces = [] + for f in facelist: + + newfaces = HSR.splitOn(clipface, f, return_positive_faces=False) + + if not newfaces: + # Check if the face is inside the view rectangle + # TODO: Do this test before, it is more efficient + points_outside = 0 + for v in f: + if abs(v[0]) > 1-EPS or abs(v[1]) > 1-EPS: + points_outside += 1 + + if points_outside != len(f): + clippedfaces.append(f) + else: + for nf in newfaces: + for v in nf: + nmesh.verts.append(v) + + nf.mat = f.mat + nf.sel = f.sel + nf.col = [f.col[0]] * len(nf.v) - def _doMeshDepthSorting(self, mesh): - """Sort faces in an object. + clippedfaces.append(nf) - The faces in the object are sorted following the distance of the - vertices from the camera position. + facelist = clippedfaces[:] + + nmesh.faces = facelist + nmesh.update() + + + # HSR routines + def __simpleDepthSort(self, mesh): + """Sort faces by the furthest vertex. + + This simple mesthod is known also as the painter algorithm, and it + solves HSR correctly only for convex meshes. """ - if len(mesh.faces) == 0: - return - #c = self._getObjPosition(self.cameraObj) + #global progress - # In NVC - c = [0, 0, 1] + # The sorting requires circa n*log(n) steps + n = len(mesh.faces) + progress.setActivity("HSR: Painter", n*log(n)) - # hackish sorting of faces + by_furthest_z = (lambda f1, f2: progress.update() and + cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2])+EPS) + ) - # Sort faces according to the max distance from the camera - by_max_vert_dist = (lambda f1, f2: - cmp(max([(Vector(v.co)-Vector(c)).length for v in f2]), - max([(Vector(v.co)-Vector(c)).length for v in f1]))) - - # Sort faces according to the min distance from the camera - by_min_vert_dist = (lambda f1, f2: - cmp(min([(Vector(v.co)-Vector(c)).length for v in f1]), - min([(Vector(v.co)-Vector(c)).length for v in f2]))) - - # Sort faces according to the avg distance from the camera - by_avg_vert_dist = (lambda f1, f2: - cmp(sum([(Vector(v.co)-Vector(c)).length for v in f1])/len(f1), - sum([(Vector(v.co)-Vector(c)).length for v in f2])/len(f2))) + # FIXME: using NMesh to sort faces. We should avoid that! + nmesh = NMesh.GetRaw(mesh.name) + + # remember that _higher_ z values mean further points + nmesh.faces.sort(by_furthest_z) + nmesh.faces.reverse() + + nmesh.update() + + + def __newellDepthSort(self, mesh): + """Newell's depth sorting. + + """ + #global progress + + # Find non planar quads and convert them to triangle + #for f in mesh.faces: + # f.sel = 0 + # if is_nonplanar_quad(f.v): + # print "NON QUAD??" + # f.sel = 1 + + + # Now reselect all faces + for f in mesh.faces: + f.sel = 1 + mesh.quadToTriangle() # FIXME: using NMesh to sort faces. We should avoid that! nmesh = NMesh.GetRaw(mesh.name) - nmesh.faces.sort(by_max_vert_dist) - #nmesh.faces.reverse() - # Depth sort tests + # remember that _higher_ z values mean further points + nmesh.faces.sort(by_furthest_z) + nmesh.faces.reverse() + + # Begin depth sort tests + + # use the smooth flag to set marked faces + for f in nmesh.faces: + f.smooth = 0 + + facelist = nmesh.faces[:] + maplist = [] + - self.depth_sort(nmesh.faces) + # The steps are _at_least_ equal to len(facelist), we do not count the + # feces coming out from splitting!! + progress.setActivity("HSR: Newell", len(facelist)) + #progress.setQuiet(True) - mesh.faces.delete(1, range(0, len(mesh.faces))) - - for i,f in enumerate(nmesh.faces): - fv = [v.index for v in f.v] - mesh.faces.extend(fv) - mesh.faces[i].mat = f.mat - mesh.faces[i].sel = f.sel - for i,c in enumerate(mesh.faces[i].col): - c.r = f.col[i].r - c.g = f.col[i].g - c.b = f.col[i].b - c.a = f.col[i].a + while len(facelist): + debug("\n----------------------\n") + debug("len(facelits): %d\n" % len(facelist)) + P = facelist[0] + + pSign = sign(P.normal[2]) + + # We can discard faces parallel to the view vector + #if P.normal[2] == 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 = sign(Q.normal[2]) + # TODO: check also if Q is parallel?? + + # Test 0: 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] + notZOverlap = min(zP) > max(zQ) + EPS + + if notZOverlap: + 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)) + notXOverlap = (min(xQ) >= max(xP)-EPS) or (min(xP) >= max(xQ)-EPS) + + 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)) + notYOverlap = (min(yQ) >= max(yP)-EPS) or (min(yP) >= max(yQ)-EPS) + + 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 * HSR.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 * HSR.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: Check if projections of polygons effectively overlap, + # in previous tests we checked only bounding boxes. + + #if not projectionsOverlap(P, Q): + if not ( HSR.projectionsOverlap(P, Q) or HSR.projectionsOverlap(Q, P)): + debug("\nTest 5\n") + debug("Projections do not overlap!\n") + continue + + # We still can't say if P obscures Q. + + # But if Q is marked we do a face-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") + + facelist = HSR.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 * HSR.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 * HSR.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") + + facelist = HSR.facesplit(P, Q, facelist, nmesh) + split_done = 1 + break + + facelist.remove(Q) + facelist.insert(0, Q) + Q.smooth = 1 + face_marked = 1 + debug("Q marked!\n") + break + + # Write P! + if split_done == 0 and face_marked == 0: + facelist.remove(P) + maplist.append(P) + dumpfaces(maplist, "dump"+str(len(maplist)).zfill(4)+".svg") + + progress.update() + + if len(facelist) == 870: + dumpfaces([P, Q], "loopdebug.svg") + + + #if facelist == None: + # maplist = [P, Q] + # print [v.co for v in P] + # print [v.co for v in Q] + # break + + # end of while len(facelist) + + + nmesh.faces = maplist + #for f in nmesh.faces: + # f.sel = 1 + + nmesh.update() + + + 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) + def _doEdgesStyle(self, mesh, edgestyleSelect): """Process Mesh Edges accroding to a given selection style. @@ -1243,12 +2765,21 @@ class Renderer: Mesh.Mode(Mesh.SelectModes['EDGE']) + edge_cache = MeshUtils.buildEdgeFaceUsersCache(mesh) + + for i,edge_faces in enumerate(edge_cache): + mesh.edges[i].sel = 0 + if edgestyleSelect(edge_faces): + mesh.edges[i].sel = 1 + + """ for e in mesh.edges: e.sel = 0 if edgestyleSelect(e, mesh): e.sel = 1 - + """ + # # --------------------------------------------------------------------- @@ -1328,7 +2859,8 @@ class GUI: glClear(GL_COLOR_BUFFER_BIT) glColor3f(0.0, 0.0, 0.0) glRasterPos2i(10, 350) - Draw.Text("VRM: Vector Rendering Method script.") + Draw.Text("VRM: Vector Rendering Method script. Version %s." % + __version__) glRasterPos2i(10, 335) Draw.Text("Press Q or ESC to quit.") @@ -1407,7 +2939,7 @@ class GUI: "Render hidden edges as dashed lines") glRasterPos2i(10, 160) - Draw.Text("Antonio Ospite (c) 2006") + Draw.Text("%s (c) 2006" % __author__) def event(evt, val): @@ -1426,9 +2958,12 @@ class GUI: elif evt == GUI.evtOutFormatMenu: i = GUI.outFormatMenu.val - 1 config.output['FORMAT']= outputWriters.keys()[i] + # Set the new output file + global outputfile + outputfile = Blender.sys.splitext(basename)[0] + "." + str(config.output['FORMAT']).lower() elif evt == GUI.evtAnimToggle: - config.outpur['ANIMATION'] = bool(GUI.animToggle.val) + config.output['ANIMATION'] = bool(GUI.animToggle.val) elif evt == GUI.evtJoinObjsToggle: config.output['JOIN_OBJECTS'] = bool(GUI.joinObjsToggle.val) @@ -1507,15 +3042,20 @@ def vectorize(filename): if editmode: Window.EditMode(1) + # Here the main if __name__ == "__main__": - + + global progress + outputfile = "" basename = Blender.sys.basename(Blender.Get('filename')) if basename != "": outputfile = Blender.sys.splitext(basename)[0] + "." + str(config.output['FORMAT']).lower() if Blender.mode == 'background': + progress = ConsoleProgressIndicator() vectorize(outputfile) else: + progress = GraphicalProgressIndicator() Draw.Register(GUI.draw, GUI.event, GUI.button_event)