Warn about negative scales
[vrm.git] / vrm.py
diff --git a/vrm.py b/vrm.py
index 69099c4..35df00c 100755 (executable)
--- a/vrm.py
+++ b/vrm.py
@@ -2,12 +2,12 @@
 """
 Name: 'VRM'
 Blender: 241
-Group: 'Export'
-Tooltip: 'Vector Rendering Method Export Script'
+Group: 'Render'
+Tooltip: 'Vector Rendering Method script'
 """
 
 __author__ = "Antonio Ospite"
-__url__ = ["blender"]
+__url__ = ["http://vrm.projects.blender.org"]
 __version__ = "0.3"
 
 __bpydoc__ = """\
@@ -43,18 +43,23 @@ __bpydoc__ = """\
 # 
 # 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 and do handle object intersections
-#   - Implement Edge Styles (silhouettes, contours, etc.)
+#   - 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?
-#   - 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.
-#   - 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!
 #
 # ---------------------------------------------------------------------
 #
@@ -74,18 +79,86 @@ from math import *
 
 
 # Some global settings
+
 PRINT_POLYGONS     = True
+
+POLYGON_EXPANSION_TRICK = True # Hidden to the user for now
+
 PRINT_EDGES        = False
 SHOW_HIDDEN_EDGES  = False
-
+EDGE_STYLE = 'silhouette'
 EDGES_WIDTH = 0.5
 
-POLYGON_EXPANSION_TRICK = True
-
 RENDER_ANIMATION = False
 
-# Do not work for now!
-OPTIMIZE_FOR_SPACE = False
+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)
+
 
 
 # ---------------------------------------------------------------------
@@ -129,7 +202,6 @@ class Projector:
         else:
             mP = self._calcPerspectiveMatrix(fovy, aspect, near, far) 
         
-
         # View transformation
         cam = Matrix(cameraObj.getInverseMatrix())
         cam.transpose() 
@@ -214,9 +286,10 @@ class Projector:
         return m
 
 
+
 # ---------------------------------------------------------------------
 #
-## 2DObject representation class
+## 2D Object representation class
 #
 # ---------------------------------------------------------------------
 
@@ -293,10 +366,10 @@ class SVGVectorWriter(VectorWriter):
     """A concrete class for writing SVG output.
     """
 
-    def __init__(self, file):
+    def __init__(self, fileName):
         """Simply call the parent Contructor.
         """
-        VectorWriter.__init__(self, file)
+        VectorWriter.__init__(self, fileName)
 
 
     ##
@@ -314,6 +387,9 @@ class SVGVectorWriter(VectorWriter):
         """
         self._printFooter()
 
+        # remember to call the close method of the parent
+        VectorWriter.close(self)
+
         
     def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
             showHiddenEdges=False):
@@ -334,6 +410,7 @@ class SVGVectorWriter(VectorWriter):
         self.file.write("<g id=\"frame%d\" style=\"%s\">\n" %
                 (framenumber, framestyle) )
 
+
         for obj in Objects:
 
             if(obj.getType() != 'Mesh'):
@@ -443,7 +520,7 @@ class SVGVectorWriter(VectorWriter):
 
         for face in mesh.faces:
             if not face.sel:
-                continue
+               continue
 
             self.file.write("<polygon points=\"")
 
@@ -459,9 +536,9 @@ class SVGVectorWriter(VectorWriter):
             # TODO: the average of vetrex colors?
             if face.col:
                 fcol = face.col[0]
-                color = [fcol.r, fcol.g, fcol.b]
+                color = [fcol.r, fcol.g, fcol.b, fcol.a]
             else:
-                color = [255, 255, 255]
+                color = [255, 255, 255, 255]
 
             # use the stroke property to alleviate the "adjacent edges" problem,
             # we simulate polygon expansion using borders,
@@ -469,10 +546,20 @@ class SVGVectorWriter(VectorWriter):
             stroke_col = color
             stroke_width = 0.5
 
-            self.file.write("\tstyle=\"fill:rgb("+str(color[0])+","+str(color[1])+","+str(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(opacity_string)
             if POLYGON_EXPANSION_TRICK:
-                self.file.write(" stroke:rgb("+str(stroke_col[0])+","+str(stroke_col[1])+","+str(stroke_col[2])+");")
-                self.file.write(" stroke-width:"+str(stroke_width)+";\n")
+                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("\"/>\n")
 
@@ -491,8 +578,7 @@ class SVGVectorWriter(VectorWriter):
             
             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:
@@ -519,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.
     
@@ -549,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)
 
@@ -568,7 +676,7 @@ class Renderer:
         """Render picture or animation and write it out.
         
         The parameters are:
