版本13和34间的区别 (跳过第21版)
于2006-10-09 19:40:49修订的的版本13
大小: 43025
编辑: czk
备注:
于2008-02-23 15:34:18修订的的版本34
大小: 18798
编辑: localhost
备注: converted to 1.6 markup
删除的内容标记成这样。 加入的内容标记成这样。
行号 1: 行号 1:
[[TableOfContents]]

= pygame.display =

这个模块提供了对pygame display的控制。Pygame有唯一一个以窗口或者全屏幕显示的display Surface。你一旦创建这个display,你可以把它作为普通的Surface一样使用。改变不会马上在屏幕上显示出来,你必须使用两个翻转(flipping)函数之一来更新实际显示出来的东西。

display的起始位置(即x=0和y=0)在屏幕的左上角。两个坐标轴分别往右和往下增加。

pygame的display可以被初始化成多种模式之一。默认情况下,它被初始化成一个软件驱动的帧缓冲。你可以请求硬件加速和OpenGL的支持。这由传给pygame.display.set_mode的参数来控制。

任何时刻pygame都只能有一个活动的display。使用pygame.display.set_mod创建一个新的display会把老的display关闭。如果需要精确控制像素格式和显示的分辨率,使用pygame.display.mode_ok函数来设置显示模式,pygame.display.list_modes来列出所有可用的模式,pygame.display.Info来创建一个显示信息对象来查询display的相关信息。

一旦display Surface创建了以后,这个模块的函数会对这个唯一的display起作用。如果这个模块uninitialized后,这个Surface就不能再使用。如果设置了一个新的显示模式,现有的Surface会自动转到新的display上操作。

如果设置了显示模式,一些事件会放在事件队列当中。在程序退出的时候,pygame.QUIT事件会发生。当窗口获取或者失去输入焦点的时候,pygame.ACTIVEEVENT事件会发生。如果display设置了pygame.RESIZEABLE标记,当用户改变窗口的大小时,pygame.VIDEORESIZE事件会发生。如果使用硬件display图形是直接画在屏幕上的,当窗口的一部分必须重画时,pygame.VIDEOEXPOSE事件会发生。


== pygame.display.init ==

初始化display模块。

pygame.display.init(): return None

初始化pygame的display模块。display模块在初始化之前不能做任何事情。当你调用高层的pygame.init的时候,这个模块也被自动初始化了。

pygame会从一组内部显示后台中选择一个进行初始化。显示模式的选择依赖于平台和用户的权限。在显示模式被初始化之前,可以设置环境变量SDL_VIDEODRIVER来控制使用哪个后台。系统的选择列在这里:
 * Windows : windib, directx
 * Unix : x11, dga, fbcon, directfb, ggi, vgl, svgalib, aalib

在某些系统上可以把pygame的display嵌入已经存在的窗口中。如果要这样做,必须设置环境变量SDL_WINDOWID来指定窗口的id或者句柄。当pygame的display被初始化的时候会检查这个变量。要注意的是嵌入的display可能会有很多古怪的副作用。

这个函数多次调用不会有什么坏处,实际上多次调用不会起任何作用。

== pygame.display.quit ==

uninitialize这个display模块。

pygame.display.quit(): return None

这个函数关闭整个display模块。这意味着任何活动的display会被关闭。这个函数在程序退出的时候会被自动调用。

这个函数多次调用不会有什么坏处,实际上多次调用不会起任何作用。

== pygame.display.get_init ==

如果display模块已经初始化,它返回True

pygame.display.get_init(): return bool

如果pygame.display函数当前已经初始化,返回True

== pygame.display.set_mode ==

初始化display的窗口或者屏幕

pygame.display.set_mode(resolution, flags=0, depth=0): return Surface

这个函数会创建一个display Surface。参数用来指定请求display的类型。实际创建的display会是系统支持的类型中与请求的尽可能一致的类型。

resolution(分辨率)参数是一对数表示宽度和高度。flags参数是一组选项的集合。depth参数表示颜色的位数。

返回的Surface和普通的Surface一样使用,但是这个Surface上的东西会最终在显示器上看到。


最好不用使用depth参数,默认情况下会自动选择当前系统最好和最快的颜色深度。如果你的游戏需要特定的颜色格式,你可以使用这个参数来控制颜色深度。pygame会模拟系统不能实现的颜色深度,但这样会很慢。

当请求全屏显示模式时,请求的分辨率有时不能够被精确匹配。在这种情况下,pygame会选择最接近的兼容模式设置显示分辨率。而返回的Surface仍然匹配请求的分辨率。

flags参数可以包含你需要的display的类型。有多种选项可以选择,你可以使用位或运算("|")来组合它们。如果传入0或者不指定flags参数,会自动使用默认值。这里是选项的列表:
 * pygame.FULLSCREEN 创建全屏的display
 * pygame.DOUBLEBUF 使用HWSURFACE或OPENGL时建议加上这个标志
 * pygame.HWSURFACE 使用硬件加速,只在FULLSCREEN时有效
 * pygame.OPENGL 创建一个可以使用opengl的display
 * pygame.RESIZABLE display的窗口可变大小
 * pygame.NOFRAME display的窗口没有边框和控制条

== pygame.display.get_surface ==

返回指向当前display Surface的引用

pygame.display.get_surface(): return Surface

返回指向当前display Surface的引用。如果当前的显示模式还没有设置,那么返回None


== pygame.display.flip ==

把整个display Surface上的东西更新到屏幕上

pygame.display.flip(): return None


这个函数会更新整个display的内容。如果显示模式设置成pygame.HWSURFACE和pygame.DOUBLEBUF,这个操作会等待垂直同步并交换surfaces。如果使用其它的显示模式,这个操作只是简单的更新整个Surface的内容。

当使用pygame.OPENGL显示模式时,这个操作会进行一个gl缓冲交换操作。

== pygame.display.update ==

更新软件display的部分内容

pygame.display.update(rectangle=None): return None

pygame.display.update(rectangle_list): return None

这个函数好像是为软件display优化的pygame.display.flip。它允许只有屏幕的一部分被更新而不是整个。如果没有指定参数,它和pygame.display.flip一样更新整个窗口。

你可以传给这个函数一个矩形或者一组矩形作为参数。一次传送多个矩形,比多次调用每次一个(或者一部分)矩形更有效率。如果传送一个矩形的列表,则列表中可以含有None,它会被自动跳过。

这个函数不能用在pygame.OPENGL模式上,如果使用会导致一个异常。

== pygame.display.get_driver ==

获得pygame显示后台的名字

pygame.display.get_driver(): return name

pygame在初始化时从多个可以选择的显示后台中选择一个。这个函数返回选择的显示后台的名字。这为 display的加速能力提供了一些有限的信息。


== pygame.display.Info ==

创建一个视频显示信息对象

      pygame.display.Info(): return VideoInfo

创建一个简单的对象,包含图形环境的一些信息。如果在pygame.display.set_mode之前被调用,有些平台上会提供默认的显示模式的信息。在设置了显示模式后调用这个函数,可以验证特定的显示选项是否满足。VideoInfo包含下列对象:
 * hw: True if the display is hardware accelerated
 * wm: True if windowed display modes can be used
 * video_mem: The megabytes of video memory on the display. This is 0 if unknown
 * bitsize: Number of bits used to store each pixel
 * bytesize: Number of bytes used to store each pixel
 * masks: Four values used to pack RGBA values into pixels
 * shifts: Four values used to pack RGBA values into pixels
 * losses: Four values used to pack RGBA values into pixels
 * blit_hw: True if hardware Surface blitting is accelerated
 * blit_hw_CC: True if hardware Surface colorkey blitting is accelerated
 * blit_hw_A: True if hardware Surface pixel alpha blitting is accelerated
 * blit_sw: True if software Surface blitting is accelerated
 * blit_sw_CC: True if software Surface colorkey blitting is accelerated
 * blit_sw_A: True if software Surface pixel alpha blitting is acclerated

== pygame.display.get_wm_info ==

获得当前窗口系统的信息

pygame.display.get_wm_info(): return dict

创建一个字典,关键字为字符串类型。关键字和值是由系统任意创建的。某些系统上可能没有任何信息,会返回一个空的字典。大部分系统上都有一个"window"关键字,它的值是当前display的系统id。


== pygame.display.list_modes ==

获得一个可用的全屏模式列表

pygame.display.list_modes(depth=0, flags=pygame.FULLSCREEN): return list

这个函数返回一个指定颜色深度的所有可用的分辨率的列表。如果给定的参数没有显示模式可用,那么会返回一个空的列表。返回-1表示任何分辨率都可以用(这可能是因为指定的是窗口模式)。列表中的模式按照分辨率从大到小排列。

如果depth是0,SDL会自动选择当前或最好的颜色深度。flags参数默认是pygame.FULLSCREEN,你可以添加额外的选项。

== pygame.display.mode_ok ==

选择一个最好的颜色深度

pygame.display.mode_ok(size, flags=0, depth=0): return depth

