Grafica Computazionale

Transcription

1 Grafica Computazionale lezione31 Informatica e Automazione, "Roma Tre" May 20, 2010

2 Grafica Computazionale: Lezione 31 Introduction to PyOpenGL GLUT - The OpenGL Utility Toolkit GLU and GLX Libraries OpenGLContext 2.x

3 Contents Introduction to PyOpenGL GLUT - The OpenGL Utility Toolkit GLU and GLX Libraries OpenGLContext 2.x

4 About PyOpenGL PyOpenGL is the cross platform Python binding to OpenGL and related APIs

5 About PyOpenGL PyOpenGL is the cross platform Python binding to OpenGL and related APIs PyOpenGL includes support for OpenGL v1.1 through 3.2, GLU, GLUT v3.7 (and FreeGLUT), and GLE 3

6 About PyOpenGL PyOpenGL is the cross platform Python binding to OpenGL and related APIs PyOpenGL includes support for OpenGL v1.1 through 3.2, GLU, GLUT v3.7 (and FreeGLUT), and GLE 3 It also includes support for hundreds of OpenGL extensions. PyOpenGL is interoperable with a large number of external GUI libraries for Python including wxpython, Pygame, PyGTK, and Qt

7 About PyOpenGL PyOpenGL is the cross platform Python binding to OpenGL and related APIs PyOpenGL includes support for OpenGL v1.1 through 3.2, GLU, GLUT v3.7 (and FreeGLUT), and GLE 3 It also includes support for hundreds of OpenGL extensions. PyOpenGL is interoperable with a large number of external GUI libraries for Python including wxpython, Pygame, PyGTK, and Qt It can also use the GLUT library to provide basic windowing and user interface mechanisms.

8 PyOpenGL Sub-Packages The SourceForge PyOpenGL project has two sub-projects:

9 PyOpenGL Sub-Packages The SourceForge PyOpenGL project has two sub-projects: the core library, PyOpenGL (known as the OpenGL-ctypes module in bzr, and the OpenGL package when installed in Python),

10 PyOpenGL Sub-Packages The SourceForge PyOpenGL project has two sub-projects: the core library, PyOpenGL (known as the OpenGL-ctypes module in bzr, and the OpenGL package when installed in Python), and a teaching and testing library, OpenGLContext built on top of the core

11 PyOpenGL Sub-Packages The SourceForge PyOpenGL project has two sub-projects: the core library, PyOpenGL (known as the OpenGL-ctypes module in bzr, and the OpenGL package when installed in Python), and a teaching and testing library, OpenGLContext built on top of the core PyOpenGL further has a module OpenGL_accelerate which provides Cython-based acceleration code.

12 OpenGLContext OpenGLContext VRML97-compatible scenegraph engine written in Python Built directly on top of PyOpenGL,

13 OpenGLContext OpenGLContext VRML97-compatible scenegraph engine written in Python Built directly on top of PyOpenGL, OpenGLContext is a retained-mode rendering engine which demonstrates many of the most basic features desired by those building scenegraph engines

14 OpenGLContext OpenGLContext VRML97-compatible scenegraph engine written in Python Built directly on top of PyOpenGL, OpenGLContext is a retained-mode rendering engine which demonstrates many of the most basic features desired by those building scenegraph engines It is written primarily to provide a source of sample and testing code for the PyOpenGL library, but represents a fairly complete rendering engine.

15 OpenSceneGraph OpenSceneGraph General-purpose C++ engine with Python binding (PyOSG) Large C++ rendering engine with what looks to be a fairly large user base

16 OpenSceneGraph OpenSceneGraph General-purpose C++ engine with Python binding (PyOSG) Large C++ rendering engine with what looks to be a fairly large user base Rendering quality is rather good judging from the screenshots

17 OpenSceneGraph OpenSceneGraph General-purpose C++ engine with Python binding (PyOSG) Large C++ rendering engine with what looks to be a fairly large user base Rendering quality is rather good judging from the screenshots Uses OpenGL for it s rendering back-end

18 OpenSceneGraph OpenSceneGraph General-purpose C++ engine with Python binding (PyOSG) Large C++ rendering engine with what looks to be a fairly large user base Rendering quality is rather good judging from the screenshots Uses OpenGL for it s rendering back-end Rather minimal homepage for the Python wrapper.

19 Pivy Pivy Wrapper for the Coin/Inventor Scenegraph Library Pivy is a Coin3D binding for Python

20 Pivy Pivy Wrapper for the Coin/Inventor Scenegraph Library Pivy is a Coin3D binding for Python Coin3D is a high-level 3D graphics library with a C++ API

21 Pivy Pivy Wrapper for the Coin/Inventor Scenegraph Library Pivy is a Coin3D binding for Python Coin3D is a high-level 3D graphics library with a C++ API Coin uses scene-graph data structures to render real-time graphics suitable for all kinds of scientific and engineering visualization applications

