Объект pygame Surface используется для представления любого изображения. Surface имеет фиксированное разрешение и формат пикселей. Surfaces с 8-битными пикселями используют палитру цветов для отображения 24-битного цвета.

Вызовите pygame.Surface() для создания нового объекта изображения. Surface будет очищен до черного цвета. Единственными необходимыми аргументами являются размеры. Без дополнительных аргументов Surface будет создан в формате, который наилучшим образом соответствует отображаемому Surface.

Формат пикселей можно контролировать, передав разрядность или существующее Surface. Аргумент flags — это битовая маска дополнительных функций для поверхности. Вы можете передавать любое сочетание этих флагов:

HWSURFACE    (obsolete in pygame 2) creates the image in video memory
SRCALPHA     the pixel format will include a per-pixel alpha

Оба флага являются лишь запросом и могут быть недоступны для всех дисплеев и форматов.

Пользователи со знанием дела могут комбинировать набор битовых масок со значением разрядности. Маски — это набор из 4 целых чисел, представляющих, какие биты в пикселе будут представлять каждый цвет. Обычные Surfaces не должны требовать аргумента masks.

Surfaces могут иметь множество дополнительных атрибутов, таких как альфа-планы, цвет-ключ, обрезка области источника. Эти функции в основном влияют на то, как Surface отображается на другие Surfaces. Функции blit будут пытаться использовать аппаратное ускорение, в противном случае они будут использовать высокооптимизированные программные методы отображения.

В pygame поддерживаются три типа прозрачности: цвет-ключ, альфа-значения поверхности и альфа-значения пикселей. Альфа-значения поверхности можно смешивать с цветом-ключом, но изображение с альфа-значениями на уровне пикселей не может использовать другие режимы. Прозрачность цвета-ключа делает прозрачным одно значение цвета. Любые пиксели, соответствующие цвету-ключа, не будут отображаться. Значение альфа-канала поверхности — это одно значение, которое изменяет прозрачность всего изображения. Значение альфа-канала поверхности 255 означает непрозрачность, а значение 0 — полную прозрачность.

Альфа-значения пикселей отличаются тем, что хранят значение прозрачности для каждого пикселя. Это позволяет получить самые точные эффекты прозрачности, но также и самые медленные. Альфа-значения пикселей нельзя смешивать с альфа-каналом поверхности и цветом-ключа.

Поддерживается доступ к пикселям для Surfaces. Доступ к пикселям на аппаратных поверхностях медленный и не рекомендуется. К пикселям можно получить доступ с помощью функций get_at() и set_at(). Эти методы подходят для простого доступа, но будут значительно медленнее при работе с пикселями. Если вы планируете выполнять много работы на уровне пикселей, рекомендуется использовать pygame.PixelArray, который предоставляет вид массива поверхности. Для сложных математических манипуляций используйте модуль pygame.surfarray (он довольно быстрый, но требует NumPy).

Любые функции, которые напрямую обращаются к пиксельным данным поверхности, потребуют, чтобы поверхность была заблокирована (lock()). Эти функции могут lock() и unlock() поверхности без помощи. Но если функция будет вызываться много раз, будет много накладных расходов на многократное блокирование и разблокирование поверхности. Лучше вручную заблокировать поверхность перед вызовом функции много раз и разблокировать её по завершении. Все функции, которые нуждаются в заблокированной поверхности, будут об этом указаны в их документации. Помните, что поверхность должна быть заблокирована только по мере необходимости.

Пиксели Surface хранятся внутри как одно число, в котором закодированы все цвета. Используйте map_rgb() и unmap_rgb() для преобразования отдельных значений красного, зеленого и синего цветов в упакованное целое число для данного Surface.

Surfaces также могут ссылаться на части других Surfaces. Они создаются методом subsurface(). Любое изменение любой поверхности повлияет на другую.

Каждая поверхность содержит область обрезки. По умолчанию область обрезки охватывает всю поверхность. Если она изменена, все операции рисования будут влиять только на меньшую область.

blit()

отображение одного изображения на другое

blit(source, dest, area=None, special_flags=0) -> Rect

