9.7. Built-in Module gl

Warning: Some illegal calls to the GL library cause the Python interpreter to dump core. In particular, the use of most GL calls is unsafe before the first window is opened.

The module is too large to document here in its entirety, but the following should help you to get started. The parameter conventions for the C functions are translated to Python as follows:

• • All (short, long, unsigned) int values are represented by Python integers.
• • All float and double values are represented by Python floating point numbers. In most cases, Python integers are also allowed.
• • All arrays are represented by one-dimensional Python lists. In most cases, tuples are also allowed.
• • All string and character arguments are represented by Python strings, for instance, winopen('Hi There!') and rotate(900, 'z').

• • All (short, long, unsigned) integer arguments or return values that are only used to specify the length of an array argument are omitted. For example, the C call
  lmdef(deftype, index, np, props)

  is translated to Python as
  lmdef(deftype, index, props)

• • Output arguments are omitted from the argument list; they are transmitted as function return values instead. If more than one value must be returned, the return value is a tuple. If the C function has both a regular return value (that is not omitted because of the previous rule) and an output argument, the return value comes first in the tuple. Examples: the C call
  getmcolor(i, &red, &green, &blue)

  is translated to Python as
  red, green, blue = getmcolor(i)

varray (argument) -- function of module gl

Equivalent to but faster than a number of v3d() calls. The argument is a list (or tuple) of points. Each point must be a tuple of coordinates (x, y, z) or (x, y). The points may be 2- or 3-dimensional but must all have the same dimension. Float and int values may be mixed however. The points are always converted to 3D double precision points by assuming z = 0.0 if necessary (as indicated in the man page), and for each point v3d() is called.

nvarray () -- function of module gl

Equivalent to but faster than a number of n3f and v3f calls. The argument is an array (list or tuple) of pairs of normals and points. Each pair is a tuple of a point and a normal for that point. Each point or normal must be a tuple of coordinates (x, y, z). Three coordinates must be given. Float and int values may be mixed. For each pair, n3f() is called for the normal, and then v3f() is called for the point.

vnarray () -- function of module gl

Similar to nvarray() but the pairs have the point first and the normal second.

nurbssurface (s_k, t_k, ctl, s_ord, t_ord, type) -- function of module gl

Defines a nurbs surface. The dimensions of ctl[][] are computed as follows: [len(s_k) - s_ord], [len(t_k) - t_ord].

nurbscurve (knots, ctlpoints, order, type) -- function of module gl

Defines a nurbs curve. The length of ctlpoints is len(knots) - order.

pwlcurve (points, type) -- function of module gl

Defines a piecewise-linear curve. points is a list of points. type must be N_ST.

pick (n) -- function of module gl

select (n) -- function of module gl

The only argument to these functions specifies the desired size of the pick or select buffer.

endpick () -- function of module gl

endselect () -- function of module gl

These functions have no arguments. They return a list of integers representing the used part of the pick/select buffer. No method is provided to detect buffer overrun.

import gl, GL, time

def main():

gl.foreground()

gl.prefposition(500, 900, 500, 900)

w = gl.winopen('CrissCross')

gl.ortho2(0.0, 400.0, 0.0, 400.0)

gl.color(GL.WHITE)

gl.clear()

gl.color(GL.RED)

gl.bgnline()

gl.v2f(0.0, 0.0)

gl.v2f(400.0, 400.0)

gl.endline()

gl.bgnline()

gl.v2f(400.0, 0.0)

gl.v2f(0.0, 400.0)

gl.endline()

time.sleep(5)

main()