Pygame Surface

The raw Pygame surface that represents the screen buffer. You can use this for advanced graphics operations. Clear ¶ Reset the screen to black. Fill ((red, green, blue)) ¶ Fill the screen with a solid color. Blit (image, (left, top)) ¶ Draw the image to the screen at the given position. Blit accepts either a Surface. This method also requires the Surface to be created as a per-pixel alpha Surface, and the color arguments needs to contain a fourth alpha integer. Size = width, height = (32, 32) myimage = pygame.Surface(size, pygame.SRCALPHA) # Creates an empty per-pixel alpha Surface. The targetsurface is the pygame.Surface that will have the lighting rendered onto it. If you render onto a black surface, you get the internal lighting mask. This technique can be useful for static lighting. However, normally you'll be rendering your lighting onto your main display surface.

Pygame Surface Class

The drawing functions are fine if you want to draw simple shapes on the screen, but many games have images (also called sprites). Pygame is able to load images onto Surface objects from PNG, JPG, GIF, and BMP image files. The differences between these image file formats is described at http://invpy.com/formats.

Pygame Surface Alpha

The image of the cat was stored in a file named cat.png. To load this file’s image, the string 'cat.png' is passed to the pygame.image.load() function. The pygame.image.load() function call will return a Surface object that has the image drawn on it. This Surface object will be a separate Surface object from the display Surface object, so we must blit (that is, copy) the image’s Surface object to the display Surface object. Blitting is drawing the contents of one Surface onto another. It is done with the blit() Surface object method.

If you get an error message like 'pygame.error: Couldn't open cat.png' when calling pygame.image.load(), then make sure the cat.png file is in the same folder as the catanimation.py file before you run the program.

Line 39 of the animation program uses the blit() method to copy catImg to DISPLAYSURF. There are two parameters for blit(). The first is the source Surface object, which is what will be copied onto the DISPLAYSURF Surface object. The second parameter is a two-integer tuple for the X and Y values of the topleft corner where the image should be blitted to.

If catx and caty were set to 100 and 200 and the width of catImg was 125 and the height was 79, this blit() call would copy this image onto DISPLAYSURF so that the top left corner of the catImg was at the XY coordinate (100, 200) and the bottom right corner’s XY coordinate was at (225, 279).

Note that you cannot blit to a Surface that is currently 'locked' (such as when a PixelArray object has been made from it and not yet been deleted.)

The rest of the game loop is just changing the catx, caty, and direction variables so that the cat moves around the window. There is also a call to pygame.event.get() to handle the QUIT event.

Pygame Surface Draw

Pygame Surface

