pyglet 1.2.2 教程与API文档

需积分: 18 27 浏览量更新于2024-07-18 收藏 2.36MB PDF 举报

"pyglet 1.2.2 稳定版文档" Pyglet 是一个纯 Python 的跨平台应用程序框架，特别适合游戏开发。它支持窗口管理、用户界面事件处理、OpenGL 图形、图像和视频加载以及声音和音乐播放。Pyglet 可在 Windows、MacOS（OSX）和 Linux 上运行。 1. **编程指南** (Programming Guide) 这部分是针对开始使用 pyglet 进行开发的程序员的入门教程。pyglet 编程指南深入介绍了如何编写使用 pyglet 的应用程序。它涵盖了多个主题，并且常常引用 pyglet 的 API 参考，帮助开发者理解如何有效地使用 pyglet 框架构建应用。 2. **API 参考** (API Reference) 这个部分提供了 pyglet 库的详细接口文档，包括类、方法、函数等。开发者可以通过查阅这个部分了解如何创建窗口、管理图形、处理事件、加载媒体等内容。例如，`pyglet` 模块包含了创建和管理窗口的核心功能，如 `window = pyglet.window.Window()`，以及 OpenGL 上下文的创建和配置。 3. **开发指南** (Development Guide) - **开发环境** (Development environment): 提供了配置开发环境的指导，可能包括安装必要的依赖、设置 IDE 和版本控制系统等。 - **测试 pyglet** (Testing pyglet): 解释如何对 pyglet 代码进行单元测试和集成测试，确保代码的稳定性和质量。 - **文档** (Documentation): 讨论如何生成和更新 pyglet 的文档，这对于开源项目来说非常重要，因为它帮助其他开发者理解和使用项目。 - **发布 pyglet 版本** (Making a pyglet release): 描述了创建和发布 pyglet 的新版本的步骤，包括版本控制策略和打包过程。 - **OpenGL 接口实现** (OpenGL Interface Implementation): 详述了 pyglet 如何封装和提供 OpenGL 功能，使得开发者可以方便地进行图形渲染。 - **ctypes 封装生成** (ctypes Wrapper Generation): 描述了 pyglet 如何使用 ctypes 生成与 C 库交互的 Python 包装器，以实现底层性能优化。 - **wraptypes**：可能是指 pyglet 如何使用 wrapt 库来装饰或修改类型，以提供额外的功能或改变行为。 4. **相关文档** (Related Documentation) 这部分可能包含了与 pyglet 相关的其他资源，如 Python 模块索引，以及其他第三方库和工具的文档链接，有助于扩展 pyglet 功能和解决特定问题。 Pyglet 的文档覆盖了从基本概念到高级特性的全方位指导，对于任何想要利用 Python 进行图形和游戏开发的开发者来说都是宝贵的资源。通过深入学习和实践，开发者可以充分利用 pyglet 的强大功能，创建出高性能、跨平台的应用程序。

pyglet Documentation, Release 1.2.2

if config.aux_buffers or config.accum_red_size:

print config

As well as supporting more complex conﬁguration selection algorithms, enumeration allows you to efﬁciently ﬁnd the

maximum value of an attribute (for example, the maximum samples per pixel), or present a list of possible conﬁgura-

tions to the user.

Sharing objects between contexts

Every window in pyglet has its own OpenGL context. Each context has its own OpenGL state, including the ma-

trix stacks and current ﬂags. However, contexts can optionally share their objects with one or more other contexts.

Shareable objects include:

• Textures

• Display lists

• Shader programs

• Vertex and pixel buffer objects

• Framebuffer objects

There are two reasons for sharing objects. The ﬁrst is to allow objects to be stored on the video card only once, even

if used by more than one window. For example, you could have one window showing the actual game, with other

“debug” windows showing the various objects as they are manipulated. Or, a set of widget textures required for a GUI

could be shared between all the windows in an application.

The second reason is to avoid having to recreate the objects when a context needs to be recreated. For example, if the

user wishes to turn on multisampling, it is necessary to recreate the context. Rather than destroy the old one and lose

all the objects already created, you can

1. Create the new context, sharing object space with the old context, then

2. Destroy the old context. The new context retains all the old objects.