这个函数使用和pygame.display.set_mode相同的参数。它用来确定请求的模式是否可用。指定的模式不能使用它会返回0,否则它会返回一个最佳的颜色深度。

通常depth参数不会被使用。然而某些平台上支持多种颜色深度都同样好,传递这个参数用来指定哪个是更好的。

最有用的flags是pygame.HWSURFACE、pygame.DOUBLEBUF和pygame.FULLSCREEN。如果被请求的flags不能够设置,函数会返回0。

== pygame.display.gl_get_attribute ==

获得当前display的opengl标志

pygame.display.gl_get_attribute(flag): return value

如果在调用pygame.display.set_mode时使用了pygame.OPENGL标志,最好检查一下请求的OpenGL属性的值。参看pygame.display.get_set_attribute来得到有效的标志列表。

== pygame.display.gl_set_attribute ==

请求设置display的opengl显示属性

pygame.display.gl_set_attribute(flag, value): return None

当调用pygame.display.set_mode时指定了pygame.OPENGL标志,pygame会自动设置OpenGL的属性比如说颜色和双缓冲。你可能需要控制OpenGL提供的其它一些属性。把这些属性作为flag,它的值作为value调用这个函数。这个函数必须在pygame.display.set_mode之前调用。

OPENGL标志有:
 * GL_ALPHA_SIZE, GL_DEPTH_SIZE, GL_STENCIL_SIZE, GL_ACCUM_RED_SIZE,
 * GL_ACCUM_GREEN_SIZE, GL_ACCUM_BLUE_SIZE, GL_ACCUM_ALPHA_SIZE,
 * GL_MULTISAMPLEBUFFERS, GL_MULTISAMPLESAMPLES, GL_STEREO

== pygame.display.get_active ==

当display是活动的时候返回True

pygame.display.get_active(): return bool

在pygame.display.set_mode被调用之后,display Surface会在屏幕上显示出来。大部分窗口的display可以被用户隐藏。如果display Surface被用户隐藏或者最小化,这个函数会返回False。

== pygame.display.iconify ==

最小化display Surface

pygame.display.iconify(): return bool

让display surface窗口最小化或者隐藏。不是所有系统都支持最小化的。这个函数在成功时会返回True。

当display被最小化,pygame.display.get_active会返回False。窗口最小化时事件队列会收到一个ACTIVEEVENT事件。

== pygame.display.toggle_fullscreen ==

在窗口和全屏之间切换

      pygame.display.toggle_fullscreen(): return bool

在窗口和全屏模式之间切换。这个函数只有在unix x11下才能使用。大部分情况下,使用pygame.display.set_mode重新设置flags标志会更好。

== pygame.display.set_gamma ==

修改硬件gamma梯度

pygame.display.set_gamma(red, green=None, blue=None): return bool

在显示硬件上设置红绿蓝gamma值。如果green和blue参数没有传,则它们的值和red一样。不是所有的硬件都支持gamma梯度,如果函数调用成功会返回True

gamma值为1.0会创建一个线性的颜色标。低的值会使显示变暗,高的值会使显示变量。

= Surface =

pygame里的Surface是用来表示图像的对象。Surface有一定的大小和像素格式。如果是8bit像素格式的Surface,它还会用一个调色板映射到24比特颜色。

调用pygame.Surface可以创建表示图像的新对象。Surface会整个全是黑的。唯一需要指定的参数是大小。如果不指定其他参数,Surface的像素格式会与display Surface的像素格式尽量一致。

像素格式可以通过指定像素深度或者已有的Surface来控制。flag标志位参数是其他一些Surface选项的集合,你可以指定如下的标志

 * HWSURFACE, 在视频内存中创建图像
 * SRCALPHA, 像素格式中会包含一个alpha通道

这些参数都仅仅是一个请求,在实际中可能并不能实现。

Advance users can combine a set of bitmasks with a depth value. The masks are a set of 4 integers representing which bits in a pixel will represent each color. Normal Surfaces should not require the masks argument.

Surfaces can have many extra attributes like alpha planes, colorkeys, source rectangle clipping. These functions mainly effect how the Surface is blitted to other Surfaces. The blit routines will attempt to use hardware acceleratio

 when possible, otherwise will use highly optimized software blitting methods.

There are three types of transparency supported in Pygame: colorkeys, surface alphas, and pixel alphas. Surface alphas can be mixed with colorkeys, but an image with per pixel alphas cannot use the other modes. Colorkey transparency makes a single color value transparent. Any pixels matching the colorkey will not be drawn. The surface alpha value is a single value that changes the transparency for the entire image. A surface alpha of 255 is opaque, and a value of 0 is completely transparent.

Per pixel alphas are different because they store a transparency value for every pixel. This allows for the most precise transparency effects, but it also the slowest. Per pixel alphas cannot be mixed with surface alpha and colorkeys.

