X-Git-Url: https://git.ao2.it/vrm.git/blobdiff_plain/d8063a0d4fb1d4448857006369dd02c3d30c8df6..dcc666c5b495072d477e85b544d6eb967fb6acc0:/vrm.py?ds=sidebyside diff --git a/vrm.py b/vrm.py index b3aac25..35df00c 100755 --- a/vrm.py +++ b/vrm.py @@ -57,7 +57,9 @@ __bpydoc__ = """\ # Think to a way to merge adjacent polygons that have the same color. # Or a way to use paths for silhouettes and contours. # - Add Vector Writers other that SVG. -# - Consider SMIL for animation handling instead of ECMA Script? +# - Consider SMIL for animation handling instead of ECMA Script? (Firefox do +# not support SMIL for animations) +# - FIX the issue with negative scales in object tranformations! # # --------------------------------------------------------------------- # @@ -77,12 +79,13 @@ from math import * # Some global settings + PRINT_POLYGONS = True -POLYGON_EXPANSION_TRICK = True -PRINT_EDGES = True +POLYGON_EXPANSION_TRICK = True # Hidden to the user for now + +PRINT_EDGES = False SHOW_HIDDEN_EDGES = False -#EDGE_STYLE = 'normal' EDGE_STYLE = 'silhouette' EDGES_WIDTH = 0.5 @@ -93,16 +96,15 @@ OPTIMIZE_FOR_SPACE = True OUTPUT_FORMAT = 'SVG' + # --------------------------------------------------------------------- # ## Utility Mesh class # # --------------------------------------------------------------------- class MeshUtils: - def __init__(self): - return - def getEdgeAdjacentFaces(self, edge, mesh): + def getEdgeAdjacentFaces(edge, mesh): """Get the faces adjacent to a given edge. There can be 0, 1 or more (usually 2) faces adjacent to an edge. @@ -115,7 +117,7 @@ class MeshUtils: return adjface_list - def isVisibleEdge(self, e, mesh): + def isVisibleEdge(e, mesh): """Normal edge selection rule. An edge is visible if _any_ of its adjacent faces is selected. @@ -123,7 +125,7 @@ class MeshUtils: useful for "edge only" portion of objects. """ - adjacent_faces = self.getEdgeAdjacentFaces(e, mesh) + adjacent_faces = MeshUtils.getEdgeAdjacentFaces(e, mesh) if len(adjacent_faces) == 0: return True @@ -135,7 +137,7 @@ class MeshUtils: else: return False - def isSilhouetteEdge(self, e, mesh): + def isSilhouetteEdge(e, mesh): """Silhuette selection rule. An edge is a silhuette edge if it is shared by two faces with @@ -143,7 +145,7 @@ class MeshUtils: face. """ - adjacent_faces = self.getEdgeAdjacentFaces(e, mesh) + adjacent_faces = MeshUtils.getEdgeAdjacentFaces(e, mesh) if ((len(adjacent_faces) == 1 and adjacent_faces[0].sel == 1) or (len(adjacent_faces) == 2 and @@ -152,6 +154,10 @@ class MeshUtils: return True else: return False + + getEdgeAdjacentFaces = staticmethod(getEdgeAdjacentFaces) + isVisibleEdge = staticmethod(isVisibleEdge) + isSilhouetteEdge = staticmethod(isSilhouetteEdge) @@ -404,6 +410,7 @@ class SVGVectorWriter(VectorWriter): self.file.write("\n" % (framenumber, framestyle) ) + for obj in Objects: if(obj.getType() != 'Mesh'): @@ -571,8 +578,6 @@ class SVGVectorWriter(VectorWriter): hidden_stroke_style = "" - # We consider an edge visible if _both_ its vertices are selected, - # hence an edge is hidden if _any_ of its vertices is deselected. if e.sel == 0: if showHiddenEdges == False: continue @@ -600,6 +605,19 @@ class SVGVectorWriter(VectorWriter): # # --------------------------------------------------------------------- +# A dictionary to collect all the different edge styles and their edge +# selection criteria +edgeSelectionStyles = { + 'normal': MeshUtils.isVisibleEdge, + 'silhouette': MeshUtils.isSilhouetteEdge + } + +# A dictionary to collect the supported output formats +outputWriters = { + 'SVG': SVGVectorWriter, + } + + class Renderer: """Render a scene viewed from a given camera. @@ -630,13 +648,22 @@ 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'] + # When there are no lights we use a default lighting source + # that have the same position of the camera if len(self.lights) == 0: l = Lamp.New('Lamp') lobj = Object.New('Lamp') + lobj.loc = self.cameraObj.loc lobj.link(l) self.lights.append(lobj) @@ -672,7 +699,16 @@ class Renderer: for f in range(startFrame, endFrame+1): context.currentFrame(f) - renderedScene = self.doRenderScene(self._SCENE) + # Use some temporary workspace, a full copy of the scene + inputScene = self._SCENE.copy(2) + + try: + renderedScene = self.doRenderScene(inputScene) + except: + self._SCENE.makeCurrent() + Scene.unlink(inputScene) + del inputScene + outputWriter.printCanvas(renderedScene, doPrintPolygons = PRINT_POLYGONS, doPrintEdges = PRINT_EDGES, @@ -688,22 +724,13 @@ class Renderer: context.currentFrame(currentFrame) - def doRenderScene(self, inputScene): + def doRenderScene(self, workScene): """Control the rendering process. Here we control the entire rendering process invoking the operation needed to transform and project the 3D scene in two dimensions. """ - # Use some temporary workspace, a full copy of the scene - workScene = inputScene.copy(2) - - # Get a projector for this scene. - # NOTE: the projector wants object in world coordinates, - # so we should apply modelview transformations _before_ - # projection transformations - proj = Projector(self.cameraObj, self.canvasRatio) - # global processing of the scene self._doConvertGeometricObjToMesh(workScene) @@ -753,7 +780,7 @@ class Renderer: self._doEdgesStyle(mesh, edgeSelectionStyles[EDGE_STYLE]) - self._doProjection(mesh, proj) + self._doProjection(mesh, self.proj) # Update the object data, important! :) mesh.update() @@ -912,11 +939,17 @@ class Renderer: def _joinMeshObjectsInScene(self, scene): """Merge all the Mesh Objects in a scene into a single Mesh Object. """ + + oList = [o for o in scene.getChildren() if o.getType()=='Mesh'] + + # FIXME: Object.join() do not work if the list contains 1 object + if len(oList) == 1: + return + mesh = Mesh.New() bigObj = Object.New('Mesh', 'BigOne') bigObj.link(mesh) - oList = [o for o in scene.getChildren() if o.getType()=='Mesh'] bigObj.join(oList) scene.link(bigObj) for o in oList: @@ -951,6 +984,11 @@ class Renderer: This step is done simply applying to the object its tranformation matrix and recalculating its normals. """ + # XXX FIXME: blender do not transform normals in the right way when + # there are negative scale values + if matrix[0][0] < 0 or matrix[1][1] < 0 or matrix[2][2] < 0: + print "WARNING: Negative scales, expect incorrect results!" + mesh.transform(matrix, True) def _doObjectDepthSorting(self, mesh): @@ -1117,10 +1155,9 @@ class Renderer: for e in mesh.edges: + e.sel = 0 if edgestyleSelect(e, mesh): e.sel = 1 - else: - e.sel = 0 def _doProjection(self, mesh, projector): """Calculate the Projection for the object. @@ -1137,22 +1174,203 @@ class Renderer: # --------------------------------------------------------------------- # -## Main Program +## GUI Class and Main Program # # --------------------------------------------------------------------- -# A dictionary to collect all the different edge styles and their edge -# selection criteria -edgeSelectionStyles = { - 'normal': MeshUtils().isVisibleEdge, - 'silhouette': MeshUtils().isSilhouetteEdge - } -# A dictionary to collect the supported output formats -outputWriters = { - 'SVG': SVGVectorWriter, - } +from Blender import BGL, Draw +from Blender.BGL import * +class GUI: + + def _init(): + + # Output Format menu + default_value = outputWriters.keys().index(OUTPUT_FORMAT)+1 + GUI.outFormatMenu = Draw.Create(default_value) + GUI.evtOutFormatMenu = 0 + + # Animation toggle button + GUI.animToggle = Draw.Create(RENDER_ANIMATION) + GUI.evtAnimToggle = 1 + + # Join Objects toggle button + GUI.joinObjsToggle = Draw.Create(OPTIMIZE_FOR_SPACE) + GUI.evtJoinObjsToggle = 2 + + # Render filled polygons + GUI.polygonsToggle = Draw.Create(PRINT_POLYGONS) + GUI.evtPolygonsToggle = 3 + # We hide the POLYGON_EXPANSION_TRICK, for now + + # Render polygon edges + GUI.showEdgesToggle = Draw.Create(PRINT_EDGES) + GUI.evtShowEdgesToggle = 4 + + # Render hidden edges + GUI.showHiddenEdgesToggle = Draw.Create(SHOW_HIDDEN_EDGES) + GUI.evtShowHiddenEdgesToggle = 5 + + # Edge Style menu + default_value = edgeSelectionStyles.keys().index(EDGE_STYLE)+1 + GUI.edgeStyleMenu = Draw.Create(default_value) + GUI.evtEdgeStyleMenu = 6 + + # Edge Width slider + GUI.edgeWidthSlider = Draw.Create(EDGES_WIDTH) + GUI.evtEdgeWidthSlider = 7 + + # Render Button + GUI.evtRenderButton = 8 + + # Exit Button + GUI.evtExitButton = 9 + + def draw(): + + # initialize static members + GUI._init() + + glClear(GL_COLOR_BUFFER_BIT) + glColor3f(0.0, 0.0, 0.0) + glRasterPos2i(10, 350) + Draw.Text("VRM: Vector Rendering Method script.") + glRasterPos2i(10, 335) + Draw.Text("Press Q or ESC to quit.") + + # Build the output format menu + glRasterPos2i(10, 310) + Draw.Text("Select the output Format:") + outMenuStruct = "Output Format %t" + for t in outputWriters.keys(): + outMenuStruct = outMenuStruct + "|%s" % t + GUI.outFormatMenu = Draw.Menu(outMenuStruct, GUI.evtOutFormatMenu, + 10, 285, 160, 18, GUI.outFormatMenu.val, "Choose the Output Format") + + # Animation toggle + GUI.animToggle = Draw.Toggle("Animation", GUI.evtAnimToggle, + 10, 260, 160, 18, GUI.animToggle.val, + "Toggle rendering of animations") + + # Join Objects toggle + GUI.joinObjsToggle = Draw.Toggle("Join objects", GUI.evtJoinObjsToggle, + 10, 235, 160, 18, GUI.joinObjsToggle.val, + "Join objects in the rendered file") + + # Render Button + Draw.Button("Render", GUI.evtRenderButton, 10, 210-25, 75, 25+18, + "Start Rendering") + Draw.Button("Exit", GUI.evtExitButton, 95, 210-25, 75, 25+18, "Exit!") + + # Rendering Styles + glRasterPos2i(200, 310) + Draw.Text("Rendering Style:") + + # Render Polygons + GUI.polygonsToggle = Draw.Toggle("Filled Polygons", GUI.evtPolygonsToggle, + 200, 285, 160, 18, GUI.polygonsToggle.val, + "Render filled polygons") + + # Render Edges + GUI.showEdgesToggle = Draw.Toggle("Show Edges", GUI.evtShowEdgesToggle, + 200, 260, 160, 18, GUI.showEdgesToggle.val, + "Render polygon edges") + + if GUI.showEdgesToggle.val == 1: + + # Edge Style + edgeStyleMenuStruct = "Edge Style %t" + for t in edgeSelectionStyles.keys(): + edgeStyleMenuStruct = edgeStyleMenuStruct + "|%s" % t + GUI.edgeStyleMenu = Draw.Menu(edgeStyleMenuStruct, GUI.evtEdgeStyleMenu, + 200, 235, 160, 18, GUI.edgeStyleMenu.val, + "Choose the edge style") + + # Edge size + GUI.edgeWidthSlider = Draw.Slider("Width: ", GUI.evtEdgeWidthSlider, + 200, 210, 160, 18, GUI.edgeWidthSlider.val, + 0.0, 10.0, 0, "Change Edge Width") + + # Show Hidden Edges + GUI.showHiddenEdgesToggle = Draw.Toggle("Show Hidden Edges", + GUI.evtShowHiddenEdgesToggle, + 200, 185, 160, 18, GUI.showHiddenEdgesToggle.val, + "Render hidden edges as dashed lines") + + glRasterPos2i(10, 160) + Draw.Text("Antonio Ospite (c) 2006") + + def event(evt, val): + + if evt == Draw.ESCKEY or evt == Draw.QKEY: + Draw.Exit() + else: + return + + Draw.Redraw(1) + + def button_event(evt): + global PRINT_POLYGONS + global POLYGON_EXPANSION_TRICK + global PRINT_EDGES + global SHOW_HIDDEN_EDGES + global EDGE_STYLE + global EDGES_WIDTH + global RENDER_ANIMATION + global OPTIMIZE_FOR_SPACE + global OUTPUT_FORMAT + + if evt == GUI.evtExitButton: + Draw.Exit() + elif evt == GUI.evtOutFormatMenu: + i = GUI.outFormatMenu.val - 1 + OUTPUT_FORMAT = outputWriters.keys()[i] + elif evt == GUI.evtAnimToggle: + RENDER_ANIMATION = bool(GUI.animToggle.val) + elif evt == GUI.evtJoinObjsToggle: + OPTIMIZE_FOR_SPACE = bool(GUI.joinObjsToggle.val) + elif evt == GUI.evtPolygonsToggle: + PRINT_POLYGONS = bool(GUI.polygonsToggle.val) + elif evt == GUI.evtShowEdgesToggle: + PRINT_EDGES = bool(GUI.showEdgesToggle.val) + elif evt == GUI.evtShowHiddenEdgesToggle: + SHOW_HIDDEN_EDGES = bool(GUI.showHiddenEdgesToggle.val) + elif evt == GUI.evtEdgeStyleMenu: + i = GUI.edgeStyleMenu.val - 1 + EDGE_STYLE = edgeSelectionStyles.keys()[i] + elif evt == GUI.evtEdgeWidthSlider: + EDGES_WIDTH = float(GUI.edgeWidthSlider.val) + elif evt == GUI.evtRenderButton: + label = "Save %s" % OUTPUT_FORMAT + # Show the File Selector + global outputfile + Blender.Window.FileSelector(vectorize, label, outputfile) + + else: + print "Event: %d not handled!" % evt + + if evt: + Draw.Redraw(1) + #GUI.conf_debug() + + def conf_debug(): + print + print "PRINT_POLYGONS:", PRINT_POLYGONS + print "POLYGON_EXPANSION_TRICK:", POLYGON_EXPANSION_TRICK + print "PRINT_EDGES:", PRINT_EDGES + print "SHOW_HIDDEN_EDGES:", SHOW_HIDDEN_EDGES + print "EDGE_STYLE:", EDGE_STYLE + print "EDGES_WIDTH:", EDGES_WIDTH + print "RENDER_ANIMATION:", RENDER_ANIMATION + print "OPTIMIZE_FOR_SPACE:", OPTIMIZE_FOR_SPACE + print "OUTPUT_FORMAT:", OUTPUT_FORMAT + + _init = staticmethod(_init) + draw = staticmethod(draw) + event = staticmethod(event) + button_event = staticmethod(button_event) + conf_debug = staticmethod(conf_debug) # A wrapper function for the vectorizing process def vectorize(filename): @@ -1161,11 +1379,17 @@ def vectorize(filename): - Instanciate the writer and the renderer - Render! """ + + if filename == "": + print "\nERROR: invalid file name!" + return + from Blender import Window editmode = Window.EditMode() if editmode: Window.EditMode(0) - writer = outputWriters[OUTPUT_FORMAT](filename) + actualWriter = outputWriters[OUTPUT_FORMAT] + writer = actualWriter(filename) renderer = Renderer() renderer.doRendering(writer, RENDER_ANIMATION) @@ -1176,12 +1400,12 @@ def vectorize(filename): # Here the main if __name__ == "__main__": + outputfile = "" basename = Blender.sys.basename(Blender.Get('filename')) - outputfile = Blender.sys.splitext(basename)[0]+".svg" + if basename != "": + outputfile = Blender.sys.splitext(basename)[0] + "." + str(OUTPUT_FORMAT).lower() if Blender.mode == 'background': vectorize(outputfile) else: - label = "Save %s" % OUTPUT_FORMAT - Blender.Window.FileSelector(vectorize, label, outputfile) - Blender.Redraw() + Draw.Register(GUI.draw, GUI.event, GUI.button_event)