Отображает source Surface на эту Surface. Отображение можно позиционировать с помощью аргумента dest. Аргумент dest может быть парой координат, представляющих положение верхнего левого угла отображения, или объектом Rect, где верхний левый угол прямоугольника будет использован как позиция для отображения. Размер прямоугольника назначения не влияет на отображение.

Можно также передать необязательный прямоугольник области (area). Он представляет меньшую часть source Surface для отображения.

Новое в pygame 1.8: Необязательные special_flags: BLEND_ADD, BLEND_SUB, BLEND_MULT, BLEND_MIN, BLEND_MAX.

Новое в pygame 1.8.1: Необязательные special_flags: BLEND_RGBA_ADD, BLEND_RGBA_SUB, BLEND_RGBA_MULT, BLEND_RGBA_MIN, BLEND_RGBA_MAX BLEND_RGB_ADD, BLEND_RGB_SUB, BLEND_RGB_MULT, BLEND_RGB_MIN, BLEND_RGB_MAX.

Новое в pygame 1.9.2: Необязательные special_flags: BLEND_PREMULTIPLIED

Новое в pygame 2.0.0: Необязательные special_flags: BLEND_ALPHA_SDL2 — Использует SDL2 блиттер для альфа-смешивания, это даёт разные результаты, чем по умолчанию блиттер, который моделируется по SDL1, из-за разных приближений, используемых для формулы альфа-смешивания. SDL2 блиттер также поддерживает RLE на альфа-смешанных поверхностях, чего не делает pygame.

Возвращаемый прямоугольник — это область затронутых пикселей, исключая пиксели за пределами назначения Surface или за пределами области обрезки.

Альфа-значения пикселей игнорируются при отображении на 8-битное Surface.

Для поверхности с цветом-ключом или альфой, отображение на себя может давать несколько другие цвета, чем отображение не на себя.

blits()

отображение множества изображений на другое

blits(blit_sequence=((source, dest), ...), doreturn=1) -> [Rect, ...] or None

blits(((source, dest, area), ...)) -> [Rect, ...]

blits(((source, dest, area, special_flags), ...)) -> [Rect, ...]

Отображает множество поверхностей на эту Surface. Она принимает на вход последовательность, где каждый элемент соответствует элементам blit(). Для этого необходимо, как минимум, последовательность (source, dest).

Parameters

• blit_sequence -- последовательность поверхностей и аргументов для их отображения, они соответствуют аргументам blit()

• doreturn -- если True, вернуть список прямоугольников изменённых областей, в противном случае вернуть None

Returns

список прямоугольников изменённых областей, если doreturn равно True, иначе None

Return type

list or None

Новое в pygame 1.9.4.

convert()

изменение формата пикселей изображения

convert(Surface=None) -> Surface

convert(depth, flags=0) -> Surface

convert(masks, flags=0) -> Surface

Создаёт новую копию Surface с изменённым форматом пикселей. Новый формат пикселей можно определить по существующей поверхности. В противном случае можно использовать аргументы depth, flags и masks, аналогично вызову pygame.Surface().

Если не передавать аргументов, новая поверхность будет иметь такой же формат пикселей, как и поверхность дисплея. Это всегда самый быстрый формат для отображения. Хорошо преобразовывать все Surfaces перед их многократным отображением.

Преобразованная поверхность не будет иметь альфа-каналов пикселей. Они будут удалены, если у оригинала были. Смотрите convert_alpha() для сохранения или создания альфа-каналов на уровне пикселей.

Новая копия будет иметь тот же класс, что и скопированная поверхность. Это позволяет подклассам Surface унаследовать этот метод без необходимости переопределения, если также не нужно копировать специфичные для подкласса атрибуты экземпляра.

convert_alpha()

изменение формата пикселей изображения, включая альфа-каналы по пикселю

convert_alpha(Surface) -> Surface

convert_alpha() -> Surface

Создает новую копию поверхности с желаемым форматом пикселей. Новая поверхность будет в формате, подходящем для быстрого отображения на данной поверхности с альфа-каналом по пикселю. Если поверхность не указана, новая поверхность будет оптимизирована для отображения на текущем дисплее.

