Do Depth Sorting later

[vrm.git] / vrm.py

diff --git a/vrm.py b/vrm.py
index 35df00c..0d35415 100755 (executable)
--- a/vrm.py
+++ b/vrm.py
@@ -1,7 +1,7 @@
 #!BPY
 """
 Name: 'VRM'
 #!BPY
 """
 Name: 'VRM'

-Blender: 241
+Blender: 242

 Group: 'Render'
 Tooltip: 'Vector Rendering Method script'
 """
 Group: 'Render'
 Tooltip: 'Vector Rendering Method script'
 """


@@ -50,7 +50,6 @@ __bpydoc__ = """\
 #   - Implement clipping of primitives and do handle object intersections.
 #     (for now only clipping for whole objects is supported).
 #   - Implement Edge Styles (silhouettes, contours, etc.) (partially done).
 #   - Implement clipping of primitives and do handle object intersections.
 #     (for now only clipping for whole objects is supported).
 #   - Implement Edge Styles (silhouettes, contours, etc.) (partially done).

-#   - Implement Edge coloring

 #   - Use multiple lighting sources in color calculation
 #   - Implement Shading Styles? (for now we use Flat Shading).
 #   - Use a data structure other than Mesh to represent the 2D image? 
 #   - Use multiple lighting sources in color calculation
 #   - Implement Shading Styles? (for now we use Flat Shading).
 #   - Use a data structure other than Mesh to represent the 2D image? 


@@ -80,20 +79,24 @@ from math import *
 
 # Some global settings
 
 
 # Some global settings
 

-PRINT_POLYGONS     = True
+class config:
+    polygons = dict()
+    polygons['SHOW'] = True
+    polygons['SHADING'] = 'TOON'
+    # Hidden to the user for now
+    polygons['EXPANSION_TRICK'] = True

 
 

-POLYGON_EXPANSION_TRICK = True # Hidden to the user for now
+    edges = dict()
+    edges['SHOW'] = True
+    edges['SHOW_HIDDEN'] = False
+    edges['STYLE'] = 'SILHOUETTE'
+    edges['WIDTH'] = 2
+    edges['COLOR'] = [0, 0, 0]

 
 

-PRINT_EDGES        = False
-SHOW_HIDDEN_EDGES  = False
-EDGE_STYLE = 'silhouette'
-EDGES_WIDTH = 0.5
-
-RENDER_ANIMATION = False
-
-OPTIMIZE_FOR_SPACE = True
-
-OUTPUT_FORMAT = 'SVG'
+    output = dict()
+    output['FORMAT'] = 'SVG'
+    output['ANIMATION'] = False
+    output['JOIN_OBJECTS'] = True

 
 
 
 
 
 


@@ -117,10 +120,10 @@ class MeshUtils:
 
         return adjface_list
 
 
         return adjface_list
 

-    def isVisibleEdge(e, mesh):
-        """Normal edge selection rule.
+    def isMeshEdge(e, mesh):
+        """Mesh edge rule.

 
 

-        An edge is visible if _any_ of its adjacent faces is selected.
+        A mesh 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.
         """
         Note: if the edge has no adjacent faces we want to show it as well,
         useful for "edge only" portion of objects.
         """


@@ -155,9 +158,29 @@ class MeshUtils:
         else:
             return False
     
         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<map[i+1]:
+                return v
+
+        return v
+
+

     getEdgeAdjacentFaces = staticmethod(getEdgeAdjacentFaces)
     getEdgeAdjacentFaces = staticmethod(getEdgeAdjacentFaces)

-    isVisibleEdge = staticmethod(isVisibleEdge)
+    isMeshEdge = staticmethod(isMeshEdge)

     isSilhouetteEdge = staticmethod(isSilhouetteEdge)
     isSilhouetteEdge = staticmethod(isSilhouetteEdge)

+    toonShading = staticmethod(toonShading)

 
 
 
 
 
 


@@ -234,6 +257,7 @@ class Projector:
 
         return p
 
 
         return p
 

+

     ##
     # Private methods
     #
     ##
     # Private methods
     #


@@ -509,7 +533,7 @@ class SVGVectorWriter(VectorWriter):
 
         self.file.write("\n</svg>\n")
 
 
         self.file.write("\n</svg>\n")
 

-    def _printPolygons(self, mesh):
+    def _printPolygons(self, mesh): 

         """Print the selected (visible) polygons.
         """
 
         """Print the selected (visible) polygons.
         """
 


@@ -540,15 +564,14 @@ class SVGVectorWriter(VectorWriter):
             else:
                 color = [255, 255, 255, 255]
 
             else:
                 color = [255, 255, 255, 255]
 

+            # Convert the color to the #RRGGBB form
+            str_col = "#%02X%02X%02X" % (color[0], color[1], color[2])
+

             # 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
             # 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_col = color

             stroke_width = 0.5
 
             stroke_width = 0.5
 

-            # 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:
             # Handle transparent polygons
             opacity_string = ""
             if color[3] != 255:


@@ -557,7 +580,7 @@ class SVGVectorWriter(VectorWriter):
 
             self.file.write("\tstyle=\"fill:" + str_col + ";")
             self.file.write(opacity_string)
 
             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")
                 self.file.write(" stroke:" + str_col + ";")
                 self.file.write(" stroke-width:" + str(stroke_width) + ";\n")
                 self.file.write(" stroke-linecap:round;stroke-linejoin:round")


@@ -569,8 +592,8 @@ class SVGVectorWriter(VectorWriter):
         """Print the wireframe using mesh edges.
         """
 
         """Print the wireframe using mesh edges.
         """
 

-        stroke_width=EDGES_WIDTH
-        stroke_col = [0, 0, 0]
+        stroke_width = config.edges['WIDTH']
+        stroke_col = config.edges['COLOR']

         
         self.file.write("<g>\n")
 
         
         self.file.write("<g>\n")
 


@@ -605,17 +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 different shading style methods
+shadingStyles = dict()
+shadingStyles['FLAT'] = None
+shadingStyles['TOON'] = None
+
+# A dictionary to collect different edge style methods
+edgeStyles = dict()
+edgeStyles['MESH'] = MeshUtils.isMeshEdge
+edgeStyles['SILHOUETTE'] = MeshUtils.isSilhouetteEdge

 
 # A dictionary to collect the supported output formats
 
 # A dictionary to collect the supported output formats

-outputWriters = {
-        'SVG': SVGVectorWriter,
-        }
+outputWriters = dict()
+outputWriters['SVG'] = SVGVectorWriter

 
 
 class Renderer:
 
 
 class Renderer:


@@ -682,11 +707,11 @@ class Renderer:
         """
         
         context = self._SCENE.getRenderingContext()
         """
         
         context = self._SCENE.getRenderingContext()

-        currentFrame = context.currentFrame()
+        origCurrentFrame = context.currentFrame()

 
         # Handle the animation case
         if not animation:
 
         # Handle the animation case
         if not animation:

-            startFrame = currentFrame
+            startFrame = origCurrentFrame

             endFrame = startFrame
             outputWriter.open()
         else:
             endFrame = startFrame
             outputWriter.open()
         else:


@@ -701,18 +726,23 @@ class Renderer:
 
             # Use some temporary workspace, a full copy of the scene
             inputScene = self._SCENE.copy(2)
 
             # Use some temporary workspace, a full copy of the scene
             inputScene = self._SCENE.copy(2)

-            
+

             try:
                 renderedScene = self.doRenderScene(inputScene)
             try:
                 renderedScene = self.doRenderScene(inputScene)

-            except:
+            except :
+                print "There was an error! Aborting."
+                import traceback
+                print traceback.print_exc()
+

                 self._SCENE.makeCurrent()
                 Scene.unlink(inputScene)
                 del inputScene
                 self._SCENE.makeCurrent()
                 Scene.unlink(inputScene)
                 del inputScene

+                return

 
             outputWriter.printCanvas(renderedScene,
 
             outputWriter.printCanvas(renderedScene,

-                    doPrintPolygons = PRINT_POLYGONS,
-                    doPrintEdges    = PRINT_EDGES,
-                    showHiddenEdges = SHOW_HIDDEN_EDGES)
+                    doPrintPolygons = config.polygons['SHOW'],
+                    doPrintEdges    = config.edges['SHOW'],
+                    showHiddenEdges = config.edges['SHOW_HIDDEN'])

             
             # clear the rendered scene
             self._SCENE.makeCurrent()
             
             # clear the rendered scene
             self._SCENE.makeCurrent()


@@ -721,7 +751,7 @@ class Renderer:
 
         outputWriter.close()
         print "Done!"
 
         outputWriter.close()
         print "Done!"

-        context.currentFrame(currentFrame)
+        context.currentFrame(origCurrentFrame)

 
 
     def doRenderScene(self, workScene):
 
 
     def doRenderScene(self, workScene):


@@ -735,27 +765,18 @@ class Renderer:
 
         self._doConvertGeometricObjToMesh(workScene)
 
 
         self._doConvertGeometricObjToMesh(workScene)
 

-        self._doSceneClipping(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
+        #self._doSceneClipping(workScene)

 
 

-        if OPTIMIZE_FOR_SPACE:
+        if config.output['JOIN_OBJECTS']:

             self._joinMeshObjectsInScene(workScene)
 
             self._joinMeshObjectsInScene(workScene)
 

-

         self._doSceneDepthSorting(workScene)
         
         # Per object activities
 
         Objects = workScene.getChildren()
         for obj in Objects:
         self._doSceneDepthSorting(workScene)
         
         # Per object activities
 
         Objects = workScene.getChildren()
         for obj in Objects:

+

             
             if obj.getType() != 'Mesh':
                 print "Only Mesh supported! - Skipping type:", obj.getType()
             
             if obj.getType() != 'Mesh':
                 print "Only Mesh supported! - Skipping type:", obj.getType()


@@ -763,22 +784,17 @@ class Renderer:
 
             print "Rendering: ", obj.getName()
 
 
             print "Rendering: ", obj.getName()
 

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

 
             self._doModelToWorldCoordinates(mesh, obj.matrix)
 
 
             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._doBackFaceCulling(mesh)
             

+            self._doObjectDepthSorting(mesh)
+            

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

-            self._doEdgesStyle(mesh, edgeSelectionStyles[EDGE_STYLE])
+            self._doEdgesStyle(mesh, edgeStyles[config.edges['STYLE']])

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


@@ -880,7 +896,6 @@ class Renderer:
                 me.recalcNormals()
                 me.update()
 
                 me.recalcNormals()
                 me.update()
 

-

     def _doSceneClipping(self, scene):
         """Clip objects against the View Frustum.
 
     def _doSceneClipping(self, scene):
         """Clip objects against the View Frustum.
 


@@ -940,18 +955,31 @@ class Renderer:
         """Merge all the Mesh Objects in a scene into a single Mesh Object.
         """
 
         """Merge all the Mesh Objects in a scene into a single Mesh Object.
         """
 

+        if Blender.mode == 'background':
+            print "\nWARNING! Joining objects not supported in background mode!\n"
+            return
+

         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
 
         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()
+        mesh = Mesh.New('BigOne')

         bigObj = Object.New('Mesh', 'BigOne')
         bigObj.link(mesh)
 
         bigObj = Object.New('Mesh', 'BigOne')
         bigObj.link(mesh)
 

-        bigObj.join(oList)

         scene.link(bigObj)
         scene.link(bigObj)

+
+        try:
+            bigObj.join(oList)
+        except RuntimeError:
+            print "Can't Join Objects"
+            scene.unlink(bigObj)
+            return
+        except TypeError:
+            print "Objects Type error?"
+        

         for o in oList:
             scene.unlink(o)
 
         for o in oList:
             scene.unlink(o)
 


@@ -997,6 +1025,9 @@ class Renderer:
         The faces in the object are sorted following the distance of the
         vertices from the camera position.
         """
         The faces in the object are sorted following the distance of the
         vertices from the camera position.
         """

+        if len(mesh.faces) == 0:
+            return
+

         c = self._getObjPosition(self.cameraObj)
 
         # hackish sorting of faces
         c = self._getObjPosition(self.cameraObj)
 
         # hackish sorting of faces


@@ -1016,8 +1047,27 @@ class Renderer:
                 cmp(sum([(Vector(v.co)-Vector(c)).length for v in f1])/len(f1),
                     sum([(Vector(v.co)-Vector(c)).length for v in f2])/len(f2)))
 
                 cmp(sum([(Vector(v.co)-Vector(c)).length for v in f1])/len(f1),
                     sum([(Vector(v.co)-Vector(c)).length for v in f2])/len(f2)))
 

-        mesh.faces.sort(by_max_vert_dist)
-        mesh.faces.reverse()
+
+        # FIXME: using NMesh to sort faces. We should avoid that!
+        nmesh = NMesh.GetRaw(mesh.name)
+        nmesh.faces.sort(by_max_vert_dist)
+        nmesh.faces.reverse()
+
+        # Get visible faces
+        #vf = nmesh.faces
+        #while len(vf)>1:
+        #    p1 = vf[0]
+        #    insideList = 
+
+        
+        mesh.faces.delete(1, range(0, len(mesh.faces)))
+
+        for i,f in enumerate(nmesh.faces):
+            fv = [v.index for v in f.v] 
+            mesh.faces.extend(fv)
+            mesh.faces[i].mat = f.mat
+            mesh.faces[i].sel = f.sel
+

 
     def _doBackFaceCulling(self, mesh):
         """Simple Backface Culling routine.
 
     def _doBackFaceCulling(self, mesh):
         """Simple Backface Culling routine.


@@ -1038,22 +1088,10 @@ class Renderer:
             if self._isFaceVisible(f):
                 f.sel = 1
 
             if self._isFaceVisible(f):
                 f.sel = 1
 

-        # 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;
-
-        #for f in mesh.faces:
-        #    if f.sel:
-        #        for v in f: v.sel = 1;
-

     def _doColorAndLighting(self, mesh):
     def _doColorAndLighting(self, mesh):

-        """Apply an Illumination model to the object.
+        """Apply an Illumination ans shading model to the object.

 
 

-        The Illumination model used is the Phong one, it may be inefficient,
+        The model used is the Phong one, it may be inefficient,

         but I'm just learning about rendering and starting from Phong seemed
         the most natural way.
         """
         but I'm just learning about rendering and starting from Phong seemed
         the most natural way.
         """


@@ -1091,16 +1129,16 @@ class Renderer:
             
             L = Vector(light_pos).normalize()
 
             
             L = Vector(light_pos).normalize()
 

-            V = (Vector(camPos) - Vector(f.v[0].co)).normalize()
+            V = (Vector(camPos) - Vector(f.cent)).normalize()

 
             N = Vector(f.no).normalize()
 
             R = 2 * (N*L) * N - L
 
             # TODO: Attenuation factor (not used for now)
 
             N = Vector(f.no).normalize()
 
             R = 2 * (N*L) * N - L
 
             # TODO: Attenuation factor (not used for now)

-            a0 = 1; a1 = 0.0; a2 = 0.0
+            a0 = 1.0; a1 = 0.0; a2 = 1.0

             d = (Vector(f.v[0].co) - Vector(light_pos)).length
             d = (Vector(f.v[0].co) - Vector(light_pos)).length

-            fd = min(1, 1.0/(a0 + a1*d + a2*d*d))
+            fd = min(1, 1.0/(a0 + a1*d + a2*(d*d)))

 
             # Ambient component
             Ia = 1.0
 
             # Ambient component
             Ia = 1.0


@@ -1110,17 +1148,22 @@ class Renderer:
             # Diffuse component (add light.col for kd)
             kd = mat.getRef() * Vector(mat.getRGBCol())
             Ip = light.getEnergy()
             # Diffuse component (add light.col for kd)
             kd = mat.getRef() * Vector(mat.getRGBCol())
             Ip = light.getEnergy()

-            Idiff = Ip * kd * (N*L)

             
             

+            if config.polygons['SHADING'] == 'FLAT':
+                Idiff = Ip * kd * (N*L)
+            elif config.polygons['SHADING'] == 'TOON':
+                Idiff = Ip * kd * MeshUtils.toonShading(N*L)
+

             # Specular component
             ks = mat.getSpec() * Vector(mat.getSpecCol())
             ns = mat.getHardness()
             # 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)
 
 
             # Emissive component
             ki = Vector([mat.getEmit()]*3)
 

-            I = ki + Iamb + Idiff + Ispec
+            I = ki + Iamb + (Idiff + Ispec)
+

 
             # Set Alpha component
             I = list(I)
 
             # Set Alpha component
             I = list(I)


@@ -1129,6 +1172,8 @@ class Renderer:
             # Clamp I values between 0 and 1
             I = [ min(c, 1) for c in I]
             I = [ max(0, 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]

+
+            # Convert to a value between 0 and 255

             tmp_col = [ int(c * 255.0) for c in I]
 
             for c in f.col:
             tmp_col = [ int(c * 255.0) for c in I]
 
             for c in f.col:


@@ -1187,40 +1232,54 @@ class GUI:
     def _init():
 
         # Output Format menu 
     def _init():
 
         # Output Format menu 

-        default_value = outputWriters.keys().index(OUTPUT_FORMAT)+1
+        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.outFormatMenu = Draw.Create(default_value)
         GUI.evtOutFormatMenu = 0
 
         # Animation toggle button

-        GUI.animToggle = Draw.Create(RENDER_ANIMATION)
+        GUI.animToggle = Draw.Create(config.output['ANIMATION'])

         GUI.evtAnimToggle = 1
 
         # Join Objects toggle button
         GUI.evtAnimToggle = 1
 
         # Join Objects toggle button

-        GUI.joinObjsToggle = Draw.Create(OPTIMIZE_FOR_SPACE)
+        GUI.joinObjsToggle = Draw.Create(config.output['JOIN_OBJECTS'])

         GUI.evtJoinObjsToggle = 2
 
         # Render filled polygons
         GUI.evtJoinObjsToggle = 2
 
         # Render filled polygons

-        GUI.polygonsToggle = Draw.Create(PRINT_POLYGONS)
+        GUI.polygonsToggle = Draw.Create(config.polygons['SHOW'])
+
+        # Shading Style menu 
+        shading_style = config.polygons['SHADING']
+        default_value = shadingStyles.keys().index(shading_style)+1
+        GUI.shadingStyleMenu = Draw.Create(default_value)
+        GUI.evtShadingStyleMenu = 21
+

         GUI.evtPolygonsToggle = 3
         GUI.evtPolygonsToggle = 3

-        # We hide the POLYGON_EXPANSION_TRICK, for now
+        # We hide the config.polygons['EXPANSION_TRICK'], for now

 
         # Render polygon edges
 
         # Render polygon edges

-        GUI.showEdgesToggle = Draw.Create(PRINT_EDGES)
+        GUI.showEdgesToggle = Draw.Create(config.edges['SHOW'])

         GUI.evtShowEdgesToggle = 4
 
         # Render hidden edges
         GUI.evtShowEdgesToggle = 4
 
         # Render hidden edges

-        GUI.showHiddenEdgesToggle = Draw.Create(SHOW_HIDDEN_EDGES)
+        GUI.showHiddenEdgesToggle = Draw.Create(config.edges['SHOW_HIDDEN'])

         GUI.evtShowHiddenEdgesToggle = 5
 
         # Edge Style menu 
         GUI.evtShowHiddenEdgesToggle = 5
 
         # Edge Style menu 

-        default_value = edgeSelectionStyles.keys().index(EDGE_STYLE)+1
+        edge_style = config.edges['STYLE']
+        default_value = edgeStyles.keys().index(edge_style)+1

         GUI.edgeStyleMenu = Draw.Create(default_value)
         GUI.evtEdgeStyleMenu = 6
 
         # Edge Width slider
         GUI.edgeStyleMenu = Draw.Create(default_value)
         GUI.evtEdgeStyleMenu = 6
 
         # Edge Width slider

-        GUI.edgeWidthSlider = Draw.Create(EDGES_WIDTH)
+        GUI.edgeWidthSlider = Draw.Create(config.edges['WIDTH'])

         GUI.evtEdgeWidthSlider = 7
 
         GUI.evtEdgeWidthSlider = 7
 

+        # Edge Color Picker
+        c = config.edges['COLOR']
+        GUI.edgeColorPicker = Draw.Create(c[0]/255.0, c[1]/255.0, c[2]/255.0)
+        GUI.evtEdgeColorPicker = 71
+

         # Render Button
         GUI.evtRenderButton = 8
 
         # Render Button
         GUI.evtRenderButton = 8
 


@@ -1272,30 +1331,45 @@ class GUI:
                 200, 285, 160, 18, GUI.polygonsToggle.val,
                 "Render filled polygons")
 
                 200, 285, 160, 18, GUI.polygonsToggle.val,
                 "Render filled polygons")
 

+        if GUI.polygonsToggle.val == 1:
+
+            # Polygon Shading Style
+            shadingStyleMenuStruct = "Shading Style %t"
+            for t in shadingStyles.keys():
+                shadingStyleMenuStruct = shadingStyleMenuStruct + "|%s" % t.lower()
+            GUI.shadingStyleMenu = Draw.Menu(shadingStyleMenuStruct, GUI.evtShadingStyleMenu,
+                    200, 260, 160, 18, GUI.shadingStyleMenu.val,
+                    "Choose the shading style")
+
+

         # Render Edges
         GUI.showEdgesToggle = Draw.Toggle("Show Edges", GUI.evtShowEdgesToggle,
         # Render Edges
         GUI.showEdgesToggle = Draw.Toggle("Show Edges", GUI.evtShowEdgesToggle,

-                200, 260, 160, 18, GUI.showEdgesToggle.val,
+                200, 235, 160, 18, GUI.showEdgesToggle.val,

                 "Render polygon edges")
 
         if GUI.showEdgesToggle.val == 1:
             
             # Edge Style
             edgeStyleMenuStruct = "Edge Style %t"
                 "Render polygon edges")
 
         if GUI.showEdgesToggle.val == 1:
             
             # Edge Style
             edgeStyleMenuStruct = "Edge Style %t"

-            for t in edgeSelectionStyles.keys():
-               edgeStyleMenuStruct = edgeStyleMenuStruct + "|%s" % t
+            for t in edgeStyles.keys():
+                edgeStyleMenuStruct = edgeStyleMenuStruct + "|%s" % t.lower()

             GUI.edgeStyleMenu = Draw.Menu(edgeStyleMenuStruct, GUI.evtEdgeStyleMenu,
             GUI.edgeStyleMenu = Draw.Menu(edgeStyleMenuStruct, GUI.evtEdgeStyleMenu,

-                    200, 235, 160, 18, GUI.edgeStyleMenu.val,
+                    200, 210, 160, 18, GUI.edgeStyleMenu.val,

                     "Choose the edge style")
 
             # Edge size
             GUI.edgeWidthSlider = Draw.Slider("Width: ", GUI.evtEdgeWidthSlider,
                     "Choose the edge style")
 
             # Edge size
             GUI.edgeWidthSlider = Draw.Slider("Width: ", GUI.evtEdgeWidthSlider,

-                    200, 210, 160, 18, GUI.edgeWidthSlider.val,
+                    200, 185, 140, 18, GUI.edgeWidthSlider.val,

                     0.0, 10.0, 0, "Change Edge Width")
 
                     0.0, 10.0, 0, "Change Edge Width")
 

+            # Edge Color
+            GUI.edgeColorPicker = Draw.ColorPicker(GUI.evtEdgeColorPicker,
+                    342, 185, 18, 18, GUI.edgeColorPicker.val, "Choose Edge Color")
+

             # Show Hidden Edges
             GUI.showHiddenEdgesToggle = Draw.Toggle("Show Hidden Edges",
                     GUI.evtShowHiddenEdgesToggle,
             # Show Hidden Edges
             GUI.showHiddenEdgesToggle = Draw.Toggle("Show Hidden Edges",
                     GUI.evtShowHiddenEdgesToggle,

-                    200, 185, 160, 18, GUI.showHiddenEdgesToggle.val,
+                    200, 160, 160, 18, GUI.showHiddenEdgesToggle.val,

                     "Render hidden edges as dashed lines")
 
         glRasterPos2i(10, 160)
                     "Render hidden edges as dashed lines")
 
         glRasterPos2i(10, 160)


@@ -1311,38 +1385,45 @@ class GUI:
         Draw.Redraw(1)
 
     def button_event(evt):
         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()
 
         if evt == GUI.evtExitButton:
             Draw.Exit()

+

         elif evt == GUI.evtOutFormatMenu:
             i = GUI.outFormatMenu.val - 1
         elif evt == GUI.evtOutFormatMenu:
             i = GUI.outFormatMenu.val - 1

-            OUTPUT_FORMAT = outputWriters.keys()[i]
+            config.output['FORMAT']= outputWriters.keys()[i]
+

         elif evt == GUI.evtAnimToggle:
         elif evt == GUI.evtAnimToggle:

-            RENDER_ANIMATION = bool(GUI.animToggle.val)
+            config.outpur['ANIMATION'] = bool(GUI.animToggle.val)
+

         elif evt == GUI.evtJoinObjsToggle:
         elif evt == GUI.evtJoinObjsToggle:

-            OPTIMIZE_FOR_SPACE = bool(GUI.joinObjsToggle.val)
+            config.output['JOIN_OBJECTS'] = bool(GUI.joinObjsToggle.val)
+

         elif evt == GUI.evtPolygonsToggle:
         elif evt == GUI.evtPolygonsToggle:

-            PRINT_POLYGONS = bool(GUI.polygonsToggle.val)
+            config.polygons['SHOW'] = bool(GUI.polygonsToggle.val)
+
+        elif evt == GUI.evtShadingStyleMenu:
+            i = GUI.shadingStyleMenu.val - 1
+            config.polygons['SHADING'] = shadingStyles.keys()[i]
+

         elif evt == GUI.evtShowEdgesToggle:
         elif evt == GUI.evtShowEdgesToggle:

-            PRINT_EDGES = bool(GUI.showEdgesToggle.val)
+            config.edges['SHOW'] = bool(GUI.showEdgesToggle.val)
+

         elif evt == GUI.evtShowHiddenEdgesToggle:
         elif evt == GUI.evtShowHiddenEdgesToggle:

-            SHOW_HIDDEN_EDGES = bool(GUI.showHiddenEdgesToggle.val)
+            config.edges['SHOW_HIDDEN'] = bool(GUI.showHiddenEdgesToggle.val)
+

         elif evt == GUI.evtEdgeStyleMenu:
             i = GUI.edgeStyleMenu.val - 1
         elif evt == GUI.evtEdgeStyleMenu:
             i = GUI.edgeStyleMenu.val - 1

-            EDGE_STYLE = edgeSelectionStyles.keys()[i]
+            config.edges['STYLE'] = edgeStyles.keys()[i]
+

         elif evt == GUI.evtEdgeWidthSlider:
         elif evt == GUI.evtEdgeWidthSlider:

-            EDGES_WIDTH = float(GUI.edgeWidthSlider.val)
+            config.edges['WIDTH'] = float(GUI.edgeWidthSlider.val)
+
+        elif evt == GUI.evtEdgeColorPicker:
+            config.edges['COLOR'] = [int(c*255.0) for c in GUI.edgeColorPicker.val]
+

         elif evt == GUI.evtRenderButton:
         elif evt == GUI.evtRenderButton:

-            label = "Save %s" % OUTPUT_FORMAT
+            label = "Save %s" % config.output['FORMAT']

             # Show the File Selector
             global outputfile
             Blender.Window.FileSelector(vectorize, label, outputfile)
             # Show the File Selector
             global outputfile
             Blender.Window.FileSelector(vectorize, label, outputfile)


@@ -1352,19 +1433,14 @@ class GUI:
 
         if evt:
             Draw.Redraw(1)
 
         if evt:
             Draw.Redraw(1)

-            #GUI.conf_debug()
+            GUI.conf_debug()

 
     def 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
+        from pprint import pprint
+        print "\nConfig"
+        pprint(config.output)
+        pprint(config.polygons)
+        pprint(config.edges)

 
     _init = staticmethod(_init)
     draw = staticmethod(draw)
 
     _init = staticmethod(_init)
     draw = staticmethod(draw)


@@ -1388,11 +1464,11 @@ def vectorize(filename):
     editmode = Window.EditMode()
     if editmode: Window.EditMode(0)
 
     editmode = Window.EditMode()
     if editmode: Window.EditMode(0)
 

-    actualWriter = outputWriters[OUTPUT_FORMAT]
+    actualWriter = outputWriters[config.output['FORMAT']]

     writer = actualWriter(filename)
     
     renderer = Renderer()
     writer = actualWriter(filename)
     
     renderer = Renderer()

-    renderer.doRendering(writer, RENDER_ANIMATION)
+    renderer.doRendering(writer, config.output['ANIMATION'])

 
     if editmode: Window.EditMode(1) 
 
 
     if editmode: Window.EditMode(1) 
 


@@ -1403,7 +1479,7 @@ if __name__ == "__main__":
     outputfile = ""
     basename = Blender.sys.basename(Blender.Get('filename'))
     if basename != "":
     outputfile = ""
     basename = Blender.sys.basename(Blender.Get('filename'))
     if basename != "":

-        outputfile = Blender.sys.splitext(basename)[0] + "." + str(OUTPUT_FORMAT).lower()
+        outputfile = Blender.sys.splitext(basename)[0] + "." + str(config.output['FORMAT']).lower()

 
     if Blender.mode == 'background':
         vectorize(outputfile)
 
     if Blender.mode == 'background':
         vectorize(outputfile)