Pygame Surface Attributes

    pygame object for representing images
    pygame.Surface((width, height), flags=0, depth=0, masks=None): return Surface
    pygame.Surface((width, height), flags=0, Surface): return Surface
      Surface.blit - draw one image onto anotherdraw one image onto another
      Surface.convert - change the pixel format of an imagechange the pixel format of an image
      Surface.convert_alpha - change the pixel format of an image including per pixel alphaschange the pixel format of an image including per pixel alphas
      Surface.copy - create a new copy of a Surfacecreate a new copy of a Surface
      Surface.fill - fill Surface with a solid colorfill Surface with a solid color
      Surface.scroll - Shift the surface image in placeShift the surface image in place
      Surface.set_colorkey - Set the transparent colorkeySet the transparent colorkey
      Surface.get_colorkey - Get the current transparent colorkeyGet the current transparent colorkey
      Surface.set_alpha - set the alpha value for the full Surface imageset the alpha value for the full Surface image
      Surface.get_alpha - get the current Surface transparency valueget the current Surface transparency value
      Surface.lock - lock the Surface memory for pixel accesslock the Surface memory for pixel access
      Surface.unlock - unlock the Surface memory from pixel accessunlock the Surface memory from pixel access
      Surface.mustlock - test if the Surface requires lockingtest if the Surface requires locking
      Surface.get_locked - test if the Surface is current lockedtest if the Surface is current locked
      Surface.get_locks - Gets the locks for the SurfaceGets the locks for the Surface
      Surface.get_at - get the color value at a single pixelget the color value at a single pixel
      Surface.set_at - set the color value for a single pixelset the color value for a single pixel
      Surface.get_palette - get the color index palette for an 8bit Surfaceget the color index palette for an 8bit Surface
      Surface.get_palette_at - get the color for a single entry in a paletteget the color for a single entry in a palette
      Surface.set_palette - set the color palette for an 8bit Surfaceset the color palette for an 8bit Surface
      Surface.set_palette_at - set the color for a single index in an 8bit Surface paletteset the color for a single index in an 8bit Surface palette
      Surface.map_rgb - convert a color into a mapped color valueconvert a color into a mapped color value
      Surface.unmap_rgb - convert a mapped integer color value into a Colorconvert a mapped integer color value into a Color
      Surface.set_clip - set the current clipping area of the Surfaceset the current clipping area of the Surface
      Surface.get_clip - get the current clipping area of the Surfaceget the current clipping area of the Surface
      Surface.subsurface - create a new surface that references its parentcreate a new surface that references its parent
      Surface.get_parent - find the parent of a subsurfacefind the parent of a subsurface
      Surface.get_abs_parent - find the top level parent of a subsurfacefind the top level parent of a subsurface
      Surface.get_offset - find the position of a child subsurface inside a parentfind the position of a child subsurface inside a parent
      Surface.get_abs_offset - find the absolute position of a child subsurface inside its top level parentfind the absolute position of a child subsurface inside its top level parent
      Surface.get_size - get the dimensions of the Surfaceget the dimensions of the Surface
      Surface.get_width - get the width of the Surfaceget the width of the Surface
      Surface.get_height - get the height of the Surfaceget the height of the Surface
      Surface.get_rect - get the rectangular area of the Surfaceget the rectangular area of the Surface
      Surface.get_bitsize - get the bit depth of the Surface pixel formatget the bit depth of the Surface pixel format
      Surface.get_bytesize - get the bytes used per Surface pixelget the bytes used per Surface pixel
      Surface.get_flags - get the additional flags used for the Surfaceget the additional flags used for the Surface
      Surface.get_pitch - get the number of bytes used per Surface rowget the number of bytes used per Surface row
      Surface.get_masks - the bitmasks needed to convert between a color and a mapped integerthe bitmasks needed to convert between a color and a mapped integer
      Surface.set_masks - set the bitmasks needed to convert between a color and a mapped integerset the bitmasks needed to convert between a color and a mapped integer
      Surface.get_shifts - the bit shifts needed to convert between a color and a mapped integerthe bit shifts needed to convert between a color and a mapped integer
      Surface.set_shifts - sets the bit shifts needed to convert between a color and a mapped integersets the bit shifts needed to convert between a color and a mapped integer
      Surface.get_losses - the significant bits used to convert between a color and a mapped integerthe significant bits used to convert between a color and a mapped integer
      Surface.get_bounding_rect - find the smallest rect containing datafind the smallest rect containing data
      Surface.get_buffer - acquires a buffer object for the pixels of the Surface.acquires a buffer object for the pixels of the Surface.

    A pygame Surface is used to represent any image. The Surface has a fixed resolution and pixel format. Surfaces with 8bit pixels use a color palette to map to 24bit color.

    Call pygame.Surface - pygame object for representing images to create a new image object. The Surface will be cleared to all black. The only required arguments are the sizes. With no additional arguments, the Surface will be created in a format that best matches the display Surface.

    The pixel format can be controlled by passing the bit depth or an existing Surface. The flags argument is a bitmask of additional features for the surface. You can pass any combination of these flags:

    Both flags are only a request, and may not be possible for all displays and formats.

    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 acceleration when possible, otherwise they 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 new in 1.8.0:BLEND_ADD, BLEND_SUB, BLEND_MULT, BLEND_MIN, BLEND_MAX new in 1.8.1:BLEND_RGBA_ADD, BLEND_RGBA_SUB, BLEND_RGBA_MULT, BLEND_RGBA_MIN, BLEND_RGBA_MAXBLEND_RGB_ADD, BLEND_RGB_SUB, BLEND_RGB_MULT, BLEND_RGB_MIN, BLEND_RGB_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.

      For a surface with colorkey or blanket alpha, a blit to self may give slightly different colors than a non self-blit.


    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.convert_alpha
      change the pixel format of an image including per pixel alphas
      Surface.convert_alpha(Surface): return Surface
      Surface.convert_alpha(): return Surface

      Creates a new copy of the surface with the desired pixel format. The new surface will be in a format suited for quick blitting to the given format with per pixel alpha. If no surface is given, the new surface will be optimized for blitting to the current display.

      Unlike the Surface.convert - change the pixel format of an image method, the pixel format for the new image will not be exactly the same as the requested source, but it will be optimized for fast alpha blitting to the destination.


    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, special_flags=0): 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 a RGB sequence, a RGBA sequence or a mapped color index. If using RGBA, the Alpha (A part of RGBA) is ignored unless the surface uses per pixel alpha (Surface has the SRCALPHA flag).

      An optional special_flags is for passing in new in 1.8.0:BLEND_ADD, BLEND_SUB, BLEND_MULT, BLEND_MIN, BLEND_MAX new in 1.8.1:BLEND_RGBA_ADD, BLEND_RGBA_SUB, BLEND_RGBA_MULT, BLEND_RGBA_MIN, BLEND_RGBA_MAXBLEND_RGB_ADD, BLEND_RGB_SUB, BLEND_RGB_MULT, BLEND_RGB_MIN, BLEND_RGB_MAX With other special blitting flags perhaps added in the future.

      This will return the affected Surface area.


    Surface.scroll
      Shift the surface image in place
      Surface.scroll(dx=0, dy=0): return None

      Move the image by dx pixels right and dy pixels down. dx and dy may be negative for left and up scrolls respectively. Areas of the surface that are not overwritten retain their original pixel values. Scrolling is contained by the Surface clip area. It is safe to have dx and dy values that exceed the surface size.


    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_colorkey
      Get the current transparent colorkey
      Surface.get_colorkey(): return RGB or None

      Return the current colorkey value for the Surface. If the colorkey is not set then None is returned.


    Surface.set_alpha
      set the alpha value for the full Surface image
      Surface.set_alpha(value, flags=0): return None
      Surface.set_alpha(None): return None

      Set the current alpha value fo r the Surface. When blitting this Surface onto a destination, the pixels will be drawn slightly transparent. The alpha value is an integer from 0 to 255, 0 is fully transparent and 255 is fully opaque. If None is passed for the alpha value, then the Surface alpha will be disabled.

      This value is different than the per pixel Surface alpha. If the Surface format contains per pixel alphas, then this alpha value will be ignored. If the Surface contains per pixel alphas, setting the alpha value to None will disable the per pixel transparency.

      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_alpha
      get the current Surface transparency value
      Surface.get_alpha(): return int_value or None

      Return the current alpha value for the Surface. If the alpha value is not set then None is returned.


    Surface.lock
      lock the Surface memory for pixel access
      Surface.lock(): return None

      Lock the pixel data of a Surface for access. On accelerated Surfaces, the pixel data may be stored in volatile video memory or nonlinear compressed forms. When a Surface is locked the pixel memory becomes available to access by regular software. Code that reads or writes pixel values will need the Surface to be locked.

      Surfaces should not remain locked for more than necessary. A locked Surface can often not be displayed or managed by Pygame.

      Not all Surfaces require locking. The Surface.mustlock - test if the Surface requires locking method can determine if it is actually required. There is no performance penalty for locking and unlocking a Surface that does not need it.

      All pygame functions will automatically lock and unlock the Surface data as needed. If a section of code is going to make calls that will repeatedly lock and unlock the Surface many times, it can be helpful to wrap the block inside a lock and unlock pair.

      It is safe to nest locking and unlocking calls. The surface will only be unlocked after the final lock is released.


    Surface.unlock
      unlock the Surface memory from pixel access
      Surface.unlock(): return None

      Unlock the Surface pixel data after it has been locked. The unlocked Surface can once again be drawn and managed by Pygame. See the Surface.lock - lock the Surface memory for pixel access documentation for more details.

      All pygame functions will automatically lock and unlock the Surface data as needed. If a section of code is going to make calls that will repeatedly lock and unlock the Surface many times, it can be helpful to wrap the block inside a lock and unlock pair.

      It is safe to nest locking and unlocking calls. The surface will only be unlocked after the final lock is released.


    Surface.mustlock
      test if the Surface requires locking
      Surface.mustlock(): return bool

      Returns True if the Surface is required to be locked to access pixel data. Usually pure software Surfaces do not require locking. This method is rarely needed, since it is safe and quickest to just lock all Surfaces as needed.

      All pygame functions will automatically lock and unlock the Surface data as needed. If a section of code is going to make calls that will repeatedly lock and unlock the Surface many times, it can be helpful to wrap the block inside a lock and unlock pair.


    Surface.get_locked
      test if the Surface is current locked
      Surface.get_locked(): return bool

      Returns True when the Surface is locked. It doesn't matter how many times the Surface is locked.


    Surface.get_locks
      Gets the locks for the Surface
      Surface.get_locks(): return tuple

      Returns the currently existing locks for the Surface.


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

      Return a copy of 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. It is better to use methods which operate on many pixels at a time like with the blit, fill and draw methods - or by using surfarray/PixelArray.

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

      Returning a Color instead of tuple, New in pygame 1.9.0. Use tuple(surf.get_at((x,y))) if you want a tuple, and not a Color. This should only matter if you want to use the color as a key in a dict.


    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.get_palette
      get the color index palette for an 8bit Surface
      Surface.get_palette(): return [RGB, RGB, RGB, ...]

      Return a list of up to 256 color elements that represent the indexed colors used in an 8bit Surface. The returned list is a copy of the palette, and changes will have no effect on the Surface.

      Returning a list of Color(with length 3) instances instead of tuples, New in pygame 1.9.0


    Surface.get_palette_at
      get the color for a single entry in a palette
      Surface.get_palette_at(index): return RGB

      Returns the red, green, and blue color values for a single index in a Surface palette. The index should be a value from 0 to 255.

      Returning Color(with length 3) instance instead of a tuple, New in pygame 1.9.0


    Surface.set_palette
      set the color palette for an 8bit Surface
      Surface.set_palette([RGB, RGB, RGB, ...]): return None

      Set the full palette for an 8bit Surface. This will replace the colors in the existing palette. A partial palette can be passed and only the first colors in the original palette will be changed.

      This function has no effect on a Surface with more than 8bits per pixel.


    Surface.set_palette_at
      set the color for a single index in an 8bit Surface palette
      Surface.set_at(index, RGB): return None

      Set the palette value for a single entry in a Surface palette. The index should be a value from 0 to 255.

      This function has no effect on a Surface with more than 8bits per pixel.


    Surface.map_rgb
      convert a color into a mapped color value
      Surface.map_rgb(Color): return mapped_int

      Convert an RGBA color into the mapped integer value for this Surface. The returned integer will contain no more bits than the bit depth of the Surface. Mapped color values are not often used inside Pygame, but can be passed to most functions that require a Surface and a color.

      See the Surface object documentation for more information about colors and pixel formats.


    Surface.unmap_rgb
      convert a mapped integer color value into a Color
      Surface.map_rgb(mapped_int): return Color

      Convert an mapped integer color into the RGB color components for this Surface. Mapped color values are not often used inside Pygame, but can be passed to most functions that require a Surface and a color.

      See the Surface object documentation for more information about colors and pixel formats.


    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 area 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.subsurface
      create a new surface that references its parent
      Surface.subsurface(Rect): return Surface

      Returns a new Surface that shares its pixels with its new parent. The new Surface is considered a child of the original. Modifications to either Surface pixels will effect each other. Surface information like clipping area and color keys are unique to each Surface.

      The new Surface will inherit the palette, color key, and alpha settings from its parent.

      It is possible to have any number of subsurfaces and subsubsurfaces on the parent. It is also possible to subsurface the display Surface if the display mode is not hardware accelerated.

      See the Surface.get_offset - find the position of a child subsurface inside a parent, Surface.get_parent - find the parent of a subsurface to learn more about the state of a subsurface.


    Surface.get_parent
      find the parent of a subsurface
      Surface.get_parent(): return Surface

      Returns the parent Surface of a subsurface. If this is not a subsurface then None will be returned.


    Surface.get_abs_parent
      find the top level parent of a subsurface
      Surface.get_abs_parent(): return Surface

      Returns the parent Surface of a subsurface. If this is not a subsurface then this surface will be returned.


    Surface.get_offset
      find the position of a child subsurface inside a parent
      Surface.get_offset(): return (x, y)

      Get the offset position of a child subsurface inside of a parent. If the Surface is not a subsurface this will return (0, 0).


    Surface.get_abs_offset
      find the absolute position of a child subsurface inside its top level parent
      Surface.get_abs_offset(): return (x, y)

      Get the offset position of a child subsurface inside of its top level parent Surface. If the Surface is not a subsurface this will return (0, 0).


    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.


    Surface.get_rect
      get the rectangular area of the Surface
      Surface.get_rect(**kwargs): return Rect

      Returns a new rectangle covering the entire surface. This rectangle will always start at 0, 0 with a width. and height the same size as the image.

      You can pass keyword argument values to this function. These named values will be applied to the attributes of the Rect before it is returned. An example would be 'mysurf.get_rect(center=(100,100))' to create a rectangle for the Surface centered at a given position.


    Surface.get_bitsize
      get the bit depth of the Surface pixel format
      Surface.get_bitsize(): return int

      Returns the number of bits used to represent each pixel. This value may not exactly fill the number of bytes used per pixel. For example a 15 bit Surface still requires a full 2 bytes.


    Surface.get_bytesize
      get the bytes used per Surface pixel
      Surface.get_bytesize(): return int

      Return the number of bytes used per pixel.


    Surface.get_flags
      get the additional flags used for the Surface
      Surface.get_flags(): return int

      Returns a set of current Surface features. Each feature is a bit in the flags bitmask. Typical flags are HWSURFACE, RLEACCEL, SRCALPHA, and SRCCOLORKEY.

      Here is a more complete list of flags. A full list can be found in SDL_video.h

      Available for pygame.display.set_mode - initialize a window or screen for display

      Used internally (read-only)


    Surface.get_pitch
      get the number of bytes used per Surface row
      Surface.get_pitch(): return int

      Return the number of bytes separating each row in the Surface. Surfaces in video memory are not always linearly packed. Subsurfaces will also have a larger pitch than their real width.

      This value is not needed for normal Pygame usage.


    Surface.get_masks
      the bitmasks needed to convert between a color and a mapped integer
      Surface.get_masks(): return (R, G, B, A)

      Returns the bitmasks used to isolate each color in a mapped integer.

      This value is not needed for normal Pygame usage.


    Surface.set_masks
      set the bitmasks needed to convert between a color and a mapped integer
      Surface.set_masks((r,g,b,a)): return None

      This is not needed for normal Pygame usage. New in pygame 1.8.1


    Surface.get_shifts
      the bit shifts needed to convert between a color and a mapped integer
      Surface.get_shifts(): return (R, G, B, A)

      Returns the pixel shifts need to convert between each color and a mapped integer.

      This value is not needed for normal Pygame usage.


    Surface.set_shifts
      sets the bit shifts needed to convert between a color and a mapped integer
      Surface.get_shifts((r,g,b,a)): return None

      This is not needed for normal Pygame usage. New in pygame 1.8.1


    Surface.get_losses
      the significant bits used to convert between a color and a mapped integer
      Surface.get_losses(): return (R, G, B, A)

      Return the least significant number of bits stripped from each color in a mapped integer.

      This value is not needed for normal Pygame usage.


    Surface.get_bounding_rect
      find the smallest rect containing data
      Surface.get_bounding_rect(min_alpha = 1): return Rect

      Returns the smallest rectangular region that contains all the pixels in the surface that have an alpha value greater than or equal to the minimum alpha value.

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

      New in pygame 1.8.


    Surface.get_buffer
      acquires a buffer object for the pixels of the Surface.
      Surface.get_buffer(): return BufferProxy

      Return a buffer object for the pixels of the Surface. The buffer can be used for direct pixel access and manipulation.

      This method implicitly locks the Surface. The lock will be released, once the returned BufferProxy object is deleted.

      New in pygame 1.8.