В отличие от метода convert(), формат пикселей нового изображения не будет точно таким же, как запрошенная исходная поверхность, но он будет оптимизирован для быстрого отображения альфа-каналов на целевой поверхности.

Как и в случае с convert(), возвращаемая поверхность имеет тот же класс, что и преобразованная поверхность.

copy()

создание новой копии поверхности

copy() -> Surface

Создает дубликат копии поверхности. Новая поверхность будет иметь тот же формат пикселей, цветовые палитры, настройки прозрачности и класс, что и оригинальная. Если подкласс Surface также должен копировать любые атрибуты экземпляра, то он должен переопределить copy().

fill()

заполнение поверхности сплошным цветом

fill(color, rect=None, special_flags=0) -> Rect

Заполняет поверхность сплошным цветом. Если аргумент rect не указан, вся поверхность будет заполнена. Аргумент rect ограничит заполнение определённой областью. Заполнение также будет ограничено областью обрезки поверхности.

Аргумент color может быть либо RGB последовательностью, либо RGBA последовательностью, либо индексом цвета в палитре. При использовании RGBA, альфа-канал (часть RGBA) игнорируется, если поверхность не использует альфа-канал по пикселям (у поверхности установлен флаг SRCALPHA).

Добавлена в pygame 1.8: Дополнительные special_flags: BLEND_ADD, BLEND_SUB, BLEND_MULT, BLEND_MIN, BLEND_MAX.

Добавлена в pygame 1.8.1: Дополнительные special_flags: BLEND_RGBA_ADD, BLEND_RGBA_SUB, BLEND_RGBA_MULT, BLEND_RGBA_MIN, BLEND_RGBA_MAX BLEND_RGB_ADD, BLEND_RGB_SUB, BLEND_RGB_MULT, BLEND_RGB_MIN, BLEND_RGB_MAX.

Это вернёт область затронутой поверхности.

scroll()

смещение изображения поверхности на месте

scroll(dx=0, dy=0) -> None

Перемещает изображение на dx пикселей вправо и на dy пикселей вниз. dx и dy могут быть отрицательными для смещения влево и вверх соответственно. Области поверхности, которые не перезаписываются, сохраняют свои исходные значения пикселей. Смещение ограничено областью обрезки поверхности. Безопасно использовать значения dx и dy, которые превышают размер поверхности.

Добавлена в pygame 1.9.

set_colorkey()

установка прозрачного цвета-ключа

set_colorkey(Color, flags=0) -> None

set_colorkey(None) -> None

Устанавливает текущий цвет-ключ для поверхности. При отображении этой поверхности на целевой поверхности, любые пиксели, имеющие тот же цвет, что и цвет-ключ, будут прозрачными. Цвет может быть RGB цветом или целочисленным индексом цвета. Если передано None, цвет-ключ будет сброшен.

Цвет-ключ будет игнорироваться, если поверхность отформатирована для использования альфа-каналов по пикселям. Цвет-ключ может сочетаться со значением альфа-канала всей поверхности.

Дополнительный аргумент flags может быть установлен в pygame.RLEACCEL, чтобы обеспечить лучшую производительность на неакселерированных дисплеях. Поверхность с RLEACCEL будет медленнее для модификации, но быстрее для отображения в качестве источника.

get_colorkey()

получение текущего прозрачного цвета-ключа

get_colorkey() -> RGB or None

Возвращает текущее значение цвета-ключа для поверхности. Если цвет-ключ не установлен, то возвращается None.

set_alpha()

установка значения альфа-канала для всего изображения поверхности

set_alpha(value, flags=0) -> None

set_alpha(None) -> None

Устанавливает текущее значение альфа-канала для поверхности. При отображении этой поверхности на целевой поверхности пиксели будут отображаться с некоторой прозрачностью. Значение альфа-канала — целое число от 0 до 255, 0 — полностью прозрачный, 255 — полностью непрозрачный. Если для значения альфа-канала передано None, то смешивание с альфа-каналом будет отключено, включая альфа-канал по пикселям.

Это значение отличается от альфа-канала поверхности по пикселям. Для поверхности с альфа-каналом по пикселям значение глобального альфа-канала игнорируется и возвращается None.