There is support for pixel access for the Surfaces. Pixel access on hardware surfaces is slow and not recommended. Pixels can be accessed using the get_at() and set_at() functions. These methods are fine for simple access, but will be considerably slow when doing of pixel work with them. If you plan on doing a lot of pixel level work, it is recommended to use the pygame.surfarray module, which can treat the surfaces like large multidimensional arrays (and it's quite quick).

Any functions that directly access a surface's pixel data will need that surface to be lock()'ed. These functions can lock() and unlock() the surfaces themselves without assistance. But, if a function will be called many times, there will be a lot of overhead for multiple locking and unlocking of the surface. It is best to lock the surface manually before making the function call many times, and then unlocking when you are finished. All functions that need a locked surface will say so in their docs. Remember to leave the Surface locked only while necessary.

Surface pixels are stored internally as a single number that has all the colors encoded into it. Use the Surface.map_rgb - convert a color into a mapped color value and Surface.unmap_rgb - convert a mapped integer color value into a Color to convert between individual red, green, and blue values into a packed integer for that Surface.

Surfaces can also reference sections of other Surfaces. These are created with the Surface.subsurface - create a new surface that references its parent method. Any change to either Surface will effect the other.

Each Surface contains a clipping area. By default the clip area covers the entire Surface. If it is changed, all drawing operations will only effect the smaller area.

== Surface.blit ==

      draw one image onto another
      Surface.blit(source, dest, area=None, special_flags = 0): return Rect

      Draws a source Surface onto this Surface. The draw can be positioned with the dest argument. Dest can either be pair of coordinates representing the upper left corner of the source. A Rect can also be passed as the destination and the topleft corner of the rectangle will be used as the position for the blit. The size of the destination rectangle does not effect the blit.

      An optional area rectangle can be passed as well. This represents a smaller portion of the source Surface to draw.

      An optional special flags is for passing in BLEND_ADD, BLEND_SUB, BLEND_MULT, BLEND_MIN, BLEND_MAX With other special blitting flags perhaps added in the future.

      The return rectangle is the area of the affected pixels, excluding any pixels outside the destination Surface, or outside the clipping area.

      Pixel alphas will be ignored when blitting to an 8 bit Surface.

      special_flags new in pygame 1.8.
       

== Surface.convert ==

      change the pixel format of an image
      Surface.convert(Surface): return Surface
      Surface.convert(depth, flags=0): return Surface
      Surface.convert(masks, flags=0): return Surface
      Surface.convert(): return Surface

      Creates a new copy of the Surface with the pixel format changed. The new pixel format can be determined from another existing Surface. Otherwise depth, flags, and masks arguments can be used, similar to the pygame.Surface - pygame object for representing images call.

      If no arguments are passed the new Surface will have the same pixel format as the display Surface. This is always the fastest format for blitting. It is a good idea to convert all Surfaces before they are blitted many times.

      The converted Surface will have no pixel alphas. They will be stripped if the original had them. See Surface.convert_alpha - change the pixel format of an image including per pixel alphas for preserving or creating per-pixel alphas.

== Surface.copy ==

      create a new copy of a Surface
      Surface.copy(): return Surface

      Makes a duplicate copy of a Surface. The new Surface will have the same pixel formats, color palettes, and transparency settings as the original.

== Surface.fill ==

      fill Surface with a solid color
      Surface.fill(color, rect=None): return Rect

      Fill the Surface with a solid color. If no rect argument is given the entire Surface will be filled. The rect argument will limit the fill to a specific area. The fill will also be contained by the Surface clip area.

      The color argument can be either an RGB sequence or a mapped color index.

      This will return the affected Surface area.

== Surface.set_colorkey ==

      Set the transparent colorkey
      Surface.set_colorkey(Color, flags=0): return None
      Surface.set_colorkey(None): return None

      Set the current color key for the Surface. When blitting this Surface onto a destination, and pixels that have the same color as the colorkey will be transparent. The color can be an RGB color or a mapped color integer. If None is passed, the colorkey will be unset.

      The colorkey will be ignored if the Surface is formatted to use per pixel alpha values. The colorkey can be mixed with the full Surface alpha value.

      The optional flags argument can be set to pygame.RLEACCEL to provide better performance on non accelerated displays. An RLEACCEL Surface will be slower to modify, but quicker to blit as a source.


== Surface.get_at ==

      get the color value at a single pixel
      Surface.get_at((x, y)): return Color

      Return the RGBA color value at the given pixel. If the Surface has no per pixel alpha, then the alpha value will always be 255 (opaque). If the pixel position is outside the area of the Surface an IndexError exception will be raised.

      Getting and setting pixels one at a time is generally too slow to be used in a game or realtime situation.

      This function will temporarily lock and unlock the Surface as needed.
       

== Surface.set_at ==

      set the color value for a single pixel
      Surface.set_at((x, y), Color): return None

      Set the RGBA or mapped integer color value for a single pixel. If the Surface does not have per pixel alphas, the alpha value is ignored. Settting pixels outside the Surface area or outside the Surface clipping will have no effect.

      Getting and setting pixels one at a time is generally too slow to be used in a game or realtime situation.

      This function will temporarily lock and unlock the Surface as needed.

== Surface.set_clip ==

      set the current clipping area of the Surface
      Surface.set_clip(rect): return None
      Surface.set_clip(None): return None

      Each Surface has an active clipping area. This is a rectangle that represents the only pixels on the Surface that can be modified. If None is passed for the rectangle the full Surface will be available for changes.

      The clipping area is always restricted to the area of the Surface itself. If the clip rectangle is too large it will be shrunk to fit inside the Surface.
       

== Surface.get_clip ==

      get the current clipping are of the Surface
      Surface.get_clip(): return Rect

      Return a rectangle of the current clipping area. The Surface will always return a valid rectangle that will never be outside the bounds of the image. If the Surface has had None set for the clipping area, the Surface will return a rectangle with the full area of the Surface.


== Surface.get_size ==

      get the dimensions of the Surface
      Surface.get_size(): return (width, height)

      Return the width and height of the Surface in pixels.
       

== Surface.get_width ==

      get the width of the Surface
      Surface.get_width(): return width

      Return the width of the Surface in pixels.
       

== Surface.get_height ==

      get the height of the Surface
      Surface.get_height(): return height

      Return the height of the Surface in pixels.
= image =

The image module contains functions for loading and saving pictures, as well as transferring Surfaces to formats usable by other packages.

Note that there is no Image class; an image is loaded as a Surface object. The Surface class allows manipulation (drawing lines, setting pixels, capturing regions, etc.).

The image module is a required dependency of Pygame, but it only optionally supports any extended file formats. By default it can only load uncompressed BMP images. When built with full image support, the pygame.image.load - load new image from a file function can support the following formats.

    * JPG
    * PNG
    * GIF (non animated)
    * BMP
    * PCX
    * TGA (uncompressed)
    * TIF
    * LBM (and PBM)
    * PBM (and PGM, PPM)
    * XPM

Saving images only supports a limited set of formats. You can save to the following formats.

    * BMP
    * TGA
    * PNG
    * JPEG

PNG, JPEG saving new in pygame 1.8.

== pygame.image.load ==

      load new image from a file
      pygame.image.load(filename): return Surface
      pygame.image.load(fileobj, namehint=""): return Surface

      Load an image from a file source. You can pass either a filename or a Python file-like object.

      Pygame will automatically determine the image type (e.g., GIF or bitmap) and create a new Surface object from the data. In some cases it will need to know the file extension (e.g., GIF images should end in ".gif"). If you pass a raw file-like object, you may also want to pass the original filename as the namehint argument.

      The returned Surface will contain the same color format, colorkey and alpha transparency as the file it came from. You will often want to call Surface.convert - change the pixel format of an image with no arguments, to create a copy that will draw more quickly on the screen.

      For alpha transparency, like in .png images use the convert_alpha() method after loading so that the image has per pixel transparency.

      Pygame may not always be built to support all image formats. At minimum it will support uncompressed BMP. If pygame.image.get_extended - test if extended image formats can be loaded returns 'True', you should be able to load most images( including png, jpg and gif ).

      You should use os.path.join() for compatibility.

        eg. asurf = pygame.image.load(os.path.join('data', 'bla.png'))


== pygame.image.save ==

      save an image to disk
      pygame.image.save(Surface, filename): return None

      This will save your Surface as either a BMP, TGA, PNG, or JPEG image. If the filename extension is unrecognized it will default to TGA. Both TGA, and BMP file formats create uncompressed files.

      PNG, JPEG saving new in pygame 1.8.


== pygame.image.tostring ==

      transfer image to string buffer
      pygame.image.tostring(Surface, format, flipped=False): return string

      Creates a string that can be transferred with the 'fromstring' method in other Python imaging packages. Some Python image packages prefer their images in bottom-to-top format (PyOpenGL for example). If you pass True for the flipped argument, the string buffer will be vertically flipped.

      The format argument is a string of one of the following values. Note that only 8bit Surfaces can use the "P" format. The other formats will work for any Surface. Also note that other Python image packages support more formats than Pygame.
          o P, 8bit palettized Surfaces
          o RGB, 24bit image
          o RGBX, 32bit image with unused space
          o RGBA, 32bit image with an alpha channel
          o ARGB, 32bit image with alpha channel first
       

== pygame.image.fromstring ==

      create new Surface from a string buffer
      pygame.image.fromstring(string, size, format, flipped=False): return Surface

      This function takes arguments similar to pygame.image.tostring - transfer image to string buffer. The size argument is a pair of numbers representing the width and height. Once the new Surface is created you can destroy the string buffer.

      The size and format image must compute the exact same size as the passed string buffer. Otherwise an exception will be raised.

      See the pygame.image.frombuffer - create a new Surface that shares data inside a string buffer method for a potentially faster way to transfer images into Pygame.

= draw =
Draw several simple shapes to a Surface. These functions will work for rendering to any format of Surface. Rendering to hardware Surfaces will be slower than regular software Surfaces.

Most of the functions take a width argument to represent the size of stroke around the edge of the shape. If a width of 0 is passed the function will actually solid fill the entire shape.

All the drawing functions respect the clip area for the Surface, and will be constrained to that area. The functions return a rectangle representing the bounding area of changed pixels.

Most of the arguments accept a color argument that is an RGB triplet. These can also accept an RGBA quadruplet. The alpha value will be written directly into the Surface if it contains pixel alphas, but the draw function will not draw transparently. The color argument can also be an integer pixel value that is already mapped to the Surface's pixel format.

These functions must temporarily lock the Surface they are operating on. Many sequential drawing calls can be sped up by locking and unlocking the Surface object around the draw calls.

== pygame.draw.rect ==

      draw a rectangle shape
      pygame.draw.rect(Surface, color, Rect, width=0): return Rect

      Draws a rectangular shape on the Surface. The given Rect is the area of the rectangle. The width argument is the thickness to draw the outer edge. If width is zero then the rectangle will be filled.

      Keep in mind the Surface.fill - fill Surface with a solid color method works just as well for drawing filled rectangles. In fact the Surface.fill - fill Surface with a solid color can be hardware accelerated on some platforms with both software and hardware display modes.
       

== pygame.draw.polygon ==

      draw a shape with any number of sides
      pygame.draw.polygon(Surface, color, pointlist, width=0): return Rect

      Draws a polygonal shape on the Surface. The pointlist argument is the vertices of the polygon. The width argument is the thickness to draw the outer edge. If width is zero then the polygon will be filled.

      For aapolygon, use aalines with the 'closed' parameter.
       

== pygame.draw.circle ==

      draw a circle around a point
      pygame.draw.circle(Surface, color, pos, radius, width=0): return Rect

      Draws a circular shape on the Surface. The pos argument is the center of the circle, and radius is the size. The width argument is the thickness to draw the outer edge. If width is zero then the circle will be filled.
       

== pygame.draw.ellipse ==

      draw a round shape inside a rectangle
      pygame.draw.ellipse(Surface, color, Rect, width=0): return Rect

      Draws an elliptical shape on the Surface. The given rectangle is the area that the circle will fill. The width argument is the thickness to draw the outer edge. If width is zero then the ellipse will be filled.
       

== pygame.draw.arc ==

      draw a partial section of an ellipse
      pygame.draw.arc(Surface, color, Rect, start_angle, stop_angle, width=1): return Rect

      Draws an elliptical arc on the Surface. The rect argument is the area that the ellipse will fill. The two angle arguments are the initial and final angle in radians, with the zero on the right. The width argument is the thickness to draw the outer edge.
       

== pygame.draw.line ==

      draw a straight line segment
      pygame.draw.line(Surface, color, start_pos, end_pos, width=1): return Rect

      Draw a straight line segment on a Surface. There are no endcaps, the ends are squared off for thick lines.
       

== pygame.draw.lines ==

      draw multiple contiguous line segments
      pygame.draw.lines(Surface, color, closed, pointlist, width=1): return Rect

      Draw a sequence of lines on a Surface. The pointlist argument is a series of points that are connected by a line. If the closed argument is true an additional line segment is drawn between the first and last points.

      This does not draw any endcaps or miter joints. Lines with sharp corners and wide line widths can have improper looking corners.
       

== pygame.draw.aaline ==

      draw fine antialiased lines
      pygame.draw.aaline(Surface, color, startpos, endpos, blend=1): return Rect

      Draws an anti-aliased line on a surface. This will respect the clipping rectangle. A bounding box of the affected area is returned returned as a rectangle. If blend is true, the shades will be be blended with existing pixel shades instead of overwriting them. This function accepts floating point values for the end points.

== pygame.draw.aalines ==

      pygame.draw.aalines(Surface, color, closed, pointlist, blend=1): return Rect

      Draws a sequence on a surface. You must pass at least two points in the sequence of points. The closed argument is a simple boolean and if true, a line will be draw between the first and last points. The boolean blend argument set to true will blend the shades with existing shades instead of overwriting them. This function accepts floating point values for the end points.

= font =
The font module allows for rendering TrueType fonts into a new Surface object. This module is optional and requires SDL_ttf as a dependency. You should test that pygame.font is available and initialized before attempting to use the module.

Most of the work done with fonts are done by using the actual Font objects. The module by itself only has routines to initialize the module and create Font objects with pygame.font.Font - create a new Font object from a file.

You can load fonts from the system by using the pygame.font.SysFont - create a Font object from the system fonts function. There are a few other functions to help lookup the system fonts.

Pygame comes with a builtin default font. This can always be accessed by passing None as the font name.

== pygame.font.init ==

      initialize the font module
      pygame.font.init(): return None

      This method is called automatically by pygame.init - initialize all imported pygame modules. It initializes the font module. The module must be initialized before any other functions will work.

      It is safe to call this function more than once.


== pygame.font.quit ==

      uninitialize the font module
      pygame.font.quit(): return None

      Manually uninitialize SDL_ttf's font system. This is called automatically by pygame.quit - uninitialize all pygame modules.

      It is safe to call this function even if font is currently not initialized.

== pygame.font.get_init ==

      true if the font module is initialized
      pygame.font.get_init(): return bool

      Test if the font module is initialized or not.

== pygame.font.get_default_font ==

      get the filename of the default font
      pygame.font.get_default_font(): return string

      Return the filename of the system font. This is not the full path to the file. This file can usually be found in the same directory as the font module, but it can also be bundled in separate archives.


== pygame.font.get_fonts ==

      get all available fonts
      pygame.font.get_fonts(): return list of strings

      Returns a list of all the fonts available on the system. The names of the fonts will be set to lowercase with all spaces and punctuation removed. This works on most systems, but some will return an empty list if they cannot find fonts.


== pygame.font.match_font ==

      find a specific font on the system
      pygame.font.match_font(name, bold=False, italic=False): return path

      Returns the full path to a font file on the system. If bold or italic are set to true, this will attempt to find the correct family of font.

      The font name can actually be a comma separated list of font names to try. If none of the given names are found, None is returned.

      Example:

          print pygame.font.match_font('bitstreamverasans')
          # output is: /usr/share/fonts/truetype/ttf-bitstream-vera/Vera.ttf
          # (but only if you have Vera on your system)


== pygame.font.SysFont ==

      create a Font object from the system fonts
      pygame.font.SysFont(name, size, bold=False, italic=False): return Font

      Return a new Font object that is loaded from the system fonts. The font will match the requested bold and italic flags. If a suitable system font is not found this will fallback on loading the default pygame font. The font name can be a comma separated list of font names to look for.

== pygame.font.Font ==

      create a new Font object from a file
      pygame.font.Font(filename, size): return Font
      pygame.font.Font(object, size): return Font
            Font.render - draw text on a new Surface draw text on a new Surface
            Font.size - determine the amount of space needed to render text determine the amount of space needed to render text
            Font.set_underline - control if text is rendered with an underline control if text is rendered with an underline
            Font.get_underline - check if text will be rendered with an underline check if text will be rendered with an underline
            Font.set_bold - enable fake rendering of bold text enable fake rendering of bold text
            Font.get_bold - check if text will be rendered bold check if text will be rendered bold
            Font.set_italic - enable fake rendering of italic text enable fake rendering of italic text
            Font.get_italic - check if the text will be rendered italic check if the text will be rendered italic
            Font.get_linesize - get the line space of the font text get the line space of the font text
            Font.get_height - get the height of the font get the height of the font
            Font.get_ascent - get the ascent of the font get the ascent of the font
            Font.get_descent - get the descent of the font get the descent of the font

      Load a new font from a given filename or a python file object. The size is the height of the font in pixels. If the filename is None the Pygame default font will be loaded. If a font cannot be loaded from the arguments given an exception will be raised. Once the font is created the size cannot be changed.

      Font objects are mainly used to render text into new Surface objects. The render can emulate bold or italic features, but it is better to load from a font with actual italic or bold glyphs. The rendered text can be regular strings or unicode.
       
=== Font.render ===

      draw text on a new Surface
      Font.render(text, antialias, color, background=None): return Surface

      This creates a new Surface with the specified text rendered on it. Pygame provides no way to directly draw text on an existing Surface: instead you must use Font.render - draw text on a new Surface to create an image (Surface) of the text, then blit this image onto another Surface.

      The text can only be a single line: newline characters are not rendered. The antialias argument is a boolean: if true the characters will have smooth edges. The color argument is the color of the text [e.g.: (0,0,255) for blue]. The optional background argument is a color to use for the text background. If no background is passed the area outside the text will be transparent.

      The Surface returned will be of the dimensions required to hold the text. (the same as those returned by Font.size()). If an empty string is passed for the text, a blank surface will be returned that is one pixel wide and the height of the font.

      Depending on the type of background and antialiasing used, this returns different types of Surfaces. For performance reasons, it is good to know what type of image will be used. If antialiasing is not used, the return image will always be an 8bit image with a two color palette. If the background is transparent a colorkey will be set. Antialiased images are rendered to 24-bit RGB images. If the background is transparent a pixel alpha will be included.

      Optimization: if you know that the final destination for the text (on the screen) will always have a solid background, and the text is antialiased, you can improve performance by specifying the background color. This will cause the resulting image to maintain transparency information by colorkey rather than (much less efficient) alpha values.

      If you render '\n' a unknown char will be rendered. Usually a rectangle. Instead you need to handle new lines yourself.

      Font rendering is not thread safe: only a single thread can render text any time.


=== Font.size ===

      determine the amount of space needed to render text
      Font.size(text): return (width, height)

      Returns the dimensions needed to render the text. This can be used to help determine the positioning needed for text before it is rendered. It can also be used for wordwrapping and other layout effects.

      Be aware that most fonts use kerning which adjusts the widths for specific letter pairs. For example, the width for "ae" will not always match the width for "a" + "e".


=== Font.set_underline ===

      control if text is rendered with an underline
      Font.set_underline(bool): return None

      When enabled, all rendered fonts will include an underline. The underline is always one pixel thick, regardless of font size. This can be mixed with the bold and italic modes.
       

=== Font.get_underline ===

      check if text will be rendered with an underline
      Font.get_underline(): return bool

      Return True when the font underline is enabled.
       

=== Font.set_bold ===

      enable fake rendering of bold text
      Font.set_bold(bool): return None

      Enables the bold rendering of text. This is a fake stretching of the font that doesn't look good on many font types. If possible load the font from a real bold font file. While bold, the font will have a different width than when normal. This can be mixed with the italic and underline modes.
       

=== Font.get_bold ===

      check if text will be rendered bold
      Font.get_bold(): return bool

      Return True when the font bold rendering mode is enabled.
       

=== Font.set_italic ===

      enable fake rendering of italic text
      Font.set_bold(bool): return None

      Enables fake rendering of italic text. This is a fake skewing of the font that doesn't look good on many font types. If possible load the font from a real italic font file. While italic the font will have a different width than when normal. This can be mixed with the bold and underline modes.
       

=== Font.get_italic ===

      check if the text will be rendered italic
      Font.get_italic(): return bool

      Return True when the font italic rendering mode is enabled.
       

=== Font.get_linesize ===

      get the line space of the font text
      Font.get_linesize(): return int

      Return the height in pixels for a line of text with the font. When rendering multiple lines of text this is the recommended amount of space between lines.
       

=== Font.get_height ===

      get the height of the font
      Font.get_height(): return int

      Return the height in pixels of the actual rendered text. This is the average size for each glyph in the font.
       

=== Font.get_ascent ===

      get the ascent of the font
      Font.get_ascent(): return int

      Return the height in pixels for the font ascent. The ascent is the number of pixels from the font baseline to the top of the font.
       

=== Font.get_descent ===

      get the descent of the font
      Font.get_descent(): return int

      Return the height in pixels for the font descent. The descent is the number of pixels from the font baseline to the bottom of the font.
<<TableOfContents>>

= 图像处理 =

== 读取和保存 ==
使用pygame.image模块,可以对图像进行读取和保存。

使用pygame.image.load读取图像文件。{{{
img = pygame.image.load(filename)
}}}可以读取文件名为filename的图像文件,pygame会自动确定文件的类型(比如GIF或者BMP),一般来说支持JPG、PNG、GIF (non animated)、BMP、PCX、TGA (uncompressed)、TIF、LBM (及PBM)、PBM (及PGM, PPM)、XPM等。它返回一个包含图像的Surface,Surface的格式和原来的文件相同(包括颜色格式、透明色和alpha透明)。

使用pygame.image.save可以把图像保存到文件中。{{{
pygame.image.save(img, filename)
}}}这个函数可以把img这个Surface的内容保存为filename指定的图像文件,文件格式可以是BMP、TGA、PNG或者JPEG。如果文件扩展名不认识,默认保存为TGA格式。TGA和BMP格式都是非压缩的文件。

还有pygame.image.tostring、pygame.image.fromstring、pygame.image.frombuffer函数可以把图像序列化,即把图像保存在字符串中或者从字符串中读取图像。

== 变换 ==
使用pygame.transform模块中的函数,可以对图像进行简单的变换。所有的这些函数都需要一个Surface参数指明要处理的图像,并生成一个新的图像表示处理后的结果,原来的图像不会被改变。

使用pygame.transform.flip可以上下左右颠倒图像,比如{{{
newimg = pygame.transform.flip(img, True, False)
}}}第一个参数指定要翻转的图像,第二个参数指定是否对图像进行左右颠倒,第三个参数指定是否对图像进行上下颠倒。函数返回颠倒后的图像。

使用pygame.transform.scale可以对图像进行缩放,比如{{{
newimg = pygame.transform.resize(img, (640, 480))
}}}第一个参数指定要缩放的图像,第二个参数指定缩放后的图像大小,函数返回缩放后的图像。

使用pygame.transform.rotate可以对图像进行旋转,比如{{{
newimg = pygame.transform.rotate(img, 30.0)
}}}第一个参数指定要旋转的图像,第二个参数指定旋转的角度数,正值为逆时针旋转,负值是顺时针旋转。函数返回旋转后的图像。旋转后的图像可能比原来的图像大,才能够容纳原来的整个图像,空出来的部分会补上透明色或者原来图像的左上角点的颜色。

使用pygame.transform.rotozoom可以对图像进行缩放并旋转,比如{{{
newimg = pygame.transform.rotozoom(img, 30.0, 2.0)
}}}第一个参数指定要处理的图像,第二个参数指定旋转的角度数,第三个参数指定缩放的比例。返回处理后的图像。这个函数和前面两个函数不一样,这个函数会对图像进行滤波处理,图像效果会更好,但是速度会慢很多。

使用pygame.transform.scale2x可以对图像进行快速的两倍大小的放大,比如{{{
newimg = pygame.transform.scale2x(img)
}}}

使用pygame.transform.chop可以对图像进行裁减,比如{{{
newimg = pygame.transform.chop(img, (100, 100, 200, 200))
}}}第一个参数指定要裁减的图像,第二个参数指定要保留的图像的区域。返回裁减后留下的图像。

= 对surface的控制 =

== 像素格式 ==
pygame里的Surface是用来表示图像的对象。Surface有一定的大小和像素格式。在创建的时候,可以指定。{{{
pygame.Surface((width, height), flags=0, depth=0, masks=None): return Surface
pygame.Surface((width, height), flags=0, Surface): return Surface
}}}
如果是8bit像素格式的Surface,它还会用一个调色板映射到24比特颜色。像素格式可以通过指定像素深度或者已有的Surface来控制。flags标志位参数是其他一些Surface选项的集合,你可以指定如下的标志

    * HWSURFACE, 在视频内存中创建图像
    * SRCALPHA, 像素格式中会包含一个alpha通道

这些参数都仅仅是一个请求,在实际中可能并不能实现。高级用户可以组合一组颜色屏蔽位,masks是4个整数的集合,表示像素里的哪个位用来表示一种颜色。一般的Surface不需要masks参数。

8bit的Surface有一个调色板,把8bit的整数映射到RGB彩色。通过下面函数可以对调色板进行设置:{{{
Surface.set_at(index, RGB): return None
Surface.set_palette([RGB, RGB, RGB, ...]): return None
}}}通过下面的函数可以获得当前的调色板:{{{
Surface.get_palette(): return [RGB, RGB, RGB, ...]
Surface.get_palette_at(index): return RGB
}}}

不同像素类型的Surface之间的blit操作是很慢的,所以一般在blit之前要先通过Surface.convert对图像进行像素格式的变换。Surface.convert有多种不同的用法{{{
Surface.convert(Surface): return Surface
Surface.convert(depth, flags=0): return Surface
Surface.convert(masks, flags=0): return Surface
Surface.convert(): return Surface
}}}新的像素格式可以由现存其它Surface确定,也可以由depth,flags或者masks决定。这些参数和pygame.Surface的参数类似。

如果没有参数,新的Surface会和display Surface的像素格式一样。这是画图最快的格式。转换所有需要多次blit的Surface是一个好主意。

转换出来的Surface不会有像素alpha。如果原来的Surface里面有,他们会被去掉。参看Surface.convert_alpha来保留或者创建每像素alpha。

如果Surface是有alpha通道的,并且需要保留这个信息,则需要使用Surface.convert_alpha:{{{
Surface.convert_alpha(Surface): return Surface
Surface.convert_alpha(): return Surface
}}}

== 块复制 ==
一个图像复制到另一个上面,这是游戏中最常用的操作,由blit函数来实现{{{
Surface.blit(source, dest, area=None, special_flags = 0): return Rect
}}}画的位置可以由dest参数指定。dest可以是一对坐标值,表示源Surface的左上角在这个Surface上的坐标。dest也可以是一个矩形,矩形的左上角作为blit的位置,而矩形的大小不影响blit。

有一个可选的area矩形参数,可以用来指定只画源Surface的一部分。

一个可选的special_flags参数,可以是BLEND_ADD、BLEND_SUB、BLEND_MULT、BLEND_MIN、BLEND_MAX。将来也可能有其它特殊标记添加进来。

函数返回的矩形表示受影响的像素的区域,不包括目标Surface以外的像素,也不包括剪切区域以外的像素。



== 透明 ==
pygame支持三种类型的透明:透明色(colorkey),Surface alpha和每像素alpha。Surface alpha可以和透明色(colorkey)混合使用,但是有像素alpha的图像不能够使用其它模式。透明色(colorkey)让一种颜色值透明。任何和这个颜色相同的像素都不会被画出来。Surface alpha值是单独一个值用来改变整个图像的透明度。Surface alpha值是255表示不透明,值是0表示全透明。而每像素alpha是不一样的,它为每个像素保存了一个透明值。这种方法允许精确的控制透明效果,但是这种方法也是最慢的。每像素alpha不能和其它方法混用。

要设置透明色,使用Surface.set_colorkey函数:{{{
Surface.set_colorkey(Color, flags=0): return None
Surface.set_colorkey(None): return None
}}}当把这个Surface blit到令一个Surface时候,和这个透明色颜色相同的像素会变成透明。color参数可以是RGB颜色或者是一个映射的整数。如果传送的是None,则Surface会没有透明色。如果是有每像素透明的Surface,透明色会被忽略。透明色可以和Surface alpha混合使用。可选的flags参数可以是pygame.RLEACCEL,用来在没有加速的时候提供更好的性能。设置了RLEACCEL的Surface作为源Surface blit更快,但是修改Surface的内容会更慢。

Surface的当前透明色可以通过Surface.get_colorkey获得:{{{
Surface.get_colorkey(): return RGB or None
}}}如果没有透明色,则函数返回None。


要设置Surface的alpha值,可以通过Surface.set_alpha来实现:{{{
Surface.set_alpha(value, flags=0): return None
Surface.set_alpha(None): return None
}}}透明值value可以取0到255之间的值,0是完全透明,255是完全不透明。如果value是None,则Surface就没有alpha透明了。

Surface当前的alpha值可以通过Surface.get_alpha获得:{{{
Surface.get_alpha(): return int_value or None
}}}如果没有alpha透明,则这个函数返回None。

每像素在绘图的时侯可以通过颜色元组的第四个参数指定。

== 剪切区域 ==
每个Surface包含一个剪切区域。默认情况下,剪切区域是整个Surface。如果改变了剪切区域,所有的画图操作都会限制在一个比较小的范围之内。

通过Surface.set_clip可以设置剪切区域:{{{
Surface.set_clip(rect): return None
Surface.set_clip(None): return None
}}}如果参数是None,则整个Surface都可以修改。剪切区域总是在Surface本身的区域只内的。如果剪切区域比Surface的区域大,则会自动缩小到Surface区域之内。


要获得Surface的当前剪切区域,可以通过Surface.get_clip:{{{
Surface.get_clip(): return Rect
}}}一个Surface总是返回一个有效的矩形,不会超过图像的边界范围。如果Surface设置了None作为剪切区域,则Surface会返回整个Surface的区域。

== 锁定 ==
对于硬件加速的Surface,它有可能被存在显示内存中。要访问这些Surface上面的像素,就必须先通过Surface.lock对像素进行锁定:{{{
Surface.lock(): return None
}}}锁定完后,可以对Surface上的像素进行操作,操作完成后,应该及时解锁:{{{
Surface.unlock(): return None
}}}一个Surface是否要先锁定再操作,可以通过Surface.mustlock来判断:{{{
Surface.mustlock(): return bool
}}}这个函数返回Ture则需要锁定,否则不需要锁定。一个Surface当前的锁定状态可以通过Surface.get_locked来获得:{{{
Surface.get_locked(): return bool
}}}这个函数返回True表示已经锁定了,False表示没有锁定。

实际上,pygame中所有需要锁定Surface才能操作的函数都会自动地对Surface锁定和解锁。一般情况下不需要调用lock和unlock函数。但是如果在一段代码中需要反复对Surface上的像素进行操作,则每次都进行锁定和解锁会非常的慢,所以可以在这一串操作开始的时候进行锁定,这一串操作结束后解锁,避免重复的锁定解锁操作。


= 绘图 =
除了可以把事先画好的图片blit到Surface上以外,还可以在Surface上自行在Surface上绘制一些简单的图形,比如点、线、方、圆等。这个功能主要由pygame.draw模块完成。

首先导入pygame.draw模块。{{{
import pygame.draw
}}}如果已经用了{{{import pygame}}},则pygame.draw模块也被自动导入了。

然后准备好要在上面绘制图形的Surface,比如{{{
surface = pygame.display.set_mode((640, 480))
}}}

== 画矩形 ==

接下来就可以在surface上面绘制想要的图形了。比如说画矩形可以使用pygame.draw.rect函数:{{{
pygame.draw.rect(surface, (0,0,255), (100, 200, 100, 100))
}}}第一个参数指定在哪个Surface上画矩形,第二个参数是矩形的颜色,第三个参数是矩形的位置和大小。

颜色的参数一般是一个由红绿蓝三种颜色值构成的三元组,0是最暗的,255是最亮的。比如(0,0,255)是纯蓝色,(255,0,0)是纯红色,(0,0,0)是黑色,(255,255,255)是白色等等。有时候也可以使用RGBA四元组来表示颜色。如果Surface包含alpha,四元组中alpha值会被直接写入到Surface里面,画图函数并不会进行透明的绘画。颜色参数也可以是一个整数,是映射到Surface里的像素值。其他绘图函数里面的颜色参数也是一样的。

矩形参数由四个值构成的元组,分别是矩形左上角的x、y坐标,矩形的宽和高。

默认情况下,画出来的矩形是实心的(中间填充了指定的颜色)。如果要画一个只有边框的矩形,可以指定一个可选的参数width。比如{{{
pygame.draw.rect(surface, (0,0,255), (100, 200, 100, 100), 2)
}}}可以在屏幕上画一个边框是2个像素粗的矩形,中间是透明的。如果不指定这个width参数,或者width指定为0,则画出来的矩形就是实心的。其他有些绘图函数里面也有类似的参数,功能也是相似的。

pygame.draw.rect函数返回一个矩形,表示屏幕上被修改的像素的区域范围。其它绘图函数也都有这样的返回值。

== 画多边形 ==

用pygame.draw.polygon可以在Surface上画一个多边形。比如{{{
pygame.draw.polygon(surface, (255,0,0), [(100, 100),(200, 100),(250,186.6),(200,273.2),(100, 273.2),(50,186.6)])
}}}
第三个参数pointlist参数是多边形顶点的列表。可选的第四个width参数是多边形的边的粗细。如果width是0或者被忽略,多边形是被填充的。{{{
pygame.draw.polygon(surface, (0,255,0), [(100, 100),(200, 100),(250,186.6),(200,273.2),(100, 273.2),(50,186.6)],1)
}}}

== 画圆 ==

pygame.draw.circle在Surface上画一个圆形。{{{
pygame.draw.circle(surface, (255,255,0), (100, 100), 50)
}}}第三个参数pos是圆的圆心,第四个参数radius是半径大小。可选的第五个参数width是圆边的粗细,如果width缺省或者是0圆会被填充。

== 画椭圆 ==

pygame.draw.ellipse在矩形区域中画一个椭圆的形状。比如{{{
pygame.draw.ellipse(surface, (0,255,255), (200, 200, 200, 100))
}}}第三个参数指定的矩形区域是椭圆填充的区域。可选的第四个参数width是边的粗细。如果width缺省或者是0,椭圆会被填充。

== 画弧线 ==

pygame.draw.arc画椭圆的一段。比如{{{
pygame.draw.arc(surface, (0,255,0), (200, 200, 200, 100), 3.14159/3, 3.14159*2/3)
}}}
在Surface上画一个椭圆状的弧线。第三个参数rect指定椭圆填充的矩形。接下来两个角度参数指定起始和终止的角度(以弧度为单位),朝右为0度。可选的第六个参数width是弧线的粗细,默认值是1。

== 画线段 ==
pygame.draw.line函数可以画一条直线段。比如{{{
pygame.draw.line(surface, (255,0,255), (100, 100), (200, 200))
}}}第三个参数指定起点,第四个参数指定终点。可选的第五个参数width指定线的宽度,默认是1。线段终点没有箭头,宽的线段终点是方形的。


== 画连续的线段 ==
pygame.draw.lines画多条连续的线段。比如{{{
pygame.draw.lines(surface, (255,255,255), False, [(100, 100), (200, 200), (300, 200), (200, 100)])
}}}第四个参数pointlist是一系列点的列表。如果第三个参数是True,则在最后一点和第一点之间会画一条线段。可选的第五个参数表示线的宽度,默认为1。这个函数不会画终点箭头和中间连接头。线段有尖锐的拐角,粗的线段会有不太好看的拐角。

== 抗锯齿的线段 ==
pygame.draw.aaline画抗锯齿的线段。{{{
pygame.draw.aaline(surface, (255,255,0), (200, 100), (300, 200))
}}}这个函数的用法和画线段的函数差不多,只是画出来的线段有抗锯齿效果,看上去比较光滑。有一个可选的第五个参数blend,如果blend是True,则阴影部分是和原始像素混合而不是直接覆盖的。这个函数接受浮点数作为点的坐标。

pygame.draw.aalines可以画多条连续的抗锯齿线段。{{{
pygame.draw.aalines(surface, (0,0, 255), False, [(100, 100), (200, 200), (300, 100), (200, 0)])
}}}如果第三个参数如果是True,则在第一个点和最后一点之间会画一条直线。有一个可选的第五个参数blend,如果blend参数是True,则阴影部分是和原始像素混合而不是直接覆盖的。这个函数接受浮点数作为点的坐标。

== 点操作 ==
画点的方法和其它方法不太一样,用Surface.set_at方法完成画点的操作,比如:{{{
surface.set_at((100, 100), (255,255,255))
}}}第一个参数是点的坐标,第二个参数是颜色。在游戏和实时模拟中,一次取得和设置一个像素是很慢的。

除了可以在Surface上画点,还可以用Surface.get_at读取Surface上像素的值。比如{{{
color = surface.get_at((100, 100))
}}}这个函数返回给定点的颜色值。

== 填充区域 ==
Surface.fill方法可以用一种颜色填充一个矩形区域。比如{{{
surface.fill((255,0,0), (100, 200, 100, 100))
}}}第一个参数指定要填充的颜色,第二个参数指定填充的矩形区域。如果没有给定第二个参数,整个Surface会被填充。第二个参数会限制备填充的区域。这个函数会返回受影响的Surface区域。

= 写字 =

相对于在Surface上画图,在Surface上写文字要复杂得多。

首先需要导入pygame.font模块并初始化。{{{
import pygame.font
pygame.font.init()
}}}

== 选择字体 ==

然后用pygame.font.get_fonts获取可用的字体的列表。{{{
pygame.font.get_fonts()
}}}它返回一个字体名字的列表。

然后再用字体名字列表中的一个名字可以创建一个字体对象。{{{
font = pygame.font.SysFont("monospace", 12)
}}}第一个参数指定字体的名字,第二个参数指定字体的大小。可选的第三个参数bold指定是否粗体,默认不是粗题。可选的地四个参数italic指定是否斜体,默认不是斜体。

如果是要使用自己给的字体文件,可以这样创建字体对象{{{
font = pygame.font.Font("/usr/share/fonts/truetype/arphic/uming.ttf", 12)
}}}第一个参数指定要载入的字体文件的完整路径,第二个参数指定字体的大小。

== 创建文字Surface ==
使用字体对象的Font.render函数可以创建一个Surface,里面包含写出来的文字。比如{{{
font_surface = font.render("Hello world!", False, (255,0,0))
}}}第一个参数是要写的文字,文字只能包含一行,换行符不会被画出来。第二个参数指定是否使用抗锯齿效果,如果是True字符会有光滑的边缘。第三个参数是字体的颜色。可选的第四个参数background用来指定文字背景的颜色。如果没有指定background,背景是透明的。返回创建的Surface,它上面包含了画出来的文字,它的大小是能容纳这些字的最小的大小。

要在已有的Surface上写字,只能先创建一个只包含文字的Surface,然后把它blit到已有的Surface上。比如:{{{
surface.blit(font_surface, (100, 100))
}}}

图像处理

1. 读取和保存

使用pygame.image模块,可以对图像进行读取和保存。

使用pygame.image.load读取图像文件。

img = pygame.image.load(filename)

可以读取文件名为filename的图像文件,pygame会自动确定文件的类型(比如GIF或者BMP),一般来说支持JPG、PNG、GIF (non animated)、BMP、PCX、TGA (uncompressed)、TIF、LBM (及PBM)、PBM (及PGM, PPM)、XPM等。它返回一个包含图像的Surface,Surface的格式和原来的文件相同(包括颜色格式、透明色和alpha透明)。

使用pygame.image.save可以把图像保存到文件中。

pygame.image.save(img, filename)

这个函数可以把img这个Surface的内容保存为filename指定的图像文件,文件格式可以是BMP、TGA、PNG或者JPEG。如果文件扩展名不认识,默认保存为TGA格式。TGA和BMP格式都是非压缩的文件。

还有pygame.image.tostring、pygame.image.fromstring、pygame.image.frombuffer函数可以把图像序列化,即把图像保存在字符串中或者从字符串中读取图像。

2. 变换

使用pygame.transform模块中的函数,可以对图像进行简单的变换。所有的这些函数都需要一个Surface参数指明要处理的图像,并生成一个新的图像表示处理后的结果,原来的图像不会被改变。

使用pygame.transform.flip可以上下左右颠倒图像,比如

newimg = pygame.transform.flip(img, True, False)

第一个参数指定要翻转的图像,第二个参数指定是否对图像进行左右颠倒,第三个参数指定是否对图像进行上下颠倒。函数返回颠倒后的图像。

使用pygame.transform.scale可以对图像进行缩放,比如

newimg = pygame.transform.resize(img, (640, 480))

第一个参数指定要缩放的图像,第二个参数指定缩放后的图像大小,函数返回缩放后的图像。

使用pygame.transform.rotate可以对图像进行旋转,比如

newimg = pygame.transform.rotate(img, 30.0)

第一个参数指定要旋转的图像,第二个参数指定旋转的角度数,正值为逆时针旋转,负值是顺时针旋转。函数返回旋转后的图像。旋转后的图像可能比原来的图像大,才能够容纳原来的整个图像,空出来的部分会补上透明色或者原来图像的左上角点的颜色。

使用pygame.transform.rotozoom可以对图像进行缩放并旋转,比如

newimg = pygame.transform.rotozoom(img, 30.0, 2.0)

第一个参数指定要处理的图像,第二个参数指定旋转的角度数,第三个参数指定缩放的比例。返回处理后的图像。这个函数和前面两个函数不一样,这个函数会对图像进行滤波处理,图像效果会更好,但是速度会慢很多。

使用pygame.transform.scale2x可以对图像进行快速的两倍大小的放大,比如

newimg = pygame.transform.scale2x(img)

使用pygame.transform.chop可以对图像进行裁减,比如

newimg = pygame.transform.chop(img, (100, 100, 200, 200))

第一个参数指定要裁减的图像,第二个参数指定要保留的图像的区域。返回裁减后留下的图像。

对surface的控制

1. 像素格式

pygame里的Surface是用来表示图像的对象。Surface有一定的大小和像素格式。在创建的时候,可以指定。

pygame.Surface((width, height), flags=0, depth=0, masks=None): return Surface
pygame.Surface((width, height), flags=0, Surface): return Surface

如果是8bit像素格式的Surface,它还会用一个调色板映射到24比特颜色。像素格式可以通过指定像素深度或者已有的Surface来控制。flags标志位参数是其他一些Surface选项的集合,你可以指定如下的标志

  • HWSURFACE, 在视频内存中创建图像
  • SRCALPHA, 像素格式中会包含一个alpha通道

这些参数都仅仅是一个请求,在实际中可能并不能实现。高级用户可以组合一组颜色屏蔽位,masks是4个整数的集合,表示像素里的哪个位用来表示一种颜色。一般的Surface不需要masks参数。

8bit的Surface有一个调色板,把8bit的整数映射到RGB彩色。通过下面函数可以对调色板进行设置:

Surface.set_at(index, RGB): return None
Surface.set_palette([RGB, RGB, RGB, ...]): return None

通过下面的函数可以获得当前的调色板:

Surface.get_palette(): return [RGB, RGB, RGB, ...]
Surface.get_palette_at(index): return RGB

不同像素类型的Surface之间的blit操作是很慢的,所以一般在blit之前要先通过Surface.convert对图像进行像素格式的变换。Surface.convert有多种不同的用法

Surface.convert(Surface): return Surface
Surface.convert(depth, flags=0): return Surface
Surface.convert(masks, flags=0): return Surface
Surface.convert(): return Surface

新的像素格式可以由现存其它Surface确定,也可以由depth,flags或者masks决定。这些参数和pygame.Surface的参数类似。

如果没有参数,新的Surface会和display Surface的像素格式一样。这是画图最快的格式。转换所有需要多次blit的Surface是一个好主意。

转换出来的Surface不会有像素alpha。如果原来的Surface里面有,他们会被去掉。参看Surface.convert_alpha来保留或者创建每像素alpha。

如果Surface是有alpha通道的,并且需要保留这个信息,则需要使用Surface.convert_alpha:

Surface.convert_alpha(Surface): return Surface
Surface.convert_alpha(): return Surface

2. 块复制

一个图像复制到另一个上面,这是游戏中最常用的操作,由blit函数来实现

Surface.blit(source, dest, area=None, special_flags = 0): return Rect

画的位置可以由dest参数指定。dest可以是一对坐标值,表示源Surface的左上角在这个Surface上的坐标。dest也可以是一个矩形,矩形的左上角作为blit的位置,而矩形的大小不影响blit。

有一个可选的area矩形参数,可以用来指定只画源Surface的一部分。

一个可选的special_flags参数,可以是BLEND_ADD、BLEND_SUB、BLEND_MULT、BLEND_MIN、BLEND_MAX。将来也可能有其它特殊标记添加进来。

函数返回的矩形表示受影响的像素的区域,不包括目标Surface以外的像素,也不包括剪切区域以外的像素。

3. 透明

pygame支持三种类型的透明:透明色(colorkey),Surface alpha和每像素alpha。Surface alpha可以和透明色(colorkey)混合使用,但是有像素alpha的图像不能够使用其它模式。透明色(colorkey)让一种颜色值透明。任何和这个颜色相同的像素都不会被画出来。Surface alpha值是单独一个值用来改变整个图像的透明度。Surface alpha值是255表示不透明,值是0表示全透明。而每像素alpha是不一样的,它为每个像素保存了一个透明值。这种方法允许精确的控制透明效果,但是这种方法也是最慢的。每像素alpha不能和其它方法混用。

要设置透明色,使用Surface.set_colorkey函数:

Surface.set_colorkey(Color, flags=0): return None
Surface.set_colorkey(None): return None

当把这个Surface blit到令一个Surface时候,和这个透明色颜色相同的像素会变成透明。color参数可以是RGB颜色或者是一个映射的整数。如果传送的是None,则Surface会没有透明色。如果是有每像素透明的Surface,透明色会被忽略。透明色可以和Surface alpha混合使用。可选的flags参数可以是pygame.RLEACCEL,用来在没有加速的时候提供更好的性能。设置了RLEACCEL的Surface作为源Surface blit更快,但是修改Surface的内容会更慢。

Surface的当前透明色可以通过Surface.get_colorkey获得:

Surface.get_colorkey(): return RGB or None

如果没有透明色,则函数返回None。

要设置Surface的alpha值,可以通过Surface.set_alpha来实现:

Surface.set_alpha(value, flags=0): return None
Surface.set_alpha(None): return None

透明值value可以取0到255之间的值,0是完全透明,255是完全不透明。如果value是None,则Surface就没有alpha透明了。

Surface当前的alpha值可以通过Surface.get_alpha获得:

Surface.get_alpha(): return int_value or None

如果没有alpha透明,则这个函数返回None。

每像素在绘图的时侯可以通过颜色元组的第四个参数指定。

4. 剪切区域

每个Surface包含一个剪切区域。默认情况下,剪切区域是整个Surface。如果改变了剪切区域,所有的画图操作都会限制在一个比较小的范围之内。

通过Surface.set_clip可以设置剪切区域:

Surface.set_clip(rect): return None
Surface.set_clip(None): return None

如果参数是None,则整个Surface都可以修改。剪切区域总是在Surface本身的区域只内的。如果剪切区域比Surface的区域大,则会自动缩小到Surface区域之内。

要获得Surface的当前剪切区域,可以通过Surface.get_clip:

Surface.get_clip(): return Rect

一个Surface总是返回一个有效的矩形,不会超过图像的边界范围。如果Surface设置了None作为剪切区域,则Surface会返回整个Surface的区域。

5. 锁定

对于硬件加速的Surface,它有可能被存在显示内存中。要访问这些Surface上面的像素,就必须先通过Surface.lock对像素进行锁定:

Surface.lock(): return None

锁定完后,可以对Surface上的像素进行操作,操作完成后,应该及时解锁:

Surface.unlock(): return None

一个Surface是否要先锁定再操作,可以通过Surface.mustlock来判断:

Surface.mustlock(): return bool

这个函数返回Ture则需要锁定,否则不需要锁定。一个Surface当前的锁定状态可以通过Surface.get_locked来获得:

Surface.get_locked(): return bool

这个函数返回True表示已经锁定了,False表示没有锁定。

实际上,pygame中所有需要锁定Surface才能操作的函数都会自动地对Surface锁定和解锁。一般情况下不需要调用lock和unlock函数。但是如果在一段代码中需要反复对Surface上的像素进行操作,则每次都进行锁定和解锁会非常的慢,所以可以在这一串操作开始的时候进行锁定,这一串操作结束后解锁,避免重复的锁定解锁操作。

绘图

除了可以把事先画好的图片blit到Surface上以外,还可以在Surface上自行在Surface上绘制一些简单的图形,比如点、线、方、圆等。这个功能主要由pygame.draw模块完成。

首先导入pygame.draw模块。

import pygame.draw

如果已经用了import pygame,则pygame.draw模块也被自动导入了。

然后准备好要在上面绘制图形的Surface,比如

surface = pygame.display.set_mode((640, 480))

1. 画矩形

接下来就可以在surface上面绘制想要的图形了。比如说画矩形可以使用pygame.draw.rect函数:

pygame.draw.rect(surface, (0,0,255), (100, 200, 100, 100))

第一个参数指定在哪个Surface上画矩形,第二个参数是矩形的颜色,第三个参数是矩形的位置和大小。

颜色的参数一般是一个由红绿蓝三种颜色值构成的三元组,0是最暗的,255是最亮的。比如(0,0,255)是纯蓝色,(255,0,0)是纯红色,(0,0,0)是黑色,(255,255,255)是白色等等。有时候也可以使用RGBA四元组来表示颜色。如果Surface包含alpha,四元组中alpha值会被直接写入到Surface里面,画图函数并不会进行透明的绘画。颜色参数也可以是一个整数,是映射到Surface里的像素值。其他绘图函数里面的颜色参数也是一样的。

矩形参数由四个值构成的元组,分别是矩形左上角的x、y坐标,矩形的宽和高。

默认情况下,画出来的矩形是实心的(中间填充了指定的颜色)。如果要画一个只有边框的矩形,可以指定一个可选的参数width。比如

pygame.draw.rect(surface, (0,0,255), (100, 200, 100, 100), 2)

可以在屏幕上画一个边框是2个像素粗的矩形,中间是透明的。如果不指定这个width参数,或者width指定为0,则画出来的矩形就是实心的。其他有些绘图函数里面也有类似的参数,功能也是相似的。

pygame.draw.rect函数返回一个矩形,表示屏幕上被修改的像素的区域范围。其它绘图函数也都有这样的返回值。

2. 画多边形

用pygame.draw.polygon可以在Surface上画一个多边形。比如

pygame.draw.polygon(surface, (255,0,0), [(100, 100),(200, 100),(250,186.6),(200,273.2),(100, 273.2),(50,186.6)])

第三个参数pointlist参数是多边形顶点的列表。可选的第四个width参数是多边形的边的粗细。如果width是0或者被忽略,多边形是被填充的。

pygame.draw.polygon(surface, (0,255,0), [(100, 100),(200, 100),(250,186.6),(200,273.2),(100, 273.2),(50,186.6)],1)

3. 画圆

pygame.draw.circle在Surface上画一个圆形。

pygame.draw.circle(surface, (255,255,0), (100, 100), 50)

第三个参数pos是圆的圆心,第四个参数radius是半径大小。可选的第五个参数width是圆边的粗细,如果width缺省或者是0圆会被填充。

4. 画椭圆

pygame.draw.ellipse在矩形区域中画一个椭圆的形状。比如

pygame.draw.ellipse(surface, (0,255,255), (200, 200, 200, 100))

第三个参数指定的矩形区域是椭圆填充的区域。可选的第四个参数width是边的粗细。如果width缺省或者是0,椭圆会被填充。

5. 画弧线

pygame.draw.arc画椭圆的一段。比如

pygame.draw.arc(surface, (0,255,0), (200, 200, 200, 100), 3.14159/3, 3.14159*2/3)

在Surface上画一个椭圆状的弧线。第三个参数rect指定椭圆填充的矩形。接下来两个角度参数指定起始和终止的角度(以弧度为单位),朝右为0度。可选的第六个参数width是弧线的粗细,默认值是1。

== 画线段 == pygame.draw.line函数可以画一条直线段。比如

pygame.draw.line(surface, (255,0,255), (100, 100), (200, 200))

第三个参数指定起点,第四个参数指定终点。可选的第五个参数width指定线的宽度,默认是1。线段终点没有箭头,宽的线段终点是方形的。

6. 画连续的线段

pygame.draw.lines画多条连续的线段。比如

pygame.draw.lines(surface, (255,255,255), False, [(100, 100), (200, 200), (300, 200), (200, 100)])

第四个参数pointlist是一系列点的列表。如果第三个参数是True,则在最后一点和第一点之间会画一条线段。可选的第五个参数表示线的宽度,默认为1。这个函数不会画终点箭头和中间连接头。线段有尖锐的拐角,粗的线段会有不太好看的拐角。

7. 抗锯齿的线段

pygame.draw.aaline画抗锯齿的线段。

pygame.draw.aaline(surface, (255,255,0), (200, 100), (300, 200))

这个函数的用法和画线段的函数差不多,只是画出来的线段有抗锯齿效果,看上去比较光滑。有一个可选的第五个参数blend,如果blend是True,则阴影部分是和原始像素混合而不是直接覆盖的。这个函数接受浮点数作为点的坐标。

pygame.draw.aalines可以画多条连续的抗锯齿线段。

pygame.draw.aalines(surface, (0,0, 255), False, [(100, 100), (200, 200), (300, 100), (200, 0)])

如果第三个参数如果是True,则在第一个点和最后一点之间会画一条直线。有一个可选的第五个参数blend,如果blend参数是True,则阴影部分是和原始像素混合而不是直接覆盖的。这个函数接受浮点数作为点的坐标。

8. 点操作

画点的方法和其它方法不太一样,用Surface.set_at方法完成画点的操作,比如:

surface.set_at((100, 100), (255,255,255))

第一个参数是点的坐标,第二个参数是颜色。在游戏和实时模拟中,一次取得和设置一个像素是很慢的。

除了可以在Surface上画点,还可以用Surface.get_at读取Surface上像素的值。比如

color = surface.get_at((100, 100))

这个函数返回给定点的颜色值。

9. 填充区域

Surface.fill方法可以用一种颜色填充一个矩形区域。比如

surface.fill((255,0,0), (100, 200, 100, 100))

第一个参数指定要填充的颜色,第二个参数指定填充的矩形区域。如果没有给定第二个参数,整个Surface会被填充。第二个参数会限制备填充的区域。这个函数会返回受影响的Surface区域。

写字

相对于在Surface上画图,在Surface上写文字要复杂得多。

首先需要导入pygame.font模块并初始化。

import pygame.font
pygame.font.init()

1. 选择字体

然后用pygame.font.get_fonts获取可用的字体的列表。

pygame.font.get_fonts()

它返回一个字体名字的列表。

然后再用字体名字列表中的一个名字可以创建一个字体对象。

font = pygame.font.SysFont("monospace", 12)

第一个参数指定字体的名字,第二个参数指定字体的大小。可选的第三个参数bold指定是否粗体,默认不是粗题。可选的地四个参数italic指定是否斜体,默认不是斜体。

如果是要使用自己给的字体文件,可以这样创建字体对象

font = pygame.font.Font("/usr/share/fonts/truetype/arphic/uming.ttf", 12)

第一个参数指定要载入的字体文件的完整路径,第二个参数指定字体的大小。

2. 创建文字Surface

使用字体对象的Font.render函数可以创建一个Surface,里面包含写出来的文字。比如

font_surface = font.render("Hello world!", False, (255,0,0))

第一个参数是要写的文字,文字只能包含一行,换行符不会被画出来。第二个参数指定是否使用抗锯齿效果,如果是True字符会有光滑的边缘。第三个参数是字体的颜色。可选的第四个参数background用来指定文字背景的颜色。如果没有指定background,背景是透明的。返回创建的Surface,它上面包含了画出来的文字,它的大小是能容纳这些字的最小的大小。

要在已有的Surface上写字,只能先创建一个只包含文字的Surface,然后把它blit到已有的Surface上。比如:

surface.blit(font_surface, (100, 100))

The end

Pygame图形接口基础 (2008-02-23 15:34:18由localhost编辑)

ch3n2k.com | Copyright (c) 2004-2020 czk.