22 Pivy Pivy Wrapper for the Coin/Inventor Scenegraph Library Pivy is a Coin3D binding for Python Coin3D is a high-level 3D graphics library with a C++ API Coin uses scene-graph data structures to render real-time graphics suitable for all kinds of scientific and engineering visualization applications Can be extended with PyOpenGL

23 Pivy Pivy Wrapper for the Coin/Inventor Scenegraph Library Pivy is a Coin3D binding for Python Coin3D is a high-level 3D graphics library with a C++ API Coin uses scene-graph data structures to render real-time graphics suitable for all kinds of scientific and engineering visualization applications Can be extended with PyOpenGL Includes loaders for a number of common formats, including VRML97.

24 POVRay Recipe POVRay Recipe Generation of POVRay files from Python (ray tracing) Textual generator for producing POVRay files from Python code

25 POVRay Recipe POVRay Recipe Generation of POVRay files from Python (ray tracing) Textual generator for producing POVRay files from Python code Written as a recipe in the Python cookbook

26 POVRay Recipe POVRay Recipe Generation of POVRay files from Python (ray tracing) Textual generator for producing POVRay files from Python code Written as a recipe in the Python cookbook Includes sample code for a few scenes

27 POVRay Recipe POVRay Recipe Generation of POVRay files from Python (ray tracing) Textual generator for producing POVRay files from Python code Written as a recipe in the Python cookbook Includes sample code for a few scenes All of the sample code I can see uses something akin to immediate mode in that it renders directly to the file, rather than creating a graph first and then rendering out to the file.

28 Contents Introduction to PyOpenGL GLUT - The OpenGL Utility Toolkit GLU and GLX Libraries OpenGLContext 2.x

29 GLUT - The OpenGL Utility Toolkit GLUT is a window-system independent toolkit for writing OpenGL programs

30 GLUT - The OpenGL Utility Toolkit GLUT is a window-system independent toolkit for writing OpenGL programs It implements a simple windowing API for OpenGL

31 GLUT - The OpenGL Utility Toolkit GLUT is a window-system independent toolkit for writing OpenGL programs It implements a simple windowing API for OpenGL GLUT makes it considerably easier to learn about and explore OpenGL programming

32 GLUT - The OpenGL Utility Toolkit GLUT is a window-system independent toolkit for writing OpenGL programs It implements a simple windowing API for OpenGL GLUT makes it considerably easier to learn about and explore OpenGL programming GLUT provides a portable API so you can write a single OpenGL program that works across all PC and workstation OS platforms.

33 GLUT - The OpenGL Utility Toolkit GLUT is a window-system independent toolkit for writing OpenGL programs It implements a simple windowing API for OpenGL GLUT makes it considerably easier to learn about and explore OpenGL programming GLUT provides a portable API so you can write a single OpenGL program that works across all PC and workstation OS platforms. While GLUT is well-suited to learning OpenGL and developing simple OpenGL applications, GLUT is not a full-featured toolkit so large applications requiring sophisticated user interfaces are better off using native window system toolkits

34 GLUT - The OpenGL Utility Toolkit GLUT is a window-system independent toolkit for writing OpenGL programs It implements a simple windowing API for OpenGL GLUT makes it considerably easier to learn about and explore OpenGL programming GLUT provides a portable API so you can write a single OpenGL program that works across all PC and workstation OS platforms. While GLUT is well-suited to learning OpenGL and developing simple OpenGL applications, GLUT is not a full-featured toolkit so large applications requiring sophisticated user interfaces are better off using native window system toolkits GLUT is simple, easy, and small.

35 Perchè GLUT Un applicazione grafica deve poter accedere ad un buffer di scrittura, sia in finestra che a schermo intero

36 Perchè GLUT Un applicazione grafica deve poter accedere ad un buffer di scrittura, sia in finestra che a schermo intero Tale accesso dipende dalla piattaforma; le OpenGL non provvedono funzionalita per gestire una finestra su cui disegnare, lasciano il compito al sistema operativo

37 Perchè GLUT Un applicazione grafica deve poter accedere ad un buffer di scrittura, sia in finestra che a schermo intero Tale accesso dipende dalla piattaforma; le OpenGL non provvedono funzionalita per gestire una finestra su cui disegnare, lasciano il compito al sistema operativo Sotto Windows si usano, per esempio, le Win32 API, mentre sotto Unix o Linux si usano, in genere, le librerie X-Windows

38 Perchè GLUT Un applicazione grafica deve poter accedere ad un buffer di scrittura, sia in finestra che a schermo intero Tale accesso dipende dalla piattaforma; le OpenGL non provvedono funzionalita per gestire una finestra su cui disegnare, lasciano il compito al sistema operativo Sotto Windows si usano, per esempio, le Win32 API, mentre sotto Unix o Linux si usano, in genere, le librerie X-Windows Che vantaggio c è ad usare una libreria multipiattaforma se poi il codice deve comunque contenere chiamate a librerie specifiche?

