Add a real GUI

Summary of all the changes:
 * Make meshutils methods static, this is really just an utility class
 * Move the config settings up in the code
 * Implement a real blender GUI for VRM

Signed-off-by: Antonio Ospite <ospite@studenti.unina.it>

diff --git a/vrm.py b/vrm.py
index b3aac25..aa73b10 100755 (executable)
--- a/vrm.py
+++ b/vrm.py
@@ -77,12 +77,13 @@ from math import *
 
 
 # Some global settings
 
 
 # Some global settings

+

 PRINT_POLYGONS     = True
 PRINT_POLYGONS     = True

-POLYGON_EXPANSION_TRICK = True

 
 

-PRINT_EDGES        = True
+POLYGON_EXPANSION_TRICK = True # Hidden to the user for now
+
+PRINT_EDGES        = False

 SHOW_HIDDEN_EDGES  = False
 SHOW_HIDDEN_EDGES  = False

-#EDGE_STYLE = 'normal'

 EDGE_STYLE = 'silhouette'
 EDGES_WIDTH = 0.5
 
 EDGE_STYLE = 'silhouette'
 EDGES_WIDTH = 0.5
 


@@ -93,16 +94,15 @@ OPTIMIZE_FOR_SPACE = True
 OUTPUT_FORMAT = 'SVG'
 
 
 OUTPUT_FORMAT = 'SVG'
 
 

+

 # ---------------------------------------------------------------------
 #
 ## Utility Mesh class
 #
 # ---------------------------------------------------------------------
 class MeshUtils:
 # ---------------------------------------------------------------------
 #
 ## Utility Mesh class
 #
 # ---------------------------------------------------------------------
 class MeshUtils:

-    def __init__(self):
-        return

 
 

-    def getEdgeAdjacentFaces(self, edge, mesh):
+    def getEdgeAdjacentFaces(edge, mesh):

         """Get the faces adjacent to a given edge.
 
         There can be 0, 1 or more (usually 2) faces adjacent to an edge.
         """Get the faces adjacent to a given edge.
 
         There can be 0, 1 or more (usually 2) faces adjacent to an edge.


@@ -115,7 +115,7 @@ class MeshUtils:
 
         return adjface_list
 
 
         return adjface_list
 

-    def isVisibleEdge(self, e, mesh):
+    def isVisibleEdge(e, mesh):

         """Normal edge selection rule.
 
         An edge is visible if _any_ of its adjacent faces is selected.
         """Normal edge selection rule.
 
         An edge is visible if _any_ of its adjacent faces is selected.


@@ -123,7 +123,7 @@ class MeshUtils:
         useful for "edge only" portion of objects.
         """
 
         useful for "edge only" portion of objects.
         """
 

-        adjacent_faces = self.getEdgeAdjacentFaces(e, mesh)
+        adjacent_faces = MeshUtils.getEdgeAdjacentFaces(e, mesh)

 
         if len(adjacent_faces) == 0:
             return True
 
         if len(adjacent_faces) == 0:
             return True


@@ -135,7 +135,7 @@ class MeshUtils:
         else:
             return False
 
         else:
             return False
 

-    def isSilhouetteEdge(self, e, mesh):
+    def isSilhouetteEdge(e, mesh):

         """Silhuette selection rule.
 
         An edge is a silhuette edge if it is shared by two faces with
         """Silhuette selection rule.
 
         An edge is a silhuette edge if it is shared by two faces with


@@ -143,7 +143,7 @@ class MeshUtils:
         face.
         """
 
         face.
         """
 

