Warn about negative scales

[vrm.git] / vrm.py

diff --git a/vrm.py b/vrm.py
index 8914045..35df00c 100755 (executable)
--- a/vrm.py
+++ b/vrm.py
@@ -2,12 +2,12 @@
 """
 Name: 'VRM'
 Blender: 241
 """
 Name: 'VRM'
 Blender: 241

-Group: 'Export'
-Tooltip: 'Vector Rendering Method Export Script'
+Group: 'Render'
+Tooltip: 'Vector Rendering Method script'

 """
 
 __author__ = "Antonio Ospite"
 """
 
 __author__ = "Antonio Ospite"

-__url__ = ["blender"]
+__url__ = ["http://vrm.projects.blender.org"]

 __version__ = "0.3"
 
 __bpydoc__ = """\
 __version__ = "0.3"
 
 __bpydoc__ = """\


@@ -43,19 +43,23 @@ __bpydoc__ = """\
 # 
 # Things TODO for a next release:
 #   - Switch to the Mesh structure, should be considerably faster
 # 
 # Things TODO for a next release:
 #   - Switch to the Mesh structure, should be considerably faster

-#    (partially done, but cannot sort faces, yet)
+#    (partially done, but with Mesh we cannot sort faces, yet)

 #   - Use a better depth sorting algorithm
 #   - Review how selections are made (this script uses selection states of
 #     primitives to represent visibility infos)
 #   - Implement clipping of primitives and do handle object intersections.
 #     (for now only clipping for whole objects is supported).
 #   - Use a better depth sorting algorithm
 #   - Review how selections are made (this script uses selection states of
 #     primitives to represent visibility infos)
 #   - Implement clipping of primitives and do handle object intersections.
 #     (for now only clipping for whole objects is supported).

-#   - Implement Edge Styles (silhouettes, contours, etc.)
+#   - Implement Edge Styles (silhouettes, contours, etc.) (partially done).

 #   - Implement Edge coloring
 #   - Use multiple lighting sources in color calculation
 #   - Implement Edge coloring
 #   - Use multiple lighting sources in color calculation

-#   - Implement Shading Styles?
-#   - Use another representation for the 2D projection? 
+#   - Implement Shading Styles? (for now we use Flat Shading).
+#   - Use a data structure other than Mesh to represent the 2D image? 

 #     Think to a way to merge adjacent polygons that have the same color.
 #     Think to a way to merge adjacent polygons that have the same color.

-#   - Add other Vector Writers.
+#     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? (Firefox do
+#     not support SMIL for animations)
+#   - FIX the issue with negative scales in object tranformations!

 #
 # ---------------------------------------------------------------------
 #
 #
 # ---------------------------------------------------------------------
 #


@@ -75,18 +79,86 @@ from math import *
 
 
 # Some global settings
 
 
 # Some global settings

+

 PRINT_POLYGONS     = True
 PRINT_POLYGONS     = True

+
+POLYGON_EXPANSION_TRICK = True # Hidden to the user for now
+

 PRINT_EDGES        = False
 SHOW_HIDDEN_EDGES  = False
 PRINT_EDGES        = False
 SHOW_HIDDEN_EDGES  = False

-
+EDGE_STYLE = 'silhouette'

 EDGES_WIDTH = 0.5
 
 EDGES_WIDTH = 0.5
 

-POLYGON_EXPANSION_TRICK = True
-

 RENDER_ANIMATION = False
 
 RENDER_ANIMATION = False
 

-# Does not work in batch mode!!
-#OPTIMIZE_FOR_SPACE = True
+OPTIMIZE_FOR_SPACE = True
+
+OUTPUT_FORMAT = 'SVG'
+
+
+
+# ---------------------------------------------------------------------
+#
+## Utility Mesh class
+#
+# ---------------------------------------------------------------------
+class MeshUtils:
+
+    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.
+        """
+        adjface_list = []
+
+        for f in mesh.faces:
+            if (edge.v1 in f.v) and (edge.v2 in f.v):
+                adjface_list.append(f)
+
+        return adjface_list
+
+    def isVisibleEdge(e, mesh):
+        """Normal edge selection rule.
+
+        An edge is visible if _any_ 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
+
+        selected_faces = [f for f in adjacent_faces if f.sel]
+
+        if len(selected_faces) != 0:
+            return True
+        else:
+            return False
+
+    def isSilhouetteEdge(e, mesh):
+        """Silhuette selection rule.
+
+        An edge is a silhuette edge if it is shared by two faces with
+        different selection status or if it is a boundary edge of a selected
+        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)
+            ):
+            return True
+        else:
+            return False
+    
+    getEdgeAdjacentFaces = staticmethod(getEdgeAdjacentFaces)
+    isVisibleEdge = staticmethod(isVisibleEdge)
+    isSilhouetteEdge = staticmethod(isSilhouetteEdge)
+

 
 
 # ---------------------------------------------------------------------
 
 
 # ---------------------------------------------------------------------