Изменено в pygame 2.0: альфа-канал поверхности может сочетаться с альфа-каналом по пикселям.

Дополнительный аргумент flags может быть установлен в pygame.RLEACCEL, чтобы обеспечить лучшую производительность на неакселерированных дисплеях. Поверхность с RLEACCEL будет медленнее для модификации, но быстрее для отображения в качестве источника.

get_alpha()

получение текущего значения прозрачности поверхности

get_alpha() -> int_value

Возвращает текущее значение альфа-канала для поверхности.

lock()

блокировка памяти поверхности для доступа к пикселям

lock() -> None

Блокирует данные пикселей поверхности для доступа. На ускоренных поверхностях данные пикселей могут храниться в динамической видеопамяти или в нелинейных сжатых форматах. Когда поверхность заблокирована, память пикселей становится доступной для доступа обычным программным обеспечением. Код, который читает или записывает значения пикселей, будет нуждаться в заблокированной поверхности.

Поверхности не должны оставаться заблокированными дольше необходимого. Заблокированная поверхность часто не может отображаться или управляться pygame.

Не все поверхности требуют блокировки. Метод mustlock() может определить, действительно ли это необходимо. Нет штрафа за производительность при блокировке и разблокировке поверхности, которая не требует этого.

Все функции pygame автоматически блокируют и разблокируют данные поверхности по мере необходимости. Если блок кода будет выполнять вызовы, которые будут многократно блокировать и разблокировать поверхность, может быть полезно обернуть блок в пару блокировки и разблокировки.

Безопасно вкладывать вызовы блокировки и разблокировки. Поверхность будет разблокирована только после того, как будет выпущена последняя блокировка.

unlock()

разблокировка памяти поверхности для доступа к пикселям

unlock() -> None

Разблокирует данные пикселей поверхности после того, как они были заблокированы. Разблокированная поверхность снова может быть отображена и управляется pygame. См. документацию к lock() для получения более подробной информации.

Все функции pygame автоматически блокируют и разблокируют данные поверхности по мере необходимости. Если блок кода будет выполнять вызовы, которые будут многократно блокировать и разблокировать поверхность, может быть полезно обернуть блок в пару блокировки и разблокировки.

Безопасно вкладывать вызовы блокировки и разблокировки. Поверхность будет разблокирована только после того, как будет выпущена последняя блокировка.

mustlock()

проверка, требуется ли блокировка поверхности

mustlock() -> bool

Возвращает True, если для доступа к данным пикселей требуется заблокировать поверхность. Обычно чистые программные поверхности не требуют блокировки. Этот метод редко нужен, так как безопасно и быстрее просто блокировать все поверхности по мере необходимости.

Все функции pygame автоматически блокируют и разблокируют данные поверхности по мере необходимости. Если блок кода будет выполнять вызовы, которые будут многократно блокировать и разблокировать поверхность, может быть полезно обернуть блок в пару блокировки и разблокировки.

get_locked()

проверка, заблокирована ли поверхность в данный момент

get_locked() -> bool

Возвращает True, когда поверхность заблокирована. Не имеет значения, сколько раз поверхность блокируется.

get_locks()

получение блокировок для поверхности

get_locks() -> tuple

Возвращает текущие существующие блокировки для поверхности.

get_at()

получить значение цвета в одном пикселе

get_at((x, y)) -> Color

Возвращает копию значения RGBA цвета в заданном пикселе. Если у Surface нет альфа-канала на пиксель, то значение альфа всегда будет 255 (непрозрачный). Если позиция пикселя находится за пределами области Surface, будет вызвано исключение IndexError.

Получение и установка пикселей по одному, как правило, слишком медленны для использования в играх или в реальном времени. Лучше использовать методы, которые работают со многими пикселями одновременно, например, методы blit, fill и draw, или используя pygame.surfarray/pygame.PixelArray.

Эта функция временно блокирует и разблокирует Surface по мере необходимости.

Новая функция в pygame 1.9: Возвращает значение Color вместо кортежа. Используйте tuple(surf.get_at((x,y))) если вам нужен кортеж, а не Color. Это должно быть важно только если вы хотите использовать цвет в качестве ключа в словаре.