-        adjacent_faces = self.getEdgeAdjacentFaces(e, mesh)
+        adjacent_faces = MeshUtils.getEdgeAdjacentFaces(e, mesh)

 
         if ((len(adjacent_faces) == 1 and adjacent_faces[0].sel == 1) or
             (len(adjacent_faces) == 2 and
 
         if ((len(adjacent_faces) == 1 and adjacent_faces[0].sel == 1) or
             (len(adjacent_faces) == 2 and


@@ -152,6 +152,10 @@ class MeshUtils:
             return True
         else:
             return False
             return True
         else:
             return False

+    
+    getEdgeAdjacentFaces = staticmethod(getEdgeAdjacentFaces)
+    isVisibleEdge = staticmethod(isVisibleEdge)
+    isSilhouetteEdge = staticmethod(isSilhouetteEdge)

 
 
 
 
 
 


@@ -600,6 +604,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.
     


@@ -634,9 +651,12 @@ class Renderer:
         obj_lst = self._SCENE.getChildren()
         self.lights = [ o for o in obj_lst if o.getType() == 'Lamp']
 
         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)
 


@@ -1137,22 +1157,203 @@ class Renderer:
 
 # ---------------------------------------------------------------------
 #
 
 # ---------------------------------------------------------------------
 #

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

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

-# A dictionary to collect all the different edge styles and their edge
-# selection criteria
-edgeSelectionStyles = {
-        'normal': MeshUtils().isVisibleEdge,
-        'silhouette': MeshUtils().isSilhouetteEdge
-        }

 
 

-# A dictionary to collect the supported output formats
-outputWriters = {
-        'SVG': SVGVectorWriter,
-        }
+from Blender import BGL, Draw
+from Blender.BGL import *
+
+class GUI:
+    
+    def _init():
+
+        # Output Format menu 
+        default_value = outputWriters.keys().index(OUTPUT_FORMAT)+1
+        GUI.outFormatMenu = Draw.Create(default_value)
+        GUI.evtOutFormatMenu = 0
+
+        # Animation toggle button
+        GUI.animToggle = Draw.Create(RENDER_ANIMATION)
+        GUI.evtAnimToggle = 1
+
+        # Join Objects toggle button
+        GUI.joinObjsToggle = Draw.Create(OPTIMIZE_FOR_SPACE)
+        GUI.evtJoinObjsToggle = 2
+
+        # Render filled polygons
+        GUI.polygonsToggle = Draw.Create(PRINT_POLYGONS)
+        GUI.evtPolygonsToggle = 3
+        # We hide the POLYGON_EXPANSION_TRICK, for now
+
+        # Render polygon edges
+        GUI.showEdgesToggle = Draw.Create(PRINT_EDGES)
+        GUI.evtShowEdgesToggle = 4
+
+        # Render hidden edges
+        GUI.showHiddenEdgesToggle = Draw.Create(SHOW_HIDDEN_EDGES)
+        GUI.evtShowHiddenEdgesToggle = 5
+
+        # Edge Style menu 
+        default_value = edgeSelectionStyles.keys().index(EDGE_STYLE)+1
+        GUI.edgeStyleMenu = Draw.Create(default_value)
+        GUI.evtEdgeStyleMenu = 6
+
+        # Edge Width slider
+        GUI.edgeWidthSlider = Draw.Create(EDGES_WIDTH)
+        GUI.evtEdgeWidthSlider = 7
+
+        # Render Button
+        GUI.evtRenderButton = 8
+
+        # Exit Button
+        GUI.evtExitButton = 9
+
+    def draw():
+
+        # initialize static members
+        GUI._init()
+
+        glClear(GL_COLOR_BUFFER_BIT)
+        glColor3f(0.0, 0.0, 0.0)
+        glRasterPos2i(10, 350)
+        Draw.Text("VRM: Vector Rendering Method script.")
+        glRasterPos2i(10, 335)
+        Draw.Text("Press Q or ESC to quit.")
+
+        # Build the output format menu
+        glRasterPos2i(10, 310)
+        Draw.Text("Select the output Format:")
+        outMenuStruct = "Output Format %t"
+        for t in outputWriters.keys():
+           outMenuStruct = outMenuStruct + "|%s" % t
+        GUI.outFormatMenu = Draw.Menu(outMenuStruct, GUI.evtOutFormatMenu,
+                10, 285, 160, 18, GUI.outFormatMenu.val, "Choose the Output Format")
+
+        # Animation toggle
+        GUI.animToggle = Draw.Toggle("Animation", GUI.evtAnimToggle,
+                10, 260, 160, 18, GUI.animToggle.val,
+                "Toggle rendering of animations")
+
+        # Join Objects toggle
+        GUI.joinObjsToggle = Draw.Toggle("Join objects", GUI.evtJoinObjsToggle,
+                10, 235, 160, 18, GUI.joinObjsToggle.val,
+                "Join objects in the rendered file")
+
+        # Render Button
+        Draw.Button("Render", GUI.evtRenderButton, 10, 210-25, 75, 25+18,
+                "Start Rendering")
+        Draw.Button("Exit", GUI.evtExitButton, 95, 210-25, 75, 25+18, "Exit!")
+
+        # Rendering Styles
+        glRasterPos2i(200, 310)
+        Draw.Text("Rendering Style:")
+
+        # Render Polygons
+        GUI.polygonsToggle = Draw.Toggle("Filled Polygons", GUI.evtPolygonsToggle,
+                200, 285, 160, 18, GUI.polygonsToggle.val,
+                "Render filled polygons")
+
+        # Render Edges
+        GUI.showEdgesToggle = Draw.Toggle("Show Edges", GUI.evtShowEdgesToggle,
+                200, 260, 160, 18, GUI.showEdgesToggle.val,
+                "Render polygon edges")
+
+        if GUI.showEdgesToggle.val == 1:
+            
+            # Edge Style
+            edgeStyleMenuStruct = "Edge Style %t"
+            for t in edgeSelectionStyles.keys():
+               edgeStyleMenuStruct = edgeStyleMenuStruct + "|%s" % t
+            GUI.edgeStyleMenu = Draw.Menu(edgeStyleMenuStruct, GUI.evtEdgeStyleMenu,
+                    200, 235, 160, 18, GUI.edgeStyleMenu.val,
+                    "Choose the edge style")
+
+            # Edge size
+            GUI.edgeWidthSlider = Draw.Slider("Width: ", GUI.evtEdgeWidthSlider,
+                    200, 210, 160, 18, GUI.edgeWidthSlider.val,
+                    0.0, 10.0, 0, "Change Edge Width")
+
+            # Show Hidden Edges
+            GUI.showHiddenEdgesToggle = Draw.Toggle("Show Hidden Edges",
+                    GUI.evtShowHiddenEdgesToggle,
+                    200, 185, 160, 18, GUI.showHiddenEdgesToggle.val,
+                    "Render hidden edges as dashed lines")
+
+        glRasterPos2i(10, 160)
+        Draw.Text("Antonio Ospite (c) 2006")
+
+    def event(evt, val):
+
+        if evt == Draw.ESCKEY or evt == Draw.QKEY:
+            Draw.Exit()
+        else:
+            return

 
 

+        Draw.Redraw(1)
+
+    def button_event(evt):
+        global PRINT_POLYGONS
+        global POLYGON_EXPANSION_TRICK
+        global PRINT_EDGES
+        global SHOW_HIDDEN_EDGES
+        global EDGE_STYLE
+        global EDGES_WIDTH
+        global RENDER_ANIMATION
+        global OPTIMIZE_FOR_SPACE
+        global OUTPUT_FORMAT
+
+        if evt == GUI.evtExitButton:
+            Draw.Exit()
+        elif evt == GUI.evtOutFormatMenu:
+            i = GUI.outFormatMenu.val - 1
+            OUTPUT_FORMAT = outputWriters.keys()[i]
+        elif evt == GUI.evtAnimToggle:
+            RENDER_ANIMATION = bool(GUI.animToggle.val)
+        elif evt == GUI.evtJoinObjsToggle:
+            OPTIMIZE_FOR_SPACE = bool(GUI.joinObjsToggle.val)
+        elif evt == GUI.evtPolygonsToggle:
+            PRINT_POLYGONS = bool(GUI.polygonsToggle.val)
+        elif evt == GUI.evtShowEdgesToggle:
+            PRINT_EDGES = bool(GUI.showEdgesToggle.val)
+        elif evt == GUI.evtShowHiddenEdgesToggle:
+            SHOW_HIDDEN_EDGES = bool(GUI.showHiddenEdgesToggle.val)
+        elif evt == GUI.evtEdgeStyleMenu:
+            i = GUI.edgeStyleMenu.val - 1
+            EDGE_STYLE = edgeSelectionStyles.keys()[i]
+        elif evt == GUI.evtEdgeWidthSlider:
+            EDGES_WIDTH = float(GUI.edgeWidthSlider.val)
+        elif evt == GUI.evtRenderButton:
+            label = "Save %s" % OUTPUT_FORMAT
+            # Show the File Selector
+            global outputfile
+            Blender.Window.FileSelector(vectorize, label, outputfile)
+
+        else:
+            print "Event: %d not handled!" % evt
+
+        if evt:
+            Draw.Redraw(1)
+            #GUI.conf_debug()
+
+    def conf_debug():
+        print
+        print "PRINT_POLYGONS:", PRINT_POLYGONS
+        print "POLYGON_EXPANSION_TRICK:", POLYGON_EXPANSION_TRICK
+        print "PRINT_EDGES:", PRINT_EDGES
+        print "SHOW_HIDDEN_EDGES:", SHOW_HIDDEN_EDGES
+        print "EDGE_STYLE:", EDGE_STYLE
+        print "EDGES_WIDTH:", EDGES_WIDTH
+        print "RENDER_ANIMATION:", RENDER_ANIMATION
+        print "OPTIMIZE_FOR_SPACE:", OPTIMIZE_FOR_SPACE
+        print "OUTPUT_FORMAT:", OUTPUT_FORMAT
+
+    _init = staticmethod(_init)
+    draw = staticmethod(draw)
+    event = staticmethod(event)
+    button_event = staticmethod(button_event)
+    conf_debug = staticmethod(conf_debug)

 
 # A wrapper function for the vectorizing process
 def vectorize(filename):
 
 # A wrapper function for the vectorizing process
 def vectorize(filename):


@@ -1161,11 +1362,17 @@ def vectorize(filename):
      - Instanciate the writer and the renderer
      - Render!
      """
      - 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 = outputWriters[OUTPUT_FORMAT](filename)
+    actualWriter = outputWriters[OUTPUT_FORMAT]
+    writer = actualWriter(filename)

     
     renderer = Renderer()
     renderer.doRendering(writer, RENDER_ANIMATION)
     
     renderer = Renderer()
     renderer.doRendering(writer, RENDER_ANIMATION)


@@ -1176,12 +1383,12 @@ def vectorize(filename):
 # 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()

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

-        label = "Save %s" % OUTPUT_FORMAT
-        Blender.Window.FileSelector(vectorize, label, outputfile)
-        Blender.Redraw()
+        Draw.Register(GUI.draw, GUI.event, GUI.button_event)