Source Code for Module examples.simple

  1  #!/usr/bin/env python 
  2   
  3  #! This file is a literate Python program. You can compile the documentation 
  4  #! using mylit (http://pypi.python.org/pypi/mylit/). 
  5  ## title = "glitter Example: Simple" 
  6  ## stylesheet = "pygments_style.css" 
  7   
  8  # <h1><i>glitter</i> Example: Simple</h1> 
  9   
 10  # <h2>Summary</h2> 
 11   
 12  # This program will open a GLUT window and render a colored, rotating quad. 
 13   
 14  # <img src="simple.png"> 
 15   
 16  # <h2>Front matter</h2> 
 17   
 18  # <h3>Module docstring</h3> 
 19   
 20  # The module docstring is used as a description of this example in the 
 21  # generated documentation: 
 22  """Simple example displaying a rotating quad. 
 23   
 24  @author: Stephan Wenger 
 25  @date: 2012-02-29 
 26  """ 
 27   
 28  # <h3>Imports</h3> 
 29   
 30  # Our scene is going to rotate. The rotating modelview matrix is computed using 
 31  # the sine and cosine functions from the math module: 
 32  from math import cos, sin 
 33   
 34  # We can usually import classes and functions contained in <i>glitter</i> 
 35  # submodules directly from glitter: 
 36  from glitter import VertexArray, get_default_program 
 37   
 38  # Modules with external dependencies other than numpy, such as platform 
 39  # dependent parts like methods for the generation of an OpenGL context, 
 40  # however, have to be imported from their respective submodules: 
 41  from glitter.contexts.glut import GlutWindow, main_loop, get_elapsed_time 
 42   
 43  # <h2>Vertex arrays</h2> 
 44   
 45  # The geometry is specified as arrays (or nested lists) of vertices, colors, 
 46  # and indices into the vertex and color arrays. Lists are automatically 
 47  # converted to appropriate numpy arrays. The shape of these arrays describes 
 48  # how the arrays are to be drawn. When an index array is used, as in this 
 49  # example, the vertex and color arrays are two-dimensional: the first dimension 
 50  # is the number of vertices, the second is the number of values for each vertex 
 51  # (e.g. the red, green, blue, and alpha channels for a color array). The shape 
 52  # of the index array is also two-dimensional: the first dimension is the number 
 53  # of primitives to be drawn, the second is the number of vertices in each 
 54  # primitive. Here, we draw four triangles forming a quad. 
 55  vertices = ((0, 0, 0), (-1, 1, 0), (1, 1, 0), (1, -1, 0), (-1, -1, 0)) 
 56  colors = ((1, 1, 1), (0, 1, 0), (0, 0, 1), (0, 1, 1), (1, 0, 0)) 
 57  indices = ((0, 1, 2), (0, 2, 3), (0, 3, 4), (0, 4, 1)) 
 58   
 59  # <h2>Main class</h2> 
 60   
 61  # We wrap all the OpenGL interaction in a class. The class will contain an 
 62  # <code>__init__()</code> method to set up all OpenGL objects, any required 
 63  # callback methods, as well as a <code>run()</code> method to trigger execution 
 64  # of the GLUT main loop. 
 65 -class SimpleExample(object): 
 66      # <h3>Initialization</h3> 
 67   
 68      # When a <code>SimpleExample</code> instance is created, we need to 
 69      # initialize a few OpenGL objects. 
 70 -    def __init__(self): 
 71          # First, we create a window; this also creates an OpenGL context. 
 72          self.window = GlutWindow(double=True, multisample=True) 
 73   
 74          # Then, we set the GLUT display callback function which will be defined 
 75          # later. 
 76          self.window.display_callback = self.display 
 77   
 78          # In the OpenGL core profile, there is no such thing as a "standard pipeline" 
 79          # any more. We use the minimalistic <code>defaultpipeline</code> from the 
 80          # <code>glitter.convenience</code> module to create a shader program instead: 
 81          self.shader = get_default_program() 
 82   
 83          # Here, we create a vertex array that contains buffers for two vertex array 
 84          # input variables as well as an index array: 
 85          self.vao = VertexArray(vertices, colors, elements=indices) 
 86   
 87      # <h3>Callback functions</h3> 
 88   
 89      # <h4>Display function</h4> 
 90   
 91      # Here we define the display function. It will be called by GLUT whenever the 
 92      # screen has to be redrawn. 
 93 -    def display(self): 
 94          # First we clear the default framebuffer: 
 95          self.window.clear() 
 96           
 97          # To draw the vertex array, we use: 
 98          self.vao.draw() 
 99   
100          # After all rendering commands have been issued, we swap the back buffer to 
101          # the front, making the rendered image visible all at once: 
102          self.window.swap_buffers() 
103   
104      # <h4>Timer function</h4> 
105   
106      # The animation is controlled by a GLUT timer. The timer callback changes the 
107      # modelview matrix, schedules the next timer event, and causes a screen redraw: 
108 -    def timer(self): 
109          # We first get the elapsed time from GLUT using <code>get_elapsed_time()</code>: 
110          phi = get_elapsed_time() 
111   
112          # We then set the <code>modelview_matrix</code> uniform variable of the 
113          # shader created in the initialization section simply by setting an 
114          # attribute: 
115          self.shader.modelview_matrix = ((cos(phi), sin(phi), 0, 0), (-sin(phi), cos(phi), 0, 0), (0, 0, 1, 0), (0, 0, 0, 2)) 
116   
117          # The following line schedules the next timer event to execute after ten milliseconds. 
118          self.window.add_timer(10, self.timer) 
119   
120          # Finally, we tell GLUT to redraw the screen. 
121          self.window.post_redisplay() 
122   
123      # <h3>Running</h3> 
124       
125      # We will call the <code>run()</code> method later to run the OpenGL code. 
126 -    def run(self): 
127          # To start the animation, we call the timer once; all subsequent timer 
128          # calls will be scheduled by the timer function itself. 
129          self.timer() 
130   
131          # The default program is bound by using a <code>with</code> statement: 
132          with self.shader: 
133              # With the shader bound, we enter the GLUT main loop. 
134              main_loop() 
135   
136          # When the main loop exits, control is handed back to the script. 
137   
138  # <h2>Main section</h2> 
139   
140  # Finally, if this program is being run from the command line, we instanciate 
141  # the main class and run it. 
142  if __name__ == "__main__": 
143      SimpleExample().run() 
144