Use on_draw event for rendering.

adamlwgriffiths · adamlwgriffiths · commit b5e9155154e4 · 2012-07-05T22:39:00.000+10:00
Instead of calling render() directly, hook into
the on_draw event for rendering. Just in-case any
other code / libraries trigger or need on_draw to
work.
Remove debug print statement.
diff --git a/examples/create_window/main.py b/examples/create_window/main.py
@@ -33,6 +33,14 @@ def __init__( self ):
             resizable = True,
             config = config
             )
+
+        # display the current FPS
+        self.fps_display = pyglet.clock.ClockDisplay()
+
+        # listen for on_draw events
+        self.window.push_handlers(
+            on_draw = self.on_draw
+            )
         
         # setup our update loop the app
         # we don't need to do this to get the window
@@ -41,21 +49,22 @@ def __init__( self ):
         # we'll render at 60 fps
         frequency = 60.0
         self.update_delta = 1.0 / frequency
+
         # use a pyglet callback for our render loop
         pyglet.clock.schedule_interval(
             self.step,
             self.update_delta
             )
-
-        # display the current FPS
-        self.fps_display = pyglet.clock.ClockDisplay()
-
-        print "Rendering at %iHz" % int(frequency)
     
     def run( self ):
         pyglet.app.run()
     
     def step( self, dt ):
+        # manually dispatch the on_draw event
+        # as we patched it out of the idle loop
+        self.window.dispatch_event( 'on_draw' )
+
+    def on_draw( self ):
         # clear our frame buffer and depth buffer
         glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT )
 
diff --git a/examples/fps_camera/main.py b/examples/fps_camera/main.py
@@ -68,23 +68,27 @@ def __init__( self ):
 
         # setup our text
         self.setup_text()
+
+        # listen for on_draw events
+        self.window.push_handlers(
+            on_draw = self.on_draw
+            )
         
         # setup our update loop the app
         # we'll render at 60 fps
         frequency = 60.0
         self.update_delta = 1.0 / frequency
+
         # use a pyglet callback for our render loop
         pyglet.clock.schedule_interval(
             self.step,
             self.update_delta
             )
 
-        # display the current FPS
+    def setup_scene( self ):
+        # create an fps display
         self.fps_display = pyglet.clock.ClockDisplay()
-        
-        print "Rendering at %iHz" % int(frequency)
 
-    def setup_scene( self ):
         # create a scene
         self.scene_node = SceneNode( 'root' ) 
         self.grid_node = SceneNode( 'grid' )
@@ -154,6 +158,12 @@ def run( self ):
     def step( self, dt ):
         self.move_camera( dt )
 
+        # manually dispatch the on_draw event
+        # as we patched it out of the idle loop
+        self.window.dispatch_event( 'on_draw' )
+
+    def on_draw( self ):
+        # render our scene
         self.render()
 
         # render the fps
diff --git a/examples/low_level/main.py b/examples/low_level/main.py
@@ -49,23 +49,27 @@ def __init__( self ):
 
         # setup our scene
         self.setup_scene()
+
+        # listen for on_draw events
+        self.window.push_handlers(
+            on_draw = self.on_draw
+            )
         
         # setup our update loop the app
         # we'll render at 60 fps
         frequency = 60.0
         self.update_delta = 1.0 / frequency
+
         # use a pyglet callback for our render loop
         pyglet.clock.schedule_interval(
             self.step,
             self.update_delta
             )
 
-        # display the current FPS
+    def setup_scene( self ):
+        # create an fps display
         self.fps_display = pyglet.clock.ClockDisplay()
 
-        print "Rendering at %iHz" % int(frequency)
-
-    def setup_scene( self ):
         # create a scene
         self.scene_node = SceneNode( 'root' )
 
@@ -138,6 +142,11 @@ def step( self, dt ):
         self.sn1.transform.object.rotate_y( dt )
         self.sn2.transform.object.rotate_y( dt )
 
+        # manually dispatch the on_draw event
+        # as we patched it out of the idle loop
+        self.window.dispatch_event( 'on_draw' )
+
+    def on_draw( self ):
         self.render()
 
         # render the fps