39 Perchè GLUT Un applicazione grafica deve poter accedere ad un buffer di scrittura, sia in finestra che a schermo intero Tale accesso dipende dalla piattaforma; le OpenGL non provvedono funzionalita per gestire una finestra su cui disegnare, lasciano il compito al sistema operativo Sotto Windows si usano, per esempio, le Win32 API, mentre sotto Unix o Linux si usano, in genere, le librerie X-Windows Che vantaggio c è ad usare una libreria multipiattaforma se poi il codice deve comunque contenere chiamate a librerie specifiche? Le GLUT si interpongono tra OS/Window system e applicazione grafica.

40 Perchè GLUT Le funzionalità GLUT possono essere riassunte in breve come segue:

41 Perchè GLUT Le funzionalità GLUT possono essere riassunte in breve come segue: 1. gestione delle finestre

42 Perchè GLUT Le funzionalità GLUT possono essere riassunte in breve come segue: 1. gestione delle finestre 2. gestione dei menù

43 Perchè GLUT Le funzionalità GLUT possono essere riassunte in breve come segue: 1. gestione delle finestre 2. gestione dei menù 3. la gestione degli eventi (della finestra, del timer, dei dispositivi di input)

44 Perchè GLUT Le funzionalità GLUT possono essere riassunte in breve come segue: 1. gestione delle finestre 2. gestione dei menù 3. la gestione degli eventi (della finestra, del timer, dei dispositivi di input) 4. gestione di varie primitive geometriche solide e in wireframe

45 GLUT è basato sul paradigma degli eventi All accadere di un evento (l utente preme un tasto sulla tastiera, muove il mouse, sposta una finestra, ecc.):

46 GLUT è basato sul paradigma degli eventi All accadere di un evento (l utente preme un tasto sulla tastiera, muove il mouse, sposta una finestra, ecc.): Il sistema operativo manda quindi un messaggio all applicazione con il tipo di evento

47 GLUT è basato sul paradigma degli eventi All accadere di un evento (l utente preme un tasto sulla tastiera, muove il mouse, sposta una finestra, ecc.): Il sistema operativo manda quindi un messaggio all applicazione con il tipo di evento La gestione dei messaggi tra OS e applicazione puo essere complessa: GLUT intercetta tali messaggi e li gestisce in maniera semplice

48 GLUT è basato sul paradigma degli eventi All accadere di un evento (l utente preme un tasto sulla tastiera, muove il mouse, sposta una finestra, ecc.): Il sistema operativo manda quindi un messaggio all applicazione con il tipo di evento La gestione dei messaggi tra OS e applicazione puo essere complessa: GLUT intercetta tali messaggi e li gestisce in maniera semplice Ad ogni messaggio GLUT fa corrispondere la chiamata ad una funzione ed è compito del programmatore costruire delle funzioni callback (di rendering, di interazione I/O, ecc.) e registrarle con chiamate alla API GLUT

49 GLUT è basato sul paradigma degli eventi All accadere di un evento (l utente preme un tasto sulla tastiera, muove il mouse, sposta una finestra, ecc.): Il sistema operativo manda quindi un messaggio all applicazione con il tipo di evento La gestione dei messaggi tra OS e applicazione puo essere complessa: GLUT intercetta tali messaggi e li gestisce in maniera semplice Ad ogni messaggio GLUT fa corrispondere la chiamata ad una funzione ed è compito del programmatore costruire delle funzioni callback (di rendering, di interazione I/O, ecc.) e registrarle con chiamate alla API GLUT

50 GLUT è basato sul paradigma degli eventi All accadere di un evento (l utente preme un tasto sulla tastiera, muove il mouse, sposta una finestra, ecc.): Il sistema operativo manda quindi un messaggio all applicazione con il tipo di evento La gestione dei messaggi tra OS e applicazione puo essere complessa: GLUT intercetta tali messaggi e li gestisce in maniera semplice Ad ogni messaggio GLUT fa corrispondere la chiamata ad una funzione ed è compito del programmatore costruire delle funzioni callback (di rendering, di interazione I/O, ecc.) e registrarle con chiamate alla API GLUT Riassumendo: Quando l OS sente un evento, invia un messaggio all applicazione; GLUT determina il tipo di evento che lo ha generato e chiama la corrispondente funzione di gestione fornita dal programmatore

51 Programmare con le GLUT passo-passo Si inizia con le import Tutte le funzioni della libreria sono della forma glutsomething(something)

52 Funzioni di inizializzazione (1/2) glutinit() richiede al sistema operativo le risorse per aprire una finestra su cui disegnare.

53 Funzioni di inizializzazione (1/2) glutinit() richiede al sistema operativo le risorse per aprire una finestra su cui disegnare. L argomento può essere fornito dagli argomenti del main e può essere usato per passare delle flag al programma in fase di avvio (dipende dal sistema operativo)