@@ -214,9 +286,10 @@ class Projector:
         return m
 
 
         return m
 
 

+

 # ---------------------------------------------------------------------
 #
 # ---------------------------------------------------------------------
 #

-## 2DObject representation class
+## 2D Object representation class

 #
 # ---------------------------------------------------------------------
 
 #
 # ---------------------------------------------------------------------
 


@@ -337,6 +410,7 @@ class SVGVectorWriter(VectorWriter):
         self.file.write("<g id=\"frame%d\" style=\"%s\">\n" %
                 (framenumber, framestyle) )
 
         self.file.write("<g id=\"frame%d\" style=\"%s\">\n" %
                 (framenumber, framestyle) )
 

+

         for obj in Objects:
 
             if(obj.getType() != 'Mesh'):
         for obj in Objects:
 
             if(obj.getType() != 'Mesh'):


@@ -446,7 +520,7 @@ class SVGVectorWriter(VectorWriter):
 
         for face in mesh.faces:
             if not face.sel:
 
         for face in mesh.faces:
             if not face.sel:

-                continue
+               continue

 
             self.file.write("<polygon points=\"")
 
 
             self.file.write("<polygon points=\"")
 


@@ -475,7 +549,14 @@ class SVGVectorWriter(VectorWriter):
             # Convert the color to the #RRGGBB form
             str_col = "#%02X%02X%02X" % (color[0], color[1], color[2])
 
             # Convert the color to the #RRGGBB form
             str_col = "#%02X%02X%02X" % (color[0], color[1], color[2])
 

+            # Handle transparent polygons
+            opacity_string = ""
+            if color[3] != 255:
+                opacity = float(color[3])/255.0
+                opacity_string = " fill-opacity: %g; stroke-opacity: %g; opacity: 1;" % (opacity, opacity)
+

             self.file.write("\tstyle=\"fill:" + str_col + ";")
             self.file.write("\tstyle=\"fill:" + str_col + ";")

+            self.file.write(opacity_string)

             if POLYGON_EXPANSION_TRICK:
                 self.file.write(" stroke:" + str_col + ";")
                 self.file.write(" stroke-width:" + str(stroke_width) + ";\n")
             if POLYGON_EXPANSION_TRICK:
                 self.file.write(" stroke:" + str_col + ";")
                 self.file.write(" stroke-width:" + str(stroke_width) + ";\n")


@@ -497,8 +578,7 @@ class SVGVectorWriter(VectorWriter):
             
             hidden_stroke_style = ""
             
             
             hidden_stroke_style = ""
             

-            # Consider an edge selected if both vertices are selected
-            if e.v1.sel == 0 or e.v2.sel == 0:
+            if e.sel == 0:

                 if showHiddenEdges == False:
                     continue
                 else:
                 if showHiddenEdges == False:
                     continue
                 else:


