# Things TODO for a next release:
# - FIX the issue with negative scales in object tranformations!
# - Use a better depth sorting algorithm
-# - Implement clipping of primitives and do handle object intersections.
-# (for now only clipping away whole objects is supported).
# - Review how selections are made (this script uses selection states of
# primitives to represent visibility infos)
# - Use a data structure other than Mesh to represent the 2D image?
# * 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
+# * 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 in the case of camera movement.
+# * Use fps as specified in blender when VectorWriter handles animation
+# * Remove the real file opening in the abstract VectorWriter
+# * View frustum clipping
+# * Scene clipping done using bounding box instead of object center
#
# ---------------------------------------------------------------------
polygons = dict()
polygons['SHOW'] = True
polygons['SHADING'] = 'FLAT' # FLAT or TOON
- polygons['HSR'] = 'PAINTER' # PAINTER or NEWELL
+ polygons['HSR'] = 'NEWELL' # PAINTER or NEWELL
# Hidden to the user for now
polygons['EXPANSION_TRICK'] = True
makeFaces = staticmethod(makeFaces)
- def splitOn(Q, P):
+ 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
"""
# If vertex are all on the same half-space, return
#if len(posVertList) < 3:
- # print "Problem, we created a face with less that 3 verteices??"
+ # 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 verteices??"
+ # print "Problem, we created a face with less that 3 vertices??"
# negVertList = []
if len(posVertList) < 3 or len(negVertList) < 3:
- print "RETURN NONE, SURE???"
+ #print "RETURN NONE, SURE???"
return None
+ if not return_positive_faces:
+ posVertList = []
+ if not return_negative_faces:
+ negVertList = []
newfaces = HSR.addNewFaces(posVertList, negVertList)
"""Set the output file name and other properties"""
self.outputFileName = fileName
- self.file = None
context = Scene.GetCurrent().getRenderingContext()
self.canvasSize = ( context.imageSizeX(), context.imageSizeY() )
+ self.fps = context.fps
+
self.startFrame = 1
self.endFrame = 1
self.animation = False
self.endFrame = endFrame
self.animation = True
- self.file = open(self.outputFileName, "w")
print "Outputting to: ", self.outputFileName
return
def close(self):
- if self.file:
- self.file.close()
return
def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
"""
VectorWriter.__init__(self, fileName)
+ self.file = None
+
##
# Public Methods
"""Do some initialization operations.
"""
VectorWriter.open(self, startFrame, endFrame)
+
+ self.file = open(self.outputFileName, "w")
+
self._printHeader()
def close(self):
"""
self._printFooter()
- # remember to call the close method of the parent
+ if self.file:
+ self.file.close()
+
+ # remember to call the close method of the parent as last
VectorWriter.close(self)
self.canvasSize)
if self.animation:
+ delay = 1000/self.fps
self.file.write("""\n<script type="text/javascript"><![CDATA[
globalStartFrame=%d;
globalEndFrame=%d;
- /* FIXME: Use 1000 as interval as lower values gives problems */
- timerID = setInterval("NextFrame()", 1000);
+ timerID = setInterval("NextFrame()", %d);
globalFrameCounter=%d;
+ \n""" % (self.startFrame, self.endFrame, delay, self.startFrame) )
+ self.file.write("""\n
function NextFrame()
{
currentElement = document.getElementById('frame'+globalFrameCounter)
}
}
\n]]></script>\n
- \n""" % (self.startFrame, self.endFrame, self.startFrame) )
+ \n""")
def _printFooter(self):
"""Print the SVG footer."""
VectorWriter.open(self, startFrame, endFrame)
self.movie = SWFMovie()
self.movie.setDimension(self.canvasSize[0], self.canvasSize[1])
- # set fps
- self.movie.setRate(25)
- numframes = endFrame - startFrame + 1
- self.movie.setFrames(numframes)
+ if self.animation:
+ self.movie.setRate(self.fps)
+ numframes = endFrame - startFrame + 1
+ self.movie.setFrames(numframes)
def close(self):
"""Do some finalization operation.
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)
- """
- # use the stroke property to alleviate the "adjacent edges" problem,
- # we simulate polygon expansion using borders,
- # see http://www.antigrain.com/svg/index.html for more info
- stroke_width = 1.0
-
- # EXPANSION TRICK is not that useful where there is transparency
- if config.polygons['EXPANSION_TRICK'] and color[3] == 255:
- # str_col = "#000000" # For debug
- self.file.write(" stroke:%s;\n" % str_col)
- self.file.write(" stroke-width:" + str(stroke_width) + ";\n")
- self.file.write(" stroke-linecap:round;stroke-linejoin:round")
-
- """
-
def _printEdges(self, mesh, sprite, showHiddenEdges=False):
"""Print the wireframe using mesh edges.
"""
for e in mesh.edges:
- #Next, we set the line width and color for our shape.
+ # 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)
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])
-
+ s.movePenTo(p1[0], p1[1])
+ s.drawLineTo(p2[0], p2[1])
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):
+ """Simply call the parent Contructor.
+ """
+ VectorWriter.__init__(self, fileName)
+
+ self.canvas = None
+
+
+ ##
+ # Public Methods
+ #
+
+ def open(self, startFrame=1, endFrame=1):
+ """Do some initialization operations.
+ """
+ VectorWriter.open(self, startFrame, endFrame)
+ 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.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.
+ """
+ context = scene.getRenderingContext()
+ framenumber = context.currentFrame()
+
+ Objects = scene.getChildren()
+
+ for obj in Objects:
+
+ if(obj.getType() != 'Mesh'):
+ continue
+
+ mesh = obj.getData(mesh=1)
+
+ if doPrintPolygons:
+ self._printPolygons(mesh)
+
+ if doPrintEdges:
+ self._printEdges(mesh, showHiddenEdges)
+
+ self.canvas.showPage()
+
+ ##
+ # 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):
+ """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/255.0, fcol.g/255.0, fcol.b/255.0,
+ fcol.a/255.0]
+ else:
+ color = [1, 1, 1, 1]
+
+ self.canvas.setFillColorRGB(color[0], color[1], color[2])
+ # For debug
+ self.canvas.setStrokeColorRGB(0, 0, 0)
+
+ path = self.canvas.beginPath()
+
+ # The starting point of the path
+ p0 = self._calcCanvasCoord(face.verts[0])
+ path.moveTo(p0[0], p0[1])
+
+ for v in face.verts[1:]:
+ p = self._calcCanvasCoord(v)
+ path.lineTo(p[0], p[1])
+
+ # Closing the shape
+ path.close()
+
+ self.canvas.drawPath(path, stroke=0, fill=1)
+
+ def _printEdges(self, mesh, showHiddenEdges=False):
+ """Print the wireframe using mesh edges.
+ """
+
+ stroke_width = config.edges['WIDTH']
+ stroke_col = config.edges['COLOR']
+
+ 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:
+
+ self.canvas.setLineWidth(stroke_width)
+
+ if e.sel == 0:
+ if showHiddenEdges == False:
+ continue
+ else:
+ # 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.canvas.line(p1[0], p1[1], p2[0], p2[1])
+
+
# ---------------------------------------------------------------------
#
outputWriters['SVG'] = SVGVectorWriter
if SWFSupported:
outputWriters['SWF'] = SWFVectorWriter
+if PDFSupported:
+ outputWriters['PDF'] = PDFVectorWriter
class Renderer:
)
# Render from the currently active camera
- self.cameraObj = self._SCENE.getCurrentCamera()
+ #self.cameraObj = self._SCENE.getCurrentCamera()
# Get the list of lighting sources
obj_lst = self._SCENE.getChildren()
print "Start Rendering of %d frames" % (endFrame-startFrame+1)
for f in xrange(startFrame, endFrame+1):
print "\n\nFrame: %d" % f
- context.currentFrame(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,
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
for o in Objects:
if o.getType() != 'Mesh': continue;
- obj_vect = Vector(cpos) - self._getObjPosition(o)
+ """
+ obj_vect = Vector(cam_pos) - self._getObjPosition(o)
d = obj_vect*view_vect
theta = AngleBetweenVecs(obj_vect, view_vect)
# if the object is outside the view frustum, clip it away
if (d < near) or (d > far) or (theta > fovy):
scene.unlink(o)
+ """
+
+ # Use the object bounding box
+ # (whose points are already in WorldSpace Coordinate)
+
+ bb = o.getBoundBox()
+
+ points_outside = 0
+ for p in bb:
+ p_vect = Vector(cam_pos) - Vector(p)
+
+ d = p_vect * view_vect
+ theta = AngleBetweenVecs(p_vect, view_vect)
+
+ # Is this point outside the view frustum?
+ if (d < near) or (d > far) or (theta > fovy):
+ points_outside += 1
+
+ # If the bb is all outside the view frustum we clip the whole
+ # object away
+ if points_outside == len(bb):
+ scene.unlink(o)
+
+
def _doConvertGeometricObjsToMesh(self, scene):
"""Convert all "geometric" objects to mesh ones.
c = self._getObjPosition(self.cameraObj)
- by_center_pos = (lambda o1, o2:
+ by_obj_center_pos = (lambda o1, o2:
(o1.getType() == 'Mesh' and o2.getType() == 'Mesh') and
cmp((self._getObjPosition(o1) - Vector(c)).length,
(self._getObjPosition(o2) - Vector(c)).length)
)
- # TODO: implement sorting by bounding box, if obj1.bb is inside obj2.bb,
- # then ob1 goes farther than obj2, useful when obj2 has holes
- by_bbox = None
+ # Implement sorting by bounding box, the object with the bb
+ # nearest to the camera should be drawn as last.
+ by_nearest_bbox_point = (lambda o1, o2:
+ (o1.getType() == 'Mesh' and o2.getType() == 'Mesh') and
+ cmp( min( [(Vector(p) - Vector(c)).length for p in o1.getBoundBox()] ),
+ min( [(Vector(p) - Vector(c)).length for p in o2.getBoundBox()] )
+ )
+ )
+
Objects = scene.getChildren()
- Objects.sort(by_center_pos)
+ #Objects.sort(by_obj_center_pos)
+ Objects.sort(by_nearest_bbox_point)
# update the scene
for o in Objects:
"""Clip faces against the View Frustum.
"""
+ # 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[:]
+
+ 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 all outside the view frustum
+ # 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 or abs(v[2]) > 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)
+
+ clippedfaces.append(nf)
+ facelist = clippedfaces[:]
+
+
+ nmesh.faces = facelist
+ nmesh.update()
+
+
# HSR routines
def __simpleDepthSort(self, mesh):
"""Sort faces by the furthest vertex.
projects / vrm.git / blobdiff