54 Funzioni di inizializzazione (2/2) glutinitdisplaymode() setta le caratteristiche della finestra tramite OR di maschere di bit:

55 Funzioni di inizializzazione (2/2) glutinitdisplaymode() setta le caratteristiche della finestra tramite OR di maschere di bit: GLUT_DOUBLE inizializza una double buffered window

56 Funzioni di inizializzazione (2/2) glutinitdisplaymode() setta le caratteristiche della finestra tramite OR di maschere di bit: GLUT_DOUBLE inizializza una double buffered window GLUT_RGB si chiede una finestra che supporti il formato RGB dei colori (in realtà è RGBA essendoci anche un valore per α-blending)

57 Funzioni di inizializzazione (2/2) glutinitdisplaymode() setta le caratteristiche della finestra tramite OR di maschere di bit: GLUT_DOUBLE inizializza una double buffered window GLUT_RGB si chiede una finestra che supporti il formato RGB dei colori (in realtà è RGBA essendoci anche un valore per α-blending) GLUT_DEPTH la finestra deve possedere un depth-buffer (z-buffer). Il sistema operativo deve quindi fornire la memoria necessaria.

58 Apertura di Finestre Quindi possiamo inizializzare ed aprire la finestra vera e propria

59 Apertura di Finestre Quindi possiamo inizializzare ed aprire la finestra vera e propria glutinitwindowsize(h, w) fissa le dimensioni di questa a h * w

60 Apertura di Finestre Quindi possiamo inizializzare ed aprire la finestra vera e propria glutinitwindowsize(h, w) fissa le dimensioni di questa a h * w glutinitwindowposition(x,y) fissa la posizione del vertice superiore sinistro della finestra agli interi (x,y)

61 Apertura di Finestre Quindi possiamo inizializzare ed aprire la finestra vera e propria glutinitwindowsize(h, w) fissa le dimensioni di questa a h * w glutinitwindowposition(x,y) fissa la posizione del vertice superiore sinistro della finestra agli interi (x,y) glutcreatewindow("name") crea la finestra e pone il titolo pari a "Name"

62 Apertura di Finestre Quindi possiamo inizializzare ed aprire la finestra vera e propria glutinitwindowsize(h, w) fissa le dimensioni di questa a h * w glutinitwindowposition(x,y) fissa la posizione del vertice superiore sinistro della finestra agli interi (x,y) glutcreatewindow("name") crea la finestra e pone il titolo pari a "Name" Dalla versione (3.7), GLUT permette anche applicazioni a schermo intero

63 Apertura di Finestre Quindi possiamo inizializzare ed aprire la finestra vera e propria glutinitwindowsize(h, w) fissa le dimensioni di questa a h * w glutinitwindowposition(x,y) fissa la posizione del vertice superiore sinistro della finestra agli interi (x,y) glutcreatewindow("name") crea la finestra e pone il titolo pari a "Name" Dalla versione (3.7), GLUT permette anche applicazioni a schermo intero Permette inoltre di aprire più finestre e fornisce varie funzioni per la gestione di programmi multi-finestra.

64 Registrazione delle funzioni utente Si devono "registrare" le varie funzioni (callback) definite dall utente, e responsabili del rendering, dell I/O, del timing ecc.

65 Registrazione delle funzioni utente Si devono "registrare" le varie funzioni (callback) definite dall utente, e responsabili del rendering, dell I/O, del timing ecc. abbiamo registrato la funzione display() come funzione di rendering che viene chiamata ogni volta che l applicazione deve disegnare sulla finestra,

66 Registrazione delle funzioni utente Si devono "registrare" le varie funzioni (callback) definite dall utente, e responsabili del rendering, dell I/O, del timing ecc. abbiamo registrato la funzione display() come funzione di rendering che viene chiamata ogni volta che l applicazione deve disegnare sulla finestra, la funzione keyboard() come funzione di I/O da tastiera che viene chiamata ogni volta che l utente usa la tastiera

67 Registrazione delle funzioni utente Si devono "registrare" le varie funzioni (callback) definite dall utente, e responsabili del rendering, dell I/O, del timing ecc. abbiamo registrato la funzione display() come funzione di rendering che viene chiamata ogni volta che l applicazione deve disegnare sulla finestra, la funzione keyboard() come funzione di I/O da tastiera che viene chiamata ogni volta che l utente usa la tastiera e la funzione animate() come funzione che viene chiamata quando non succede nulla (utile per le animazioni)

