X-Git-Url: https://git.ao2.it/vrm.git/blobdiff_plain/d8063a0d4fb1d4448857006369dd02c3d30c8df6..159f92477d4654437623a3e564619519b9a1fdd1:/vrm.py diff --git a/vrm.py b/vrm.py index b3aac25..fc7cb5d 100755 --- a/vrm.py +++ b/vrm.py @@ -1,7 +1,7 @@ #!BPY """ Name: 'VRM' -Blender: 241 +Blender: 242 Group: 'Render' Tooltip: 'Vector Rendering Method script' """ @@ -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,20 +79,25 @@ from math import * # Some global settings -PRINT_POLYGONS = True -POLYGON_EXPANSION_TRICK = True -PRINT_EDGES = True -SHOW_HIDDEN_EDGES = False -#EDGE_STYLE = 'normal' -EDGE_STYLE = 'silhouette' -EDGES_WIDTH = 0.5 +class config: + polygons = dict() + polygons['FILL'] = True + polygons['STYLE'] = None + # Hidden to the user for now + polygons['EXPANSION_TRICK'] = True -RENDER_ANIMATION = False + edges = dict() + edges['SHOW'] = True + edges['SHOW_HIDDEN'] = False + edges['STYLE'] = 'silhouette' + edges['WIDTH'] = 2 -OPTIMIZE_FOR_SPACE = True + output = dict() + output['FORMAT'] = 'SVG' + output['ANIMATION'] = False + output['MERGED_OBJECTS'] = True -OUTPUT_FORMAT = 'SVG' # --------------------------------------------------------------------- @@ -99,10 +106,8 @@ OUTPUT_FORMAT = 'SVG' # # --------------------------------------------------------------------- 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 +120,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 +128,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 +140,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 +148,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 +157,30 @@ class MeshUtils: return True else: return False + + def toonShading(u): + + levels = 2 + texels = 2*levels - 1 + map = [0.0] + [(i)/float(texels-1) for i in range(1, texels-1) ] + [1.0] + + v = 1.0 + for i in range(0, len(map)-1): + pivot = (map[i]+map[i+1])/2.0 + j = int(u>pivot) + + v = map[i+j] + + if v\n" % (framenumber, framestyle) ) + for obj in Objects: if(obj.getType() != 'Mesh'): @@ -550,7 +580,7 @@ class SVGVectorWriter(VectorWriter): self.file.write("\tstyle=\"fill:" + str_col + ";") self.file.write(opacity_string) - if POLYGON_EXPANSION_TRICK: + if config.polygons['EXPANSION_TRICK']: self.file.write(" stroke:" + str_col + ";") self.file.write(" stroke-width:" + str(stroke_width) + ";\n") self.file.write(" stroke-linecap:round;stroke-linejoin:round") @@ -571,8 +601,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 +628,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 +671,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,12 +722,25 @@ 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) + + print "Before" + + try: + renderedScene = self.doRenderScene(inputScene) + except: + self._SCENE.makeCurrent() + Scene.unlink(inputScene) + del inputScene + outputWriter.printCanvas(renderedScene, - doPrintPolygons = PRINT_POLYGONS, - doPrintEdges = PRINT_EDGES, - showHiddenEdges = SHOW_HIDDEN_EDGES) + doPrintPolygons = config.polygons['FILL'], + doPrintEdges = config.edges['SHOW'], + showHiddenEdges = config.edges['SHOW_HIDDEN']) + print "After" + # clear the rendered scene self._SCENE.makeCurrent() Scene.unlink(renderedScene) @@ -688,22 +751,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 +807,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 +966,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 +1011,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): @@ -1072,22 +1137,27 @@ class Renderer: # Diffuse component (add light.col for kd) kd = mat.getRef() * Vector(mat.getRGBCol()) Ip = light.getEnergy() - Idiff = Ip * kd * (N*L) - + #Idiff = Ip * kd * int(N*L > 0.5) + Idiff = Ip * kd * MeshUtils.toonShading(N*L) + # Specular component ks = mat.getSpec() * Vector(mat.getSpecCol()) ns = mat.getHardness() - Ispec = Ip * ks * pow((V * R), ns) + Ispec = Ip * ks * pow((V*R), ns) # Emissive component ki = Vector([mat.getEmit()]*3) I = ki + Iamb + Idiff + Ispec + # Set Alpha component I = list(I) I.append(mat.getAlpha()) + # Toon shading + #I = [MeshUtils.toonShading(c) for c in I] + # Clamp I values between 0 and 1 I = [ min(c, 1) for c in I] I = [ max(0, c) for c in I] @@ -1117,10 +1187,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 +1206,198 @@ 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 + output_format = config.output['FORMAT'] + default_value = outputWriters.keys().index(output_format)+1 + GUI.outFormatMenu = Draw.Create(default_value) + GUI.evtOutFormatMenu = 0 + + # Animation toggle button + GUI.animToggle = Draw.Create(config.output['ANIMATION']) + GUI.evtAnimToggle = 1 + + # Join Objects toggle button + GUI.joinObjsToggle = Draw.Create(config.output['MERGED_OBJECTS']) + GUI.evtJoinObjsToggle = 2 + + # Render filled polygons + GUI.polygonsToggle = Draw.Create(config.polygons['FILL']) + + GUI.evtPolygonsToggle = 3 + # We hide the config.polygons['EXPANSION_TRICK'], for now + + # Render polygon edges + GUI.showEdgesToggle = Draw.Create(config.edges['SHOW']) + GUI.evtShowEdgesToggle = 4 + + # Render hidden edges + GUI.showHiddenEdgesToggle = Draw.Create(config.edges['SHOW_HIDDEN']) + GUI.evtShowHiddenEdgesToggle = 5 + + # Edge Style menu + edge_style = config.edges['STYLE'] + default_value = edgeSelectionStyles.keys().index(edge_style)+1 + GUI.edgeStyleMenu = Draw.Create(default_value) + GUI.evtEdgeStyleMenu = 6 + + # Edge Width slider + GUI.edgeWidthSlider = Draw.Create(config.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): + + if evt == GUI.evtExitButton: + Draw.Exit() + + elif evt == GUI.evtOutFormatMenu: + i = GUI.outFormatMenu.val - 1 + config.output['FORMAT']= outputWriters.keys()[i] + + elif evt == GUI.evtAnimToggle: + config.outpur['ANIMATION'] = bool(GUI.animToggle.val) + + elif evt == GUI.evtJoinObjsToggle: + config.output['MERGED_OBJECTS'] = bool(GUI.joinObjsToggle.val) + + elif evt == GUI.evtPolygonsToggle: + config.polygons['FILL'] = bool(GUI.polygonsToggle.val) + + elif evt == GUI.evtShowEdgesToggle: + config.edges['SHOW'] = bool(GUI.showEdgesToggle.val) + + elif evt == GUI.evtShowHiddenEdgesToggle: + config.edges['SHOW_HIDDEN'] = bool(GUI.showHiddenEdgesToggle.val) + + elif evt == GUI.evtEdgeStyleMenu: + i = GUI.edgeStyleMenu.val - 1 + config.edges['STYLE'] = edgeSelectionStyles.keys()[i] + + elif evt == GUI.evtEdgeWidthSlider: + config.edges['WIDTH'] = float(GUI.edgeWidthSlider.val) + + elif evt == GUI.evtRenderButton: + label = "Save %s" % config.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(): + from pprint import pprint + pprint(config) + + _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,14 +1406,20 @@ 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[config.output['FORMAT']] + writer = actualWriter(filename) renderer = Renderer() - renderer.doRendering(writer, RENDER_ANIMATION) + renderer.doRendering(writer, config.output['ANIMATION']) if editmode: Window.EditMode(1) @@ -1176,12 +1427,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(config.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)