set_at()

установить значение цвета для одного пикселя

set_at((x, y), Color) -> None

Устанавливает значение RGBA или сопоставленного целочисленного значения цвета для одного пикселя. Если у Surface нет альфа-канала на пиксель, значение альфа игнорируется. Установка пикселей за пределами области Surface или за пределами обрезки Surface не повлияет.

Получение и установка пикселей по одному, как правило, слишком медленны для использования в играх или в реальном времени.

Эта функция временно блокирует и разблокирует Surface по мере необходимости.

Примечание

Если поверхность палитровая, цвет пикселя будет установлен на наиболее близкий цвет в палитре.

get_at_mapped()

получить сопоставленное значение цвета в одном пикселе

get_at_mapped((x, y)) -> Color

Возвращает целочисленное значение заданного пикселя. Если позиция пикселя находится за пределами области Surface, будет вызвано исключение IndexError.

Этот метод предназначен для тестирования pygame. Вряд ли он пригодится в приложении.

Эта функция временно блокирует и разблокирует Surface по мере необходимости.

Новая функция в pygame 1.9.2.

get_palette()

получить палитру индексов цвета для 8-битной Surface

get_palette() -> [RGB, RGB, RGB, ...]

Возвращает список до 256 элементов цвета, которые представляют индексированные цвета, используемые в 8-битной Surface. Возвращаемый список — копия палитры, и изменения не повлияют на Surface.

Возвращает список Color(with length 3) объектов вместо кортежей.

Новая функция в pygame 1.9.

get_palette_at()

получить цвет для отдельной записи в палитре

get_palette_at(index) -> RGB

Возвращает значения красного, зеленого и синего цвета для отдельного индекса в палитре Surface. Индекс должен быть значением от 0 до 255.

Новая функция в pygame 1.9: Возвращает Color(with length 3) объект вместо кортежа.

set_palette()

установить палитру цветов для 8-битной Surface

set_palette([RGB, RGB, RGB, ...]) -> None

Устанавливает полную палитру для 8-битной Surface. Это заменит цвета в существующей палитре. Можно передать частичную палитру, и только первые цвета в исходной палитре будут изменены.

Эта функция не влияет на Surface с более чем 8 битами на пиксель.

set_palette_at()

установить цвет для отдельного индекса в палитре 8-битной Surface

set_palette_at(index, RGB) -> None

Устанавливает значение палитры для отдельной записи в палитре Surface. Индекс должен быть значением от 0 до 255.

Эта функция не влияет на Surface с более чем 8 битами на пиксель.

map_rgb()

преобразовать цвет в сопоставленное значение

map_rgb(Color) -> mapped_int

Преобразует цвет RGBA в сопоставленное целочисленное значение для этой Surface. Возвращаемое целое число будет содержать не больше битов, чем битовая глубина Surface. Сопоставленные значения цвета не часто используются внутри pygame, но могут передаваться в большинство функций, которые требуют Surface и цвет.

См. документацию объекта Surface для получения дополнительной информации о цветах и форматах пикселей.

unmap_rgb()

преобразовать сопоставленное целочисленное значение цвета в цвет

unmap_rgb(mapped_int) -> Color

Преобразует сопоставленное целочисленное значение цвета в RGB цветовые компоненты для этой Surface. Сопоставленные значения цвета не часто используются внутри pygame, но могут передаваться в большинство функций, которые требуют Surface и цвет.

См. документацию объекта Surface для получения дополнительной информации о цветах и форматах пикселей.

set_clip()

установить текущую область обрезки Surface

set_clip(rect) -> None

set_clip(None) -> None

У каждой Surface есть активная область обрезки. Это прямоугольник, который представляет собой единственные пиксели на Surface, которые могут быть изменены. Если None передается для прямоугольника, вся Surface будет доступна для изменений.

Область обрезки всегда ограничивается областью самой Surface. Если прямоугольник обрезки слишком большой, он будет уменьшен для соответствия внутри Surface.

get_clip()

получить текущую область обрезки Surface

get_clip() -> Rect