68 Glut callbacks glutbuttonboxfunc glutclosefunc glutdialsfunc glutdisplayfunc glutentryfunc glutidlefunc glutjoystickfunc glutkeyboardfunc glutkeyboardupfunc glutmenudestroyfunc glutmenustatefunc glutmenustatusfunc glutmotionfunc glutmousefunc glutmousewheelfunc glutoverlaydisplayfunc glutpassivemotionfunc glutreshapefunc glutspaceballbuttonfunc glutspaceballmotionfunc glutspaceballrotatefunc glutspecialfunc glutspecialupfunc gluttabletbuttonfunc gluttabletmotionfunc gluttimerfunc glutvisibilityfunc glutwmclosefunc glutwindowstatusfunc

69 Esempi di registrazioni callback in C

70

71 Esempio di programma GLUT in C

72

73 Esempio di programma GLUT in Python

74 Esempi di altre funzioni callback

75 Contents Introduction to PyOpenGL GLUT - The OpenGL Utility Toolkit GLU and GLX Libraries OpenGLContext 2.x

76 GLU is the OpenGL Utility Library The GL Utilities (GLU) library is a set of routines designed to complement the OpenGL graphics system by providing support for

77 GLU is the OpenGL Utility Library The GL Utilities (GLU) library is a set of routines designed to complement the OpenGL graphics system by providing support for mipmapping (to create texture mipmaps from a base image),

78 GLU is the OpenGL Utility Library The GL Utilities (GLU) library is a set of routines designed to complement the OpenGL graphics system by providing support for mipmapping (to create texture mipmaps from a base image), matrix manipulation (to map coordinates between screen and object space),

79 GLU is the OpenGL Utility Library The GL Utilities (GLU) library is a set of routines designed to complement the OpenGL graphics system by providing support for mipmapping (to create texture mipmaps from a base image), matrix manipulation (to map coordinates between screen and object space), polygon tessellation,

80 GLU is the OpenGL Utility Library The GL Utilities (GLU) library is a set of routines designed to complement the OpenGL graphics system by providing support for mipmapping (to create texture mipmaps from a base image), matrix manipulation (to map coordinates between screen and object space), polygon tessellation, quadrics, NURBS, and error handling.

81 GLU supported functions

82 GLU supported functions Mipmapping routines include image scaling and automatic mipmap generation

83 GLU supported functions Mipmapping routines include image scaling and automatic mipmap generation A variety of matrix manipulation functions build projection and viewing matrices, or project vertices from one coordinate system to another.

84 GLU supported functions Mipmapping routines include image scaling and automatic mipmap generation A variety of matrix manipulation functions build projection and viewing matrices, or project vertices from one coordinate system to another. Polygon tessellation routines convert concave polygons into triangles for easy rendering

85 GLU supported functions Mipmapping routines include image scaling and automatic mipmap generation A variety of matrix manipulation functions build projection and viewing matrices, or project vertices from one coordinate system to another. Polygon tessellation routines convert concave polygons into triangles for easy rendering Quadrics support renders a few basic quadrics such as spheres and cones

86 GLU supported functions Mipmapping routines include image scaling and automatic mipmap generation A variety of matrix manipulation functions build projection and viewing matrices, or project vertices from one coordinate system to another. Polygon tessellation routines convert concave polygons into triangles for easy rendering Quadrics support renders a few basic quadrics such as spheres and cones NURBS code maps complicated NURBS curves and trimmed surfaces into simpler OpenGL evaluators

87 GLU supported functions Mipmapping routines include image scaling and automatic mipmap generation A variety of matrix manipulation functions build projection and viewing matrices, or project vertices from one coordinate system to another. Polygon tessellation routines convert concave polygons into triangles for easy rendering Quadrics support renders a few basic quadrics such as spheres and cones NURBS code maps complicated NURBS curves and trimmed surfaces into simpler OpenGL evaluators an error lookup routine translates OpenGL and GLU error codes into strings.

88 GLU Application Programming Interface glubegincurve - glubeginpolygon - glubeginsurface - glubegintrim - glubuild1dmipmaplevels - glubuild1dmipmaps - glubuild2dmipmaplevels - glubuild2dmipmaps - glubuild3dmipmaplevels - glubuild3dmipmaps - glucheckextension - glucylinder - gludeletenurbsrenderer - gludeletequadric - gludeletetess - gludisk - gluendcurve - gluendpolygon - gluendsurface - gluendtrim - gluerrorstring - glugetnurbsproperty - glugetstring - glugettessproperty - gluloadsamplingmatrices - glulookat - glunewnurbsrenderer - glunewquadric - glunewtess - glunextcontour - glunurbscallbackdata - glunurbscallbackdataext - glunurbscurve - glunurbsproperty - glunurbssurface - gluortho2d - glupartialdisk - gluperspective - glupickmatrix - gluproject - glupwlcurve - gluquadricdrawstyle - gluquadricnormals - gluquadricorientation - gluquadrictexture - gluscaleimage - glusphere - glutessbegincontour - glutessendcontour - glutessendpolygon - glutessnormal - glutessproperty - gluunproject - gluunproject4 -