-            - a Vector writer object than will be used to output the result.
+            - a Vector writer object that will be used to output the result.
             - a flag to tell if we want to render an animation or only the
               current frame.
         """
@@ -591,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,
@@ -607,70 +724,63 @@ 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)
+        # global processing of the scene
 
-        # 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)
+        self._doConvertGeometricObjToMesh(workScene)
 
+        self._doSceneClipping(workScene)
 
-        # Convert geometric object types to mesh Objects
-        geometricObjTypes = ['Mesh', 'Surf', 'Curve'] # TODO: add the Text type
-        Objects = workScene.getChildren()
-        objList = [ o for o in Objects if o.getType() in geometricObjTypes ]
-        for obj in objList:
-            old_obj = obj
-            obj = self._convertToRawMeshObj(obj)
-            workScene.link(obj)
-            workScene.unlink(old_obj)
 
+        # 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
 
-        # FIXME: does not work!!, Blender segfaults on joins
         if OPTIMIZE_FOR_SPACE:
             self._joinMeshObjectsInScene(workScene)
 
-        
-        # global processing of the scene
-        self._doClipping()
 
         self._doSceneDepthSorting(workScene)
         
         # Per object activities
-        Objects = workScene.getChildren()
 
+        Objects = workScene.getChildren()
         for obj in Objects:
             
-            if obj.getType() not in geometricObjTypes:
-                print "Only geometric Objects supported! - Skipping type:", obj.getType()
+            if obj.getType() != 'Mesh':
+                print "Only Mesh supported! - Skipping type:", obj.getType()
                 continue
 
             print "Rendering: ", obj.getName()
 
-            mesh = obj.data
+            mesh = obj.getData()
 
             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)
 
-            # 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()
@@ -684,19 +794,15 @@ class Renderer:
 
     # Utility methods
 
-    def _worldPosition(self, obj):
+    def _getObjPosition(self, obj):
         """Return the obj position in World coordinates.
         """
         return obj.matrix.translationPart()
 
-    def _cameraWorldPosition(self):
-        """Return the camera position in World coordinates.
-
-        This trick is needed when the camera follows a path and then
-        camera.loc does not correspond to the current real position of the
-        camera in the world.
+    def _cameraViewDirection(self):
+        """Get the View Direction form the camera matrix.
         """
-        return self._worldPosition(self.cameraObj)
+        return Vector(self.cameraObj.matrix[2]).resize3D()
 
 
     # Faces methods
@@ -722,25 +828,20 @@ class Renderer:
         """
 
         normal = Vector(face.no)
-        c = self._cameraWorldPosition()
-
-        # View vector in orthographics projections can be considered simply as the
-        # camera position
-        view_vect = Vector(c)
-        #if self.cameraObj.data.getType() == 1:
-        #    view_vect = Vector(c)
-
-        # View vector as in perspective projections
-        # it is the difference between the camera position and one point of
-        # the face, we choose the farthest point.
-        # TODO: make the code more pythonic :)
+        camPos = self._getObjPosition(self.cameraObj)
+        view_vect = None
+
+        # View Vector in orthographics projections is the view Direction of
+        # the camera
+        if self.cameraObj.data.getType() == 1:
+            view_vect = self._cameraViewDirection()
+
+        # View vector in perspective projections can be considered as
+        # the difference between the camera position and one point of
+        # the face, we choose the farthest point from the camera.
         if self.cameraObj.data.getType() == 0:
-            max_len = 0
-            for vect in face:
-                vv = Vector(c) - Vector(vect.co)
-                if vv.length > max_len:
-                    max_len = vv.length
-                    view_vect = vv
+            vv = max( [ ((camPos - Vector(v.co)).length, (camPos - Vector(v.co))) for v in face] )
+            view_vect = vv[1]
 
         # if d > 0 the face is visible from the camera
         d = view_vect * normal
@@ -753,11 +854,61 @@ class Renderer:
 
     # Scene methods
 
-    def _doClipping(self):
-        """Clip object against the View Frustum.
+    def _doConvertGeometricObjToMesh(self, scene):
+        """Convert all "geometric" objects to mesh ones.
         """