diff --git a/examples/mesh_md2/main.py b/examples/mesh_md2/main.py
@@ -58,23 +58,27 @@ def __init__( self ):
 
         # setup our scene
         self.setup_scene()
+
+        # listen for on_draw events
+        self.window.push_handlers(
+            on_draw = self.on_draw
+            )
         
         # setup our update loop the app
         # we'll render at 60 fps
         frequency = 60.0
         self.update_delta = 1.0 / frequency
+
         # use a pyglet callback for our render loop
         pyglet.clock.schedule_interval(
             self.step,
             self.update_delta
             )
 
-        # display the current FPS
+    def setup_scene( self ):
+        # create an fps display
         self.fps_display = pyglet.clock.ClockDisplay()
-        
-        print "Rendering at %iHz" % int(frequency)
 
-    def setup_scene( self ):
         self.renderables = []
 
         # create a scene
@@ -194,6 +198,11 @@ def step( self, dt ):
             # rotate the mesh about it's own vertical axis
             mesh_node.transform.object.rotate_y( dt )
 
+        # manually dispatch the on_draw event
+        # as we patched it out of the idle loop
+        self.window.dispatch_event( 'on_draw' )
+
+    def on_draw( self ):
         self.render()
         
         # render the fps
diff --git a/examples/mesh_obj/main.py b/examples/mesh_obj/main.py
@@ -56,23 +56,27 @@ def __init__( self ):
         
         # setup our scene
         self.setup_scene()
+
+        # listen for on_draw events
+        self.window.push_handlers(
+            on_draw = self.on_draw
+            )
         
         # setup our update loop the app
         # we'll render at 60 fps
         frequency = 60.0
         self.update_delta = 1.0 / frequency
+
         # use a pyglet callback for our render loop
         pyglet.clock.schedule_interval(
             self.step,
             self.update_delta
             )
 
-        # display the current FPS
+    def setup_scene( self ):
+        # create an fps display
         self.fps_display = pyglet.clock.ClockDisplay()
-        
-        print "Rendering at %iHz" % int(frequency)
 
-    def setup_scene( self ):
         # store a list of our renderables
         self.renderables = []
 
@@ -123,6 +127,11 @@ def step( self, dt ):
         # rotate the mesh about it's own vertical axis
         self.mesh_node.transform.object.rotate_y( dt )
 
+        # manually dispatch the on_draw event
+        # as we patched it out of the idle loop
+        self.window.dispatch_event( 'on_draw' )
+
+    def on_draw( self ):
         # render the scene
         self.render()
 
diff --git a/examples/multiple_viewports/main.py b/examples/multiple_viewports/main.py
@@ -63,23 +63,27 @@ def __init__( self ):
 
         # setup our scene
         self.setup_scene()
+
+        # listen for on_draw events
+        self.window.push_handlers(
+            on_draw = self.on_draw
+            )
         
         # setup our update loop the app
         # we'll render at 60 fps
         frequency = 60.0
         self.update_delta = 1.0 / frequency
+
         # use a pyglet callback for our render loop
         pyglet.clock.schedule_interval(
             self.step,
             self.update_delta
             )
 
-        # display the current FPS
+    def setup_scene( self ):
+        # create an fps display
         self.fps_display = pyglet.clock.ClockDisplay()
 
-        print "Rendering at %iHz" % int(frequency)
-
-    def setup_scene( self ):
         # create a list of renderables
         self.renderables = []
 
@@ -159,6 +163,11 @@ def step( self, dt ):
         # rotate the mesh about it's own vertical axis
         self.grid_node.transform.object.rotate_y( dt )
 
+        # manually dispatch the on_draw event
+        # as we patched it out of the idle loop
+        self.window.dispatch_event( 'on_draw' )
+
+    def on_draw( self ):
         # render the scene
         self.render()
 
diff --git a/examples/orthographic/main.py b/examples/orthographic/main.py
@@ -51,23 +51,27 @@ def __init__( self ):
 
         # setup our scene
         self.setup_scene()