89 GLX: OpenGL onto the X protocol stream for remote rendering GLX 1.4 is used on Unix OpenGL implementation to manage interaction with the X Window System and to encode OpenGL onto the X protocol stream for remote rendering

90 GLX: OpenGL onto the X protocol stream for remote rendering GLX 1.4 is used on Unix OpenGL implementation to manage interaction with the X Window System and to encode OpenGL onto the X protocol stream for remote rendering pixel buffers for hardware accelerated offscreen rendering;

91 GLX: OpenGL onto the X protocol stream for remote rendering GLX 1.4 is used on Unix OpenGL implementation to manage interaction with the X Window System and to encode OpenGL onto the X protocol stream for remote rendering pixel buffers for hardware accelerated offscreen rendering; read-only drawables for preprocessing of data in an offscreen window and direct video input;

92 GLX: OpenGL onto the X protocol stream for remote rendering GLX 1.4 is used on Unix OpenGL implementation to manage interaction with the X Window System and to encode OpenGL onto the X protocol stream for remote rendering pixel buffers for hardware accelerated offscreen rendering; read-only drawables for preprocessing of data in an offscreen window and direct video input; FBConfigs, a more powerful and flexible interface for selecting frame buffer configurations underlying an OpenGL rendering window.

93 X Terminology In X, a rendering surface is called a Drawable

94 X Terminology In X, a rendering surface is called a Drawable X provides two types of Drawables: Windows which are located onscreen and Pixmaps which are maintained offscreen

95 X Terminology In X, a rendering surface is called a Drawable X provides two types of Drawables: Windows which are located onscreen and Pixmaps which are maintained offscreen The GLX equivalent to a Window is a GLXWindow and the GLX equivalent to a Pixmap is a GLXPixmap

96 X Terminology In X, a rendering surface is called a Drawable X provides two types of Drawables: Windows which are located onscreen and Pixmaps which are maintained offscreen The GLX equivalent to a Window is a GLXWindow and the GLX equivalent to a Pixmap is a GLXPixmap GLX introduces a third type of drawable, called a GLXPbuffer, for which there is no X equivalent

97 X Terminology In X, a rendering surface is called a Drawable X provides two types of Drawables: Windows which are located onscreen and Pixmaps which are maintained offscreen The GLX equivalent to a Window is a GLXWindow and the GLX equivalent to a Pixmap is a GLXPixmap GLX introduces a third type of drawable, called a GLXPbuffer, for which there is no X equivalent GLXPbuffers are used for offscreen rendering but they have different semantics than GLXPixmaps that make it easier to allocate them in non-visible frame buffer memory.

98 X Terminology GLXWindow*s, *GLXPixmaps and GLXPbuffers are created with respect to a GLXFBConfig;

99 X Terminology GLXWindow*s, *GLXPixmaps and GLXPbuffers are created with respect to a GLXFBConfig; the GLXFBConfig describes the depth of the color buffer components and the types, quantities and sizes of the ancillary buffers (i.e., the depth, accumulation, auxiliary, multisample, and stencil buffers)

100 X Terminology GLXWindow*s, *GLXPixmaps and GLXPbuffers are created with respect to a GLXFBConfig; the GLXFBConfig describes the depth of the color buffer components and the types, quantities and sizes of the ancillary buffers (i.e., the depth, accumulation, auxiliary, multisample, and stencil buffers) Double buffering and stereo capability is also fixed by the GLXFBConfig. Ancillary buffers are associated with a GLXDrawable, not with a rendering context

101 X Terminology GLXWindow*s, *GLXPixmaps and GLXPbuffers are created with respect to a GLXFBConfig; the GLXFBConfig describes the depth of the color buffer components and the types, quantities and sizes of the ancillary buffers (i.e., the depth, accumulation, auxiliary, multisample, and stencil buffers) Double buffering and stereo capability is also fixed by the GLXFBConfig. Ancillary buffers are associated with a GLXDrawable, not with a rendering context If several rendering contexts are all writing to the same window, they will share those buffers.

102 Rendering Contexts and Drawing Surfaces The OpenGL specification is intentionally vague on how a rendering context (an abstract OpenGL state machine) is created. One of the purposes of GLX is to pro- vide a means to create an OpenGL context and associate it with a drawing surface. OpenGL defines both client state and server state. Thus a rendering context consists of two parts: one to hold the client state and one to hold the server state.

103 Rendering Contexts and Drawing Surfaces The OpenGL specification is intentionally vague on how a rendering context (an abstract OpenGL state machine) is created. One of the purposes of GLX is to pro- vide a means to create an OpenGL context and associate it with a drawing surface. OpenGL defines both client state and server state. Thus a rendering context consists of two parts: one to hold the client state and one to hold the server state. Each thread can have at most one current rendering context