Возвращает прямоугольник текущей области обрезки. Surface всегда возвращает допустимый прямоугольник, который никогда не будет за пределами границ изображения. Если для области обрезки Surface был None установлен, Surface вернет прямоугольник со всей областью Surface.

subsurface()

создать новую поверхность, которая ссылается на свою родительскую

subsurface(Rect) -> Surface

Возвращает новую Surface, которая разделяет свои пиксели с её новым родителем. Новая Surface считается дочерней по отношению к исходной. Изменения в пикселях любой Surface повлияют на другую. Информация о Surface, такая как область обрезки и цветовые ключи, уникальны для каждой Surface.

Новая Surface унаследует палитру, цветовой ключ и настройки альфа-канала от своего родителя.

Можно иметь любое количество подповерхностей и подподповерхностей на родителе. Также можно создать подповерхность на дисплейной Surface, если режим отображения не ускорен аппаратным обеспечением.

См. get_offset() и get_parent() для получения дополнительной информации о состоянии подповерхности.

Подповерхность будет иметь тот же класс, что и родительская поверхность.

get_parent()

найти родительскую поверхность подповерхности

get_parent() -> Surface

Возвращает родительскую Surface подповерхности. Если это не подповерхность, то будет возвращено None.

get_abs_parent()

найти родительскую поверхность верхнего уровня подповерхности

get_abs_parent() -> Surface

Возвращает родительскую Surface подповерхности. Если это не подповерхность, то будет возвращена эта поверхность.

get_offset()

найти позицию дочерней подповерхности внутри родительской

get_offset() -> (x, y)

Получить смещение позиции дочерней подповерхности внутри родителя. Если Surface не является подповерхностью, будет возвращено (0, 0).

get_abs_offset()

найти абсолютное положение дочернего подповерхностного элемента внутри его родительского поверхностного элемента верхнего уровня

get_abs_offset() -> (x, y)

Получить смещение положения дочернего подповерхностного элемента внутри родительского поверхностного элемента верхнего уровня. Если поверхность не является подповерхностным элементом, будет возвращено (0, 0).

get_size()

получить размеры поверхности

get_size() -> (ширина, высота)

Возвращает ширину и высоту поверхности в пикселях.

get_width()

получить ширину поверхности

get_width() -> ширина

Возвращает ширину поверхности в пикселях.

get_height()

получить высоту поверхности

get_height() -> высота

Возвращает высоту поверхности в пикселях.

get_rect()

получить прямоугольную область поверхности

get_rect(**kwargs) -> Rect

Возвращает новый прямоугольник, покрывающий всю поверхность. Этот прямоугольник всегда начинается с (0, 0) с шириной и высотой, равными размеру изображения.

Вы можете передать значения аргументов ключевых слов в эту функцию. Эти именованные значения будут применены к атрибутам Rect перед возвращением. Пример: mysurf.get_rect(center=(100, 100)), чтобы создать прямоугольник для поверхности, центрированный в заданном положении.

get_bitsize()

получить разрядность поверхности формата пикселей

get_bitsize() -> int

Возвращает количество битов, используемых для представления каждого пикселя. Это значение может не точно соответствовать количеству байтов, используемых на пиксель. Например, 15-битная поверхность по-прежнему требует 2 байта.

get_bytesize()

получить количество байтов, используемых на пиксель поверхности

get_bytesize() -> int

Возвращает количество байтов, используемых на пиксель.

get_flags()

получить дополнительные флаги, используемые для поверхности

get_flags() -> int

Возвращает набор текущих функций поверхности. Каждая функция является битом в битовой маске флагов. Типичные флаги — RLEACCEL, SRCALPHA, и SRCCOLORKEY.

Вот более полный список флагов. Полный список можно найти в SDL_video.h.

SWSURFACE      0x00000000    # Surface is in system memory
HWSURFACE      0x00000001    # (obsolete in pygame 2) Surface is in video memory
ASYNCBLIT      0x00000004    # (obsolete in pygame 2) Use asynchronous blits if possible

См. pygame.display.set_mode() для флагов, специфичных для поверхности отображения.

Используется внутри (только для чтения)