pyglet deﬁnes an ObjectSpace: a representation of a collection of objects used by one or more contexts. Each

context has a single object space, accessible via its object_space attribute.

By default, all contexts share the same object space as long as at least one context using it is “alive”. If all the contexts

sharing an object space are lost or destroyed, the object space will be destroyed also. This is why it is necessary to

follow the steps outlined above for retaining objects when a context is recreated.

pyglet creates a hidden “shadow” context as soon as pyglet.gl is imported. By default, all windows will share

object space with this shadow context, so the above steps are generally not needed. The shadow context also allows

objects such as textures to be loaded before a window is created (see shadow_window in pyglet.options for

further details).

When you create a Context, you tell pyglet which other context it will obtain an object space from. By default

(when using the Window constructor to create the context) the most recently created context will be used. You can

specify another context, or specify no context (to create a new object space) in the Context constructor.

It can be useful to keep track of which object space an object was created in. For example, when you load a font,

pyglet caches the textures used and reuses them; but only if the font is being loaded on the same object space. The

easiest way to do this is to set your own attributes on the ObjectSpace object.

In the following example, an attribute is set on the object space indicating that game objects have been loaded. This

way, if the context is recreated, you can check for this attribute to determine if you need to load them again:

12 Chapter 1. Programming Guide

pyglet Documentation, Release 1.2.2

context = pyglet.gl.get_current_context()

object_space = context.object_space

object_space.my_game_objects_loaded = True

Avoid using attribute names on ObjectSpace that begin with "pyglet",they may conﬂict with an internal module.

The OpenGL interface

pyglet provides an interface to OpenGL and GLU. The interface is used by all of pyglet’s higher-level API’s, so that

all rendering is done efﬁciently by the graphics card, rather than the operating system. You can access this interface

directly; using it is much like using OpenGL from C.

The interface is a “thin-wrapper” around libGL.so on Linux, opengl32.dll on Windows and

OpenGL.framework on OS X. The pyglet maintainers regenerate the interface from the latest speciﬁcations, so

it is always up-to-date with the latest version and almost all extensions.

The interface is provided by the pyglet.gl package. To use it you will need a good knowledge of OpenGL, C

and ctypes. You may prefer to use OpenGL without using ctypes, in which case you should investigate PyOpenGL.

PyOpenGL provides similar functionality with a more “Pythonic” interface, and will work with pyglet without any

modiﬁcation.

• Using OpenGL

• Resizing the window

• Error checking

• Using extension functions

• Using multiple windows

• AGL, GLX and WGL

Using OpenGL

Documentation of OpenGL and GLU are provided at the OpenGL website and (more comprehensively) in the OpenGL

Programming Guide.

Importing the package gives access to OpenGL, GLU, and all OpenGL registered extensions. This is sufﬁcient for all

but the most advanced uses of OpenGL:

from pyglet.gl import

All function names and constants are identical to the C counterparts. For example, the following program draws a

triangle on the screen:

from pyglet.gl import

# Direct OpenGL commands to this window.

window = pyglet.window.Window()

@window.event

def on_draw():

glClear(GL_COLOR_BUFFER_BIT)

glLoadIdentity()

glBegin(GL_TRIANGLES)

glVertex2f(0, 0)

glVertex2f(window.width, 0)

glVertex2f(window.width, window.height)

1.1. pyglet Programming Guide 13

pyglet Documentation, Release 1.2.2

Error checking

By default, pyglet calls glGetError after every GL function call (except where such a check would be invalid). If

an error is reported, pyglet raises GLException with the result of gluErrorString as the message.

This is very handy during development, as it catches common coding errors early on. However, it has a signiﬁcant

impact on performance, and is disabled when python is run with the -O option.

You can also disable this error check by setting the following option before importing pyglet.gl or

pyglet.window:

# Disable error checking for increased performance

pyglet.options['debug_gl'] = False

from pyglet.gl import

Setting the option after importing pyglet.gl will have no effect. Once disabled, there is no error-checking overhead

in each GL call.

Using extension functions

Before using an extension function, you should check that the extension is implemented by the current driver. Typically

this is done using glGetString(GL_EXTENSIONS), but pyglet has a convenience module, pyglet.gl.gl_info that