+
+        # listen for on_draw events
+        self.window.push_handlers(
+            on_draw = self.on_draw
+            )
         
         # setup our update loop the app
         # we'll render at 60 fps
         frequency = 60.0
         self.update_delta = 1.0 / frequency
+
         # use a pyglet callback for our render loop
         pyglet.clock.schedule_interval(
             self.step,
             self.update_delta
             )
 
-        # display the current FPS
+    def setup_scene( self ):
+        # create an fps display
         self.fps_display = pyglet.clock.ClockDisplay()
 
-        print "Rendering at %iHz" % int(frequency)
-
-    def setup_scene( self ):
         # create a scene
         self.scene_node = SceneNode( 'root' )
 
@@ -123,6 +127,11 @@ def step( self, dt ):
         self.sn1.transform.object.rotate_y( dt )
         self.sn2.transform.object.rotate_y( dt )
 
+        # manually dispatch the on_draw event
+        # as we patched it out of the idle loop
+        self.window.dispatch_event( 'on_draw' )
+
+    def on_draw( self ):
         # render the scene
         self.render()
 
diff --git a/examples/ray_casting/main.py b/examples/ray_casting/main.py
@@ -70,23 +70,27 @@ def __init__( self ):
 
         # setup our text
         self.setup_text()
+
+        # listen for on_draw events
+        self.window.push_handlers(
+            on_draw = self.on_draw
+            )
         
         # setup our update loop the app
         # we'll render at 60 fps
         frequency = 60.0
         self.update_delta = 1.0 / frequency
+
         # use a pyglet callback for our render loop
         pyglet.clock.schedule_interval(
             self.step,
             self.update_delta
             )
 
-        # display the current FPS
+    def setup_scene( self ):
+        # create an fps display
         self.fps_display = pyglet.clock.ClockDisplay()
-        
-        print "Rendering at %iHz" % int(frequency)
 
-    def setup_scene( self ):
         # create a list of renderables
         self.renderables = []
 
@@ -219,6 +223,11 @@ def step( self, dt ):
         # rotate the mesh about it's own vertical axis
         self.mesh_node.transform.object.rotate_y( dt )
 
+        # manually dispatch the on_draw event
+        # as we patched it out of the idle loop
+        self.window.dispatch_event( 'on_draw' )
+
+    def on_draw( self ):
         # render the scene
         self.render()
 
diff --git a/examples/render_callbacks/main.py b/examples/render_callbacks/main.py
@@ -52,23 +52,27 @@ def __init__( self ):
 
         # setup our scene
         self.setup_scene()
+
+        # listen for on_draw events
+        self.window.push_handlers(
+            on_draw = self.on_draw
+            )
         
         # setup our update loop the app
         # we'll render at 60 fps
         frequency = 60.0
         self.update_delta = 1.0 / frequency
+
         # use a pyglet callback for our render loop
         pyglet.clock.schedule_interval(
             self.step,
             self.update_delta
             )
 
-        # display the current FPS
+    def setup_scene( self ):
+        # create an fps display
         self.fps_display = pyglet.clock.ClockDisplay()
 
-        print "Rendering at %iHz" % int(frequency)
-
-    def setup_scene( self ):
         # store a list of renderables
         self.renderables = []
 
@@ -145,6 +149,11 @@ def step( self, dt ):
         # rotate the mesh about it's own vertical axis
         self.grid_node.transform.object.rotate_y( dt )
 
+        # manually dispatch the on_draw event
+        # as we patched it out of the idle loop
+        self.window.dispatch_event( 'on_draw' )
+
+    def on_draw( self ):
         self.render()
 
         # render the fps
diff --git a/examples/render_methods/main.py b/examples/render_methods/main.py
diff --git a/examples/scene_graph/main.py b/examples/scene_graph/main.py
diff --git a/examples/six_dof_camera/main.py b/examples/six_dof_camera/main.py
diff --git a/examples/sorting/main.py b/examples/sorting/main.py