-        print "TODO: _doClipping()"
-        return
+        geometricObjTypes = ['Mesh', 'Surf', 'Curve', 'Text']
+
+        Objects = scene.getChildren()
+        objList = [ o for o in Objects if o.getType() in geometricObjTypes ]
+        for obj in objList:
+            old_obj = obj
+            obj = self._convertToRawMeshObj(obj)
+            scene.link(obj)
+            scene.unlink(old_obj)
+
+
+            # XXX Workaround for Text and Curve which have some normals
+            # inverted when they are converted to Mesh, REMOVE that when
+            # blender will fix that!!
+            if old_obj.getType() in ['Curve', 'Text']:
+                me = obj.getData(mesh=1)
+                for f in me.faces: f.sel = 1;
+                for v in me.verts: v.sel = 1;
+                me.remDoubles(0)
+                me.triangleToQuad()
+                me.recalcNormals()
+                me.update()
+
+
+    def _doSceneClipping(self, scene):
+        """Clip objects against the View Frustum.
+
+        For now clip away only objects according to their center position.
+        """
+
+        cpos = self._getObjPosition(self.cameraObj)
+        view_vect = self._cameraViewDirection()
+
+        near = self.cameraObj.data.clipStart
+        far  = self.cameraObj.data.clipEnd
+
+        aspect = float(self.canvasRatio[0])/float(self.canvasRatio[1])
+        fovy = atan(0.5/aspect/(self.cameraObj.data.lens/32))
+        fovy = fovy * 360.0/pi
+
+        Objects = scene.getChildren()
+        for o in Objects:
+            if o.getType() != 'Mesh': continue;
+
+            obj_vect = Vector(cpos) - self._getObjPosition(o)
+
+            d = obj_vect*view_vect
+            theta = AngleBetweenVecs(obj_vect, view_vect)
+            
+            # if the object is outside the view frustum, clip it away
+            if (d < near) or (d > far) or (theta > fovy):
+                scene.unlink(o)
 
     def _doSceneDepthSorting(self, scene):
         """Sort objects in the scene.
@@ -765,40 +916,47 @@ class Renderer:
         The object sorting is done accordingly to the object centers.
         """
 
-        c = self._cameraWorldPosition()
+        c = self._getObjPosition(self.cameraObj)
 
-        Objects = scene.getChildren()
+        by_center_pos = (lambda o1, o2:
+                (o1.getType() == 'Mesh' and o2.getType() == 'Mesh') and
+                cmp((self._getObjPosition(o1) - Vector(c)).length,
+                    (self._getObjPosition(o2) - Vector(c)).length)
+            )
 
-        #Objects.sort(lambda obj1, obj2: 
-        #        cmp((Vector(obj1.loc) - Vector(c)).length,
-        #            (Vector(obj2.loc) - Vector(c)).length
-        #            )
-        #        )
+        # TODO: implement sorting by bounding box, if obj1.bb is inside obj2.bb,
+        # then ob1 goes farther than obj2, useful when obj2 has holes
+        by_bbox = None
         
-        Objects.sort(lambda obj1, obj2: 
-                cmp((self._worldPosition(obj1) - Vector(c)).length,
-                    (self._worldPosition(obj2) - Vector(c)).length
-                    )
-                )
+        Objects = scene.getChildren()
+        Objects.sort(by_center_pos)
         
         # update the scene
         for o in Objects:
             scene.unlink(o)
             scene.link(o)
-    
 
     def _joinMeshObjectsInScene(self, scene):
         """Merge all the Mesh Objects in a scene into a single Mesh Object.
         """
-        bigObj = Object.New('Mesh', 'BigOne')
+
         oList = [o for o in scene.getChildren() if o.getType()=='Mesh']
-        print "Before join", oList
+
+        # 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)
+
         bigObj.join(oList)
-        print "After join"
         scene.link(bigObj)
         for o in oList:
             scene.unlink(o)
 
+        scene.update()
+
  
     # Per object methods
 
@@ -811,6 +969,11 @@ class Renderer:
         newObject = Object.New('Mesh', 'RawMesh_'+object.name)
         newObject.link(me)
 