does this for you:

if pyglet.gl.gl_info.have_extension('GL_ARB_shadow'):

# ... do shadow-related code.

else:

# ... raise an exception, or use a fallback method

You can also easily check the version of OpenGL:

if pyglet.gl.gl_info.have_version(1,5):

# We can assume all OpenGL 1.5 functions are implemented.

Remember to only call the gl_info functions after creating a window.

There is a corresponding glu_info module for checking the version and extensions of GLU.

nVidia often release hardware with extensions before having them registered ofﬁcially. When you import

from

pyglet.gl you import only the registered extensions. You can import the latest nVidia extensions with:

from pyglet.gl.glext_nv import

Using multiple windows

pyglet allows you to create and display any number of windows simultaneously. Each will be created with its own

OpenGL context, however all contexts will share the same texture objects, display lists, shader programs, and so on,

by default

. Each context has its own state and framebuffers.

There is always an active context (unless there are no windows). When using pyglet.app.run for the application event

loop, pyglet ensures that the correct window is the active context before dispatching the on_draw or on_resize events.

In other cases, you can explicitly set the active context with Window.switch_to.

Sometimes objects and lists cannot be shared between contexts; for example, when the contexts are provided by different video devices. This

will usually only occur if you explicitly select different screens driven by different devices.

1.1. pyglet Programming Guide 15

pyglet Documentation, Release 1.2.2

AGL, GLX and WGL

The OpenGL context itself is managed by an operating-system speciﬁc library: AGL on OS X, GLX under X11 and

WGL on Windows. pyglet handles these details when a window is created, but you may need to use the functions

directly (for example, to use pbuffers) or an extension function.

The modules are named pyglet.gl.agl, pyglet.gl.glx and pyglet.gl.wgl. You must only import the

correct module for the running operating system:

if sys.platform.startswith('linux'):

from pyglet.gl.glx import

glxCreatePbuffer(...)

elif sys.platform == 'darwin':

from pyglet.gl.agl import

aglCreatePbuffer(...)

Alternativally you can use pyglet.compat_platform to support platforms that are compatible with plat-

forms not ofﬁcially supported by pyglet. For example FreeBSD systems will appear as linux-compat in

pyglet.compat_platform.

There are convenience modules for querying the version and extensions of WGL and GLX named

pyglet.gl.wgl_info and pyglet.gl.glx_info, respectively. AGL does not have such a module, just

query the version of OS X instead.

If using GLX extensions, you can import pyglet.gl.glxext_arb for the registered extensions or

pyglet.gl.glxext_nv for the latest nVidia extensions.

Similarly, if using WGL extensions, import pyglet.gl.wglext_arb or pyglet.gl.wglext_nv.

Graphics

At the lowest level, pyglet uses OpenGL to draw in windows. The OpenGL interface is exposed via the pyglet.gl

module (see The OpenGL interface).

However, using the OpenGL interface directly for drawing graphics is difﬁcult and inefﬁcient. The pyglet.graphics

module provides a simpler means for drawing graphics that uses vertex arrays and vertex buffer objects internally to

deliver better performance.

• Drawing primitives

• Vertex attributes

• Vertex lists

– Updating vertex data

– Data usage

– Indexed vertex lists

• Batched rendering

– Setting the OpenGL state

– Hierarchical state

– Sorting vertex lists

• Batches and groups in other modules

Drawing primitives

The pyglet.graphics module draws the OpenGL primitive objects by a mode denoted by the constants

• pyglet.gl.GL_POINTS

16 Chapter 1. Programming Guide

剩余353页未读，继续阅读

r123ed

粉丝: 1
资源: 5

pyglet 1.2.2 教程与API文档

PyPI 官网下载 | pyglet-1.4.11.zip

pyglet-docs1.2

robot-underground一个开源的基于pyglet写的rpg

pyglet-template:引导一个 pyglet 1.2 应用程序

pyglet-gui:基于Kytten的Pyglet图形用户界面

Pyglet的英文手册

pyglet-playground:用于测试各种pyglet功能的游乐场

pyglet-feedstock：用于pyglet的conda-smithy存储库

pyglet-example可用例程

pyglet

最新资源