HWACCEL        0x00000100    # Blit uses hardware acceleration
SRCCOLORKEY    0x00001000    # Blit uses a source color key
RLEACCELOK     0x00002000    # Private flag
RLEACCEL       0x00004000    # Surface is RLE encoded
SRCALPHA       0x00010000    # Blit uses source alpha blending
PREALLOC       0x01000000    # Surface uses preallocated memory

get_pitch()

получить количество байтов, используемых на строку поверхности

get_pitch() -> int

Возвращает количество байтов, разделяющих каждую строку на поверхности. Поверхности в видеопамяти не всегда упакованы линейно. Подповерхностные элементы также будут иметь больший шаг, чем их реальная ширина.

Это значение не нужно для обычного использования pygame.

get_masks()

битовые маски, необходимые для преобразования между цветом и сопоставленным целым числом

get_masks() -> (R, G, B, A)

Возвращает битовые маски, используемые для изоляции каждого цвета в сопоставленном целом числе.

Это значение не нужно для обычного использования pygame.

set_masks()

установить битовые маски, необходимые для преобразования между цветом и сопоставленным целым числом

set_masks((r,g,b,a)) -> None

Это не нужно для обычного использования pygame.

Примечание

Начиная с pygame 2.0, маски являются только для чтения, и, следовательно, этот метод будет поднимать TypeError при вызове.

Устарело начиная с pygame 2.0.0.

Введено в pygame 1.8.1.

get_shifts()

битовые сдвиги, необходимые для преобразования между цветом и сопоставленным целым числом

get_shifts() -> (R, G, B, A)

Возвращает сдвиги пикселей, необходимые для преобразования между каждым цветом и сопоставленным целым числом.

Это значение не нужно для обычного использования pygame.

set_shifts()

устанавливает битовые сдвиги, необходимые для преобразования между цветом и сопоставленным целым числом

set_shifts((r,g,b,a)) -> None

Это не нужно для обычного использования pygame.

Примечание

Начиная с pygame 2.0, сдвиги являются только для чтения, и, следовательно, этот метод будет поднимать TypeError при вызове.

Устарело начиная с pygame 2.0.0.

Введено в pygame 1.8.1.

get_losses()

значимые биты, используемые для преобразования между цветом и сопоставленным целым числом

get_losses() -> (R, G, B, A)

Возвращает наименее значимое количество битов, удаленных из каждого цвета в сопоставленном целом числе.

Это значение не нужно для обычного использования pygame.

get_bounding_rect()

найти наименьший прямоугольник, содержащий данные

get_bounding_rect(min_alpha = 1) -> Rect

Возвращает наименьшую прямоугольную область, содержащую все пиксели на поверхности, у которых значение альфа больше или равно минимальному значению альфа.

Эта функция временно блокирует и разблокирует поверхность по мере необходимости.

Введено в pygame 1.8.

get_view()

возвратить представление буфера пикселей поверхности.

get_view(<kind>='2') -> BufferProxy

Возвращает объект, который экспортирует внутренний буфер пикселей поверхности как структуру массива уровня C, интерфейс массива уровня Python или интерфейс буфера уровня C. Поддерживается новый протокол буфера.

Аргумент kind — это строка длиной 1 символ '0', '1', '2', '3', 'r', 'g', 'b' или 'a'. Буквы регистронезависимы; 'A' также будет работать. Аргумент может быть строкой Unicode или байтовой (символьной) строкой. По умолчанию — '2'.

'0' возвращает непрерывное неупорядоченное представление байтов. Информация о форме поверхности не предоставляется. Если пиксели поверхности не являются непрерывными, будет вызвано ValueError.

'1' возвращает массив (ширина_поверхности * высота_поверхности) непрерывных пикселей. Если пиксели поверхности не являются непрерывными, будет вызвано ValueError.

'2' возвращает массив (ширина_поверхности, высота_поверхности) из исходных пикселей. Пиксели — это целые числа с размером в байтах поверхности без знака. Формат пикселей зависит от поверхности. 3-байтовые целые числа без знака 24-битных поверхностей, скорее всего, не будут приняты ничем, кроме других функций pygame.