104 Rendering Contexts and Drawing Surfaces The OpenGL specification is intentionally vague on how a rendering context (an abstract OpenGL state machine) is created. One of the purposes of GLX is to pro- vide a means to create an OpenGL context and associate it with a drawing surface. OpenGL defines both client state and server state. Thus a rendering context consists of two parts: one to hold the client state and one to hold the server state. Each thread can have at most one current rendering context In addition, a rendering context can be **current for only one thread at a time

105 Rendering Contexts and Drawing Surfaces The OpenGL specification is intentionally vague on how a rendering context (an abstract OpenGL state machine) is created. One of the purposes of GLX is to pro- vide a means to create an OpenGL context and associate it with a drawing surface. OpenGL defines both client state and server state. Thus a rendering context consists of two parts: one to hold the client state and one to hold the server state. Each thread can have at most one current rendering context In addition, a rendering context can be **current for only one thread at a time The client is responsible for creating a rendering context and a drawable.

106 Contents Introduction to PyOpenGL GLUT - The OpenGL Utility Toolkit GLU and GLX Libraries OpenGLContext 2.x

107 OpenGLContext 2.x The OpenGLContext project provides a simplified environment for writing OpenGL code with PyOpenGL

108 OpenGLContext 2.x The OpenGLContext project provides a simplified environment for writing OpenGL code with PyOpenGL 1. Rendering contexts for various

109 OpenGLContext 2.x The OpenGLContext project provides a simplified environment for writing OpenGL code with PyOpenGL 1. Rendering contexts for various

110 OpenGLContext 2.x The OpenGLContext project provides a simplified environment for writing OpenGL code with PyOpenGL 1. Rendering contexts for various GUI libraries,

111 OpenGLContext 2.x The OpenGLContext project provides a simplified environment for writing OpenGL code with PyOpenGL 1. Rendering contexts for various GUI libraries, scene graph geometry objects, and

112 OpenGLContext 2.x The OpenGLContext project provides a simplified environment for writing OpenGL code with PyOpenGL 1. Rendering contexts for various GUI libraries, scene graph geometry objects, and PyOpenGL testing code

113 OpenGLContext 2.x The OpenGLContext project provides a simplified environment for writing OpenGL code with PyOpenGL 1. Rendering contexts for various GUI libraries, scene graph geometry objects, and PyOpenGL testing code 2. This simplified environment abstracts the GUI library interfaces for a large number of GUI libraries to allow the easy creation of cross platform and cross-gui OpenGL programs.

114 OpenGLContext 2.x The project also provides simplified geometry display primitives to allow new developers to concentrate on the particular task in which they are interested rather than forcing them to re-implement basic geometry display mechanisms.

115 OpenGLContext 2.x The project also provides simplified geometry display primitives to allow new developers to concentrate on the particular task in which they are interested rather than forcing them to re-implement basic geometry display mechanisms. Taking advantage of this simplified environment, the project provides a number of testing modules

116 OpenGLContext 2.x The project also provides simplified geometry display primitives to allow new developers to concentrate on the particular task in which they are interested rather than forcing them to re-implement basic geometry display mechanisms. Taking advantage of this simplified environment, the project provides a number of testing modules These testing modules should operate under any of the fully functional GUI contexts (note that there are unfinished contexts).

117 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x

118 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders

119 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects

120 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects

121 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries

122 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries Pygame

123 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries Pygame wxpython

124 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries Pygame wxpython GLUT

125 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries Pygame wxpython GLUT Qt (in the OpenGLContext_qt project)

126 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries Pygame wxpython GLUT Qt (in the OpenGLContext_qt project)

127 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries Pygame wxpython GLUT Qt (in the OpenGLContext_qt project) Rendering common scenegraph objects

128 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries Pygame wxpython GLUT Qt (in the OpenGLContext_qt project) Rendering common scenegraph objects geometry

129 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries Pygame wxpython GLUT Qt (in the OpenGLContext_qt project) Rendering common scenegraph objects geometry point-sets

130 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries Pygame wxpython GLUT Qt (in the OpenGLContext_qt project) Rendering common scenegraph objects geometry point-sets line-sets

131 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries Pygame wxpython GLUT Qt (in the OpenGLContext_qt project) Rendering common scenegraph objects geometry point-sets line-sets face-sets

132 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries Pygame wxpython GLUT Qt (in the OpenGLContext_qt project) Rendering common scenegraph objects geometry point-sets line-sets face-sets polygonal text

133 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries Pygame wxpython GLUT Qt (in the OpenGLContext_qt project) Rendering common scenegraph objects geometry point-sets line-sets face-sets polygonal text trimmed NURBs

134 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries Pygame wxpython GLUT Qt (in the OpenGLContext_qt project) Rendering common scenegraph objects geometry point-sets line-sets face-sets polygonal text trimmed NURBs basic particle systems

