# * 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
+# * Fixed a bug in the animation code, now the projection matrix is
+# recalculated at each frame!
#
# ---------------------------------------------------------------------
# Constants
EPS = 10e-5
+# We use a global progress Indicator Object
+progress = None
+
# Some global settings
class config:
polygons = dict()
polygons['SHOW'] = True
- polygons['SHADING'] = 'TOON'
+ polygons['SHADING'] = 'FLAT'
#polygons['HSR'] = 'PAINTER' # 'PAINTER' or 'NEWELL'
- polygons['HSR'] = 'NEWELL'
+ polygons['HSR'] = 'PAINTER'
# Hidden to the user for now
polygons['EXPANSION_TRICK'] = True
edges['SHOW'] = False
edges['SHOW_HIDDEN'] = False
edges['STYLE'] = 'MESH' # or SILHOUETTE
+ edges['STYLE'] = 'SILHOUETTE'
edges['WIDTH'] = 2
edges['COLOR'] = [0, 0, 0]
output = dict()
output['FORMAT'] = 'SVG'
- output['ANIMATION'] = False
+ output['FORMAT'] = 'SWF'
+ output['ANIMATION'] = True
output['JOIN_OBJECTS'] = True
# Utility functions
def sign(x):
- if x < 0:
+ if x < -EPS:
return -1
- elif x > 0:
+ elif x > EPS:
return 1
- #else:
- # return 0
+ else:
+ return 0
# ---------------------------------------------------------------------
return
def close(self):
- self.file.close()
+ if self.file:
+ self.file.close()
return
def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
self.file.write("</g>\n")
+## SWF Writer
+
+from ming import *
+
+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])
+ # set fps
+ self.movie.setRate(25)
+ 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)
+
+
+ """
+ # 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.
+ """
+
+ 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])
+
+
+ s.end()
+ sprite.add(s)
+
+
+
# ---------------------------------------------------------------------
#
## Rendering Classes
# A dictionary to collect the supported output formats
outputWriters = dict()
outputWriters['SVG'] = SVGVectorWriter
+outputWriters['SWF'] = SWFVectorWriter
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)
-
# Get the list of lighting sources
obj_lst = self._SCENE.getChildren()
self.lights = [ o for o in obj_lst if o.getType() == 'Lamp']
# And Set our camera accordingly
self.cameraObj = inputScene.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)
+
try:
renderedScene = self.doRenderScene(inputScene)
except :
mesh = obj.getData(mesh=1)
- # Triangolarize the mesh??
- for f in mesh.faces: f.sel = 1
- mesh.quadToTriangle()
-
self._doModelingTransformation(mesh, obj.matrix)
self._doBackFaceCulling(mesh)
+
# When doing HSR with NEWELL we may want to flip all normals
# toward the viewer
if config.polygons['HSR'] == "NEWELL":
self._doLighting(mesh)
-
# Do "projection" now so we perform further processing
# in Normalized View Coordinates
self._doProjection(mesh, self.proj)
self._doEdgesStyle(mesh, edgeStyles[config.edges['STYLE']])
-
# Update the object data, important! :)
mesh.update()
solves HSR correctly only for convex meshes.
"""
- global progress
+ #global progress
+
# The sorting requires circa n*log(n) steps
n = len(mesh.faces)
progress.setActivity("HSR: Painter", n*log(n))
nmesh.update()
+
def __newellDepthSort(self, mesh):
"""Newell's depth sorting.
"""
-
from hsrtk import *
+ #global progress
+
# Find non planar quads and convert them to triangle
#for f in mesh.faces:
# f.sel = 0
# 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_furthest_z)
nmesh.faces.reverse()
-
# Begin depth sort tests
# use the smooth flag to set marked faces
# The steps are _at_least_ equal to len(facelist), we do not count the
# feces coming out from splitting!!
- global progress
progress.setActivity("HSR: Newell", len(facelist))
#progress.setQuiet(True)
pSign = sign(P.normal[2])
# We can discard faces parallel to the view vector
- if P.normal[2] == 0:
- facelist.remove(P)
- continue
+ #if P.normal[2] == 0:
+ # facelist.remove(P)
+ # continue
split_done = 0
face_marked = 0
zP = [v.co[2] for v in P.v]
zQ = [v.co[2] for v in Q.v]
- notZOverlap = min(zP) > max(zQ)+EPS
+ notZOverlap = min(zP) > max(zQ) + EPS
if notZOverlap:
debug("\nTest 0\n")
progress.update()
- if facelist == None:
- maplist = [P, Q]
- print [v.co for v in P]
- print [v.co for v in Q]
- break
+ #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()
if editmode: Window.EditMode(1)
-# We use a global progress Indicator Object
-progress = None
-
# Here the main
if __name__ == "__main__":
projects / vrm.git / blobdiff