+        # If the object has no materials set a default material
+        if not me.materials:
+            me.materials = [Material.New()]
+            #for f in me.faces: f.mat = 0
+
         newObject.setMatrix(object.getMatrix())
 
         return newObject
@@ -821,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):
@@ -829,23 +997,26 @@ class Renderer:
         The faces in the object are sorted following the distance of the
         vertices from the camera position.
         """
-        c = self._cameraWorldPosition()
+        c = self._getObjPosition(self.cameraObj)
 
         # hackish sorting of faces
-        mesh.faces.sort(
-            lambda f1, f2:
-                # Sort faces according to the min distance from the camera
-                #cmp(min([(Vector(v.co)-Vector(c)).length for v in f1]),
-                #    min([(Vector(v.co)-Vector(c)).length for v in f2])))
 
-                # Sort faces according to the max distance from the camera
+        # Sort faces according to the max distance from the camera
+        by_max_vert_dist = (lambda f1, f2:
                 cmp(max([(Vector(v.co)-Vector(c)).length for v in f1]),
                     max([(Vector(v.co)-Vector(c)).length for v in f2])))
-                
-                # Sort faces according to the avg distance from the camera
-                #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)))
+        
+        # Sort faces according to the min distance from the camera
+        by_min_vert_dist = (lambda f1, f2:
+                cmp(min([(Vector(v.co)-Vector(c)).length for v in f1]),
+                    min([(Vector(v.co)-Vector(c)).length for v in f2])))
+        
+        # Sort faces according to the avg distance from the camera
+        by_avg_vert_dist = (lambda f1, 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()
 
     def _doBackFaceCulling(self, mesh):
@@ -855,7 +1026,8 @@ class Renderer:
         select the vertices belonging to visible faces.
         """
         
-        # Select all vertices, so edges without faces can be displayed
+        # Select all vertices, so edges can be displayed even if there are no
+        # faces
         for v in mesh.verts:
             v.sel = 1
         
@@ -868,17 +1040,15 @@ class Renderer:
 
         # Is this the correct way to propagate the face selection info to the
         # vertices belonging to a face ??
-        # TODO: Using the Mesh class 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
+        # 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
+        #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.
@@ -890,18 +1060,18 @@ class Renderer:
 
         # If the mesh has vertex colors already, use them,
         # otherwise turn them on and do some calculations
-        if mesh.hasVertexColours():
+        if mesh.vertexColors:
             return
-        mesh.hasVertexColours(True)
+        mesh.vertexColors = 1
 
         materials = mesh.materials
         
         # TODO: use multiple lighting sources
         light_obj = self.lights[0]
-        light_pos = self._worldPosition(light_obj)
+        light_pos = self._getObjPosition(light_obj)
         light = light_obj.data
 
-        camPos = self._cameraWorldPosition()
+        camPos = self._getObjPosition(self.cameraObj)
         
         # We do per-face color calculation (FLAT Shading), we can easily turn
         # to a per-vertex calculation if we want to implement some shading
@@ -916,7 +1086,7 @@ class Renderer:
                 mat = materials[f.mat]
 
             # A new default material
-            if not mat:
+            if mat == None:
                 mat = Material.New('defMat')
             
             L = Vector(light_pos).normalize()
@@ -952,26 +1122,43 @@ class Renderer:
 
             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]
 
-            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, edgestyleSelect):
+        """Process Mesh Edges accroding to a given selection style.
 
-    def _doEdgesStyle(self, mesh, style):
-        """Process Mesh Edges. (For now copy the edge data, in next version it
-        can be a place where recognize silouhettes and/or contours).
+        Examples of algorithms:
 
-        input: an edge list
-        return: a processed edge list
+        Contours:
+            given an edge if its adjacent faces have the same normal (that is
+            they are complanar), than deselect it.
+
+        Silhouettes:
+            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.
         """
@@ -987,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!
      """
+
+    if filename == "":
+        print "\nERROR: invalid file name!"
+        return
+
     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) 
 
-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__":
     
-    import os
-    outputfile = os.path.splitext(Blender.Get('filename'))[0]+".svg"
+    outputfile = ""
+    basename = Blender.sys.basename(Blender.Get('filename'))
+    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)
+    else:
+        Draw.Register(GUI.draw, GUI.event, GUI.button_event)