135 OpenGLContext 2.x (Feature set) Testing and learning environment for PyOpenGL and Python 2.x Shaders Vertex Buffer Objects Pixel Buffer Objects PyOpenGL Usage with Common GUI Libraries Pygame wxpython GLUT Qt (in the OpenGLContext_qt project) Rendering common scenegraph objects geometry point-sets line-sets face-sets polygonal text trimmed NURBs basic particle systems extruded shapes (via GLE)

136 OpenGLContext 2.x (Feature set)

137 OpenGLContext 2.x (Feature set) materials and textures

138 OpenGLContext 2.x (Feature set) materials and textures mip-mapping

139 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing

140 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL

141 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms

142 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms incl. support for forward and reverse transf matrices

143 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms incl. support for forward and reverse transf matrices backgrounds

144 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms incl. support for forward and reverse transf matrices backgrounds solid-colour

145 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms incl. support for forward and reverse transf matrices backgrounds solid-colour spherical

146 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms incl. support for forward and reverse transf matrices backgrounds solid-colour spherical image-cube

147 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms incl. support for forward and reverse transf matrices backgrounds solid-colour spherical image-cube lights

148 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms incl. support for forward and reverse transf matrices backgrounds solid-colour spherical image-cube lights

149 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms incl. support for forward and reverse transf matrices backgrounds solid-colour spherical image-cube lights glblend-based (sorted) transparent-geometry rendering

150 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms incl. support for forward and reverse transf matrices backgrounds solid-colour spherical image-cube lights glblend-based (sorted) transparent-geometry rendering Color-id-rendered mouse selection and interaction

151 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms incl. support for forward and reverse transf matrices backgrounds solid-colour spherical image-cube lights glblend-based (sorted) transparent-geometry rendering Color-id-rendered mouse selection and interaction Frustum culling

152 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms incl. support for forward and reverse transf matrices backgrounds solid-colour spherical image-cube lights glblend-based (sorted) transparent-geometry rendering Color-id-rendered mouse selection and interaction Frustum culling hierarchic axis-aligned bounding boxes

153 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms incl. support for forward and reverse transf matrices backgrounds solid-colour spherical image-cube lights glblend-based (sorted) transparent-geometry rendering Color-id-rendered mouse selection and interaction Frustum culling hierarchic axis-aligned bounding boxes frustum extraction from the combined model-view matrix

154 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms incl. support for forward and reverse transf matrices backgrounds solid-colour spherical image-cube lights glblend-based (sorted) transparent-geometry rendering Color-id-rendered mouse selection and interaction Frustum culling hierarchic axis-aligned bounding boxes frustum extraction from the combined model-view matrix glstencilbuffer-based shadow rendering (defunct)

155 OpenGLContext 2.x (Feature set) materials and textures mip-mapping multi-texturing loading from disk with PIL transforms incl. support for forward and reverse transf matrices backgrounds solid-colour spherical image-cube lights glblend-based (sorted) transparent-geometry rendering Color-id-rendered mouse selection and interaction Frustum culling hierarchic axis-aligned bounding boxes frustum extraction from the combined model-view matrix glstencilbuffer-based shadow rendering (defunct) Tessellating polygons

156 Examples of OpenGL programming (NeHe) NeHe Translations These tutorials are translations of the famous "NeHe" series of tutorials. These are low-level introductory tutorials which generally use the legacy OpenGL API. The linked original tutorials are very gentle and thorough.

157 Examples of OpenGL programming (NeHe) NeHe Translations These tutorials are translations of the famous "NeHe" series of tutorials. These are low-level introductory tutorials which generally use the legacy OpenGL API. The linked original tutorials are very gentle and thorough. 1. NeHe1

158 Examples of OpenGL programming (NeHe) NeHe Translations These tutorials are translations of the famous "NeHe" series of tutorials. These are low-level introductory tutorials which generally use the legacy OpenGL API. The linked original tutorials are very gentle and thorough. 1. NeHe1 2. NeHe2

159 Examples of OpenGL programming (NeHe) NeHe Translations These tutorials are translations of the famous "NeHe" series of tutorials. These are low-level introductory tutorials which generally use the legacy OpenGL API. The linked original tutorials are very gentle and thorough. 1. NeHe1 2. NeHe2 3. NeHe3

160 Examples of OpenGL programming (NeHe) NeHe Translations These tutorials are translations of the famous "NeHe" series of tutorials. These are low-level introductory tutorials which generally use the legacy OpenGL API. The linked original tutorials are very gentle and thorough. 1. NeHe1 2. NeHe2 3. NeHe3 4. NeHe4

161 Examples of OpenGL programming (NeHe) NeHe Translations These tutorials are translations of the famous "NeHe" series of tutorials. These are low-level introductory tutorials which generally use the legacy OpenGL API. The linked original tutorials are very gentle and thorough. 1. NeHe1 2. NeHe2 3. NeHe3 4. NeHe4 5. NeHe5

162