'3' возвращает массив (ширина_поверхности, высота_поверхности, 3) из RGB цветовых компонентов. Каждый из компонентов красного, зеленого и синего — это байты без знака. Поддерживаются только 24-битные и 32-битные поверхности. Цветовые компоненты должны быть в RGB или BGR порядке в пикселе.

'r' для красного, 'g' для зеленого, 'b' для синего и 'a' для альфы возвращают представление (ширина_поверхности, высота_поверхности) отдельного цветового компонента на поверхности: цветовой плоскости. Цветовые компоненты — байты без знака. 24-битные и 32-битные поверхности поддерживают 'r', 'g' и 'b'. Только 32-битные поверхности с SRCALPHA поддерживают 'a'.

Поверхность блокируется только при обращении к экспортированному интерфейсу. Для новых обращений к интерфейсу буфера поверхность разблокируется, как только последний прокси-объект буфера будет освобожден. Для обращений к интерфейсу массива и старому интерфейсу буфера поверхность остается заблокированной до тех пор, пока не будет освобожден объект BufferProxy.

Введено в pygame 1.9.2.

get_buffer()

получает объект буфера для пикселей поверхности.

get_buffer() -> BufferProxy

Возвращает объект буфера для пикселей поверхности. Буфер может использоваться для прямого доступа и манипулирования пикселями. Данные пикселей поверхности представлены как неструктурированный блок памяти с начальным адресом и длиной в байтах. Данные не обязательно должны быть непрерывными. Любые пробелы включаются в длину, но в противном случае игнорируются.

Этот метод неявно блокирует поверхность. Блокировка будет освобождена при сборке мусора возвращённого объекта pygame.BufferProxy.

Новое в pygame 1.8.

_pixels_address

адрес буфера пикселей

_pixels_address -> int

Начальный адрес сырых байтов пикселей поверхности.

Новое в pygame 1.9.2.

premul_alpha()

возвращает копию поверхности с цветовыми каналами RGB, умноженными на альфа-канал.

premul_alpha() -> Surface

Экспериментально: функция всё ещё в разработке, доступна для тестирования и обратной связи. Она может измениться. Пожалуйста, оставьте обратную связь по premul_alpha с авторами

Возвращает копию исходной поверхности, в которой красные, зелёные и синие цветовые каналы умножаются на альфа-канал. Это призвано упростить работу с флагом смешивания BLEND_PREMULTIPLED метода blit(). Поверхности, которые вызывали этот метод, будут выглядеть правильно только после использования флага смешивания BLEND_PREMULTIPLED при вызове метода blit().

Следует отметить, что после вызова этого метода методы, возвращающие цвет пикселя, такие как get_at(), будут возвращать значения цвета, умноженные на альфа-канал. Полностью обратить умножение альфы на цвета на поверхности невозможно, так как целочисленные данные цветовых каналов обычно уменьшаются в результате операции (например, 255 x 0 = 0, отсюда невозможно восстановить исходное значение 255 только по двум оставшимся нулям в цветовых и альфа-каналах).

Если вы вызовете этот метод дважды, цветовые каналы будут умножены на альфа-канал дважды. Существует множество способов получить поверхность с цветовыми каналами, умноженными на альфа-канал в pygame, и отличить их по информации о пикселях невозможно. Совершенно возможно иметь две идентичные поверхности — одну для смешивания с предварительно умноженной альфой и одну для обычного смешивания. По этой причине мы не сохраняем состояние поверхностей, предназначенных для предварительного умножения альфы.

Поверхности без альфа-канала не могут использовать этот метод и вернут ошибку, если вы его используете. Лучше всего использовать его на 32-битных поверхностях (по умолчанию на большинстве платформ), так как отрисовка на этих поверхностях может быть ускорена с помощью SIMD-версий блендера с предварительно умноженной альфой.

В целом, предварительно умноженное альфа-смешивание быстрее, чем «прямое альфа-смешивание», и обеспечивает лучшие результаты при смешивании поверхности с альфой на другую поверхность с альфой — в предположении, что обе поверхности содержат предварительно умноженные цвета альфы.

Новое в pygame 2.2.0.