@@ -525,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.
     
 class Renderer:
     """Render a scene viewed from a given camera.
     


@@ -555,13 +648,22 @@ class Renderer:
         # Render from the currently active camera 
         self.cameraObj = self._SCENE.getCurrentCamera()
 
         # 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']
 
         # 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')
         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)
 
             lobj.link(l) 
             self.lights.append(lobj)
 


@@ -597,7 +699,16 @@ class Renderer:
         for f in range(startFrame, endFrame+1):
             context.currentFrame(f)
 
         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,
             outputWriter.printCanvas(renderedScene,
                     doPrintPolygons = PRINT_POLYGONS,
                     doPrintEdges    = PRINT_EDGES,


@@ -613,31 +724,31 @@ class Renderer:
         context.currentFrame(currentFrame)
 
 
         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.
         """
         
         """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)
 
         self._doSceneClipping(workScene)
 
         # global processing of the scene
 
         self._doConvertGeometricObjToMesh(workScene)
 
         self._doSceneClipping(workScene)
 

-        # FIXME: does not work in batch mode!
-        #if OPTIMIZE_FOR_SPACE:
-        #    self._joinMeshObjectsInScene(workScene)
+
+        # XXX: Joining objects does not work in batch mode!!
+        # Do not touch the following if, please :)
+
+        global OPTIMIZE_FOR_SPACE
+        if Blender.mode == 'background':
+            print "\nWARNING! Joining objects not supported in background mode!\n"
+            OPTIMIZE_FOR_SPACE = False
+
+        if OPTIMIZE_FOR_SPACE:
+            self._joinMeshObjectsInScene(workScene)
+

 
         self._doSceneDepthSorting(workScene)
         
 
         self._doSceneDepthSorting(workScene)
         


@@ -652,21 +763,24 @@ class Renderer:
 
             print "Rendering: ", obj.getName()
 
 
             print "Rendering: ", obj.getName()
 

-            mesh = obj.data
+            mesh = obj.getData()

 
             self._doModelToWorldCoordinates(mesh, obj.matrix)
 
             self._doObjectDepthSorting(mesh)
             
 
             self._doModelToWorldCoordinates(mesh, obj.matrix)
 
             self._doObjectDepthSorting(mesh)
             

+            # We use both Mesh and NMesh because for depth sorting we change
+            # face order and Mesh class don't let us to do that.
+            mesh.update()
+            mesh = obj.getData(mesh=1)
+            

             self._doBackFaceCulling(mesh)
             
             self._doColorAndLighting(mesh)
 
             self._doBackFaceCulling(mesh)
             
             self._doColorAndLighting(mesh)
 

-            # TODO: 'style' can be a function that determine
-            # if an edge should be showed?
-            self._doEdgesStyle(mesh, style=None)
+            self._doEdgesStyle(mesh, edgeSelectionStyles[EDGE_STYLE])

 
 

-            self._doProjection(mesh, proj)
+            self._doProjection(mesh, self.proj)

             
             # Update the object data, important! :)
             mesh.update()
             
             # Update the object data, important! :)
             mesh.update()


@@ -825,11 +939,17 @@ class Renderer:
     def _joinMeshObjectsInScene(self, scene):
         """Merge all the Mesh Objects in a scene into a single Mesh Object.
         """
     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)
 
         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:
         bigObj.join(oList)
         scene.link(bigObj)
         for o in oList:


@@ -864,6 +984,11 @@ class Renderer:
         This step is done simply applying to the object its tranformation
         matrix and recalculating its normals.
         """
         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):
         mesh.transform(matrix, True)
 
     def _doObjectDepthSorting(self, mesh):


@@ -916,14 +1041,14 @@ class Renderer:
         # Is this the correct way to propagate the face selection info to the
         # vertices belonging to a face ??
         # TODO: Using the Mesh module this should come for free. Right?
         # Is this the correct way to propagate the face selection info to the
         # vertices belonging to a face ??
         # TODO: Using the Mesh module this should come for free. Right?

-        Mesh.Mode(Mesh.SelectModes['VERTEX'])
-        for f in mesh.faces:
-            if not f.sel:
-                for v in f: v.sel = 0;
+        #Mesh.Mode(Mesh.SelectModes['VERTEX'])
+        #for f in mesh.faces:
+        #    if not f.sel:
+        #        for v in f: v.sel = 0;

 
 

-        for f in mesh.faces:
-            if f.sel:
-                for v in f: v.sel = 1;
+        #for f in mesh.faces:
+        #    if f.sel:
+        #        for v in f: v.sel = 1;

 
     def _doColorAndLighting(self, mesh):
         """Apply an Illumination model to the object.
 
     def _doColorAndLighting(self, mesh):
         """Apply an Illumination model to the object.


@@ -935,9 +1060,9 @@ class Renderer:
 
         # If the mesh has vertex colors already, use them,
         # otherwise turn them on and do some calculations
 
         # If the mesh has vertex colors already, use them,
         # otherwise turn them on and do some calculations

-        if mesh.hasVertexColours():
+        if mesh.vertexColors:

             return
             return

-        mesh.hasVertexColours(True)
+        mesh.vertexColors = 1

 
         materials = mesh.materials
         
 
         materials = mesh.materials
         


@@ -997,18 +1122,23 @@ class Renderer:
 
             I = ki + Iamb + Idiff + Ispec
 
 
             I = ki + Iamb + Idiff + Ispec
 

+            # Set Alpha component
+            I = list(I)
+            I.append(mat.getAlpha())
+

             # Clamp I values between 0 and 1
             I = [ min(c, 1) for c in I]
             I = [ max(0, c) for c in I]
             tmp_col = [ int(c * 255.0) 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]
             tmp_col = [ int(c * 255.0) for c in I]
 

-            vcol = NMesh.Col(tmp_col[0], tmp_col[1], tmp_col[2], 255)
-            f.col = []
-            for v in f.v:
-                f.col.append(vcol)
+            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]

 
 

-    def _doEdgesStyle(self, mesh, style):
-        """Process Mesh Edges.
+    def _doEdgesStyle(self, mesh, edgestyleSelect):
+        """Process Mesh Edges accroding to a given selection style.

 
         Examples of algorithms:
 
 
         Examples of algorithms:
 


@@ -1020,9 +1150,15 @@ class Renderer:
             given an edge if one its adjacent faces is frontfacing and the
             other is backfacing, than select it, else deselect.
         """
             given an edge if one its adjacent faces is frontfacing and the
             other is backfacing, than select it, else deselect.
         """

-        #print "\tTODO: _doEdgeStyle()"
-        return

 
 

+        Mesh.Mode(Mesh.SelectModes['EDGE'])
+
+        for e in mesh.edges:
+
+            e.sel = 0
+            if edgestyleSelect(e, mesh):
+                e.sel = 1
+                

     def _doProjection(self, mesh, projector):
         """Calculate the Projection for the object.
         """
     def _doProjection(self, mesh, projector):
         """Calculate the Projection for the object.
         """


@@ -1038,44 +1174,238 @@ class Renderer:
 
 # ---------------------------------------------------------------------
 #
 
 # ---------------------------------------------------------------------
 #

-## Main Program
+## GUI Class and Main Program

 #
 # ---------------------------------------------------------------------
 
 #
 # ---------------------------------------------------------------------
 

+
+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):
     """The vectorizing process is as follows:
      
      - Instanciate the writer and the renderer
      - Render!
      """
 def vectorize(filename):
     """The vectorizing process is as follows:
      
      - 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)
 
     from Blender import Window
     editmode = Window.EditMode()
     if editmode: Window.EditMode(0)
 

-    writer = SVGVectorWriter(filename)
+    actualWriter = outputWriters[OUTPUT_FORMAT]
+    writer = actualWriter(filename)

     
     renderer = Renderer()
     renderer.doRendering(writer, RENDER_ANIMATION)
 
     if editmode: Window.EditMode(1) 
 
     
     renderer = Renderer()
     renderer.doRendering(writer, RENDER_ANIMATION)
 
     if editmode: Window.EditMode(1) 
 

-def vectorize_gui(filename):
-    """Draw the gui.
-
-    I would like to keep that simple, really.
-    """
-    Blender.Window.FileSelector (vectorize, 'Save SVG', filename)
-    Blender.Redraw()
-

 
 # Here the main
 if __name__ == "__main__":
     
 
 # Here the main
 if __name__ == "__main__":
     

+    outputfile = ""

     basename = Blender.sys.basename(Blender.Get('filename'))
     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()

 
 

-    # with this trick we can run the script in batch mode
-    try:
-        vectorize_gui(outputfile)
-    except:
+    if Blender.mode == 'background':

         vectorize(outputfile)
         vectorize(outputfile)

+    else:
+        Draw.Register(GUI.draw, GUI.event, GUI.button_event)