Aumentar a velocidade do blitting?

Estou trabalhando em um sidecroller 2D no PyGame. Para cada mapa, usamos uma textura (esse é o tamanho real da textura):

Em seguida, carregamos a imagem com este código:

sprite = pygame.image.load("Maps/MapTesting.png")
sprite.convert()
sprite = pygame.transform.scale(sprite,
              (sprite.get_width()*6, sprite.get_height()*6))

Como você pode ver, a textura é ampliada 6 vezes para criar a textura real do mapa. Em média, essa textura é de cerca de 4500x800. Essa textura deve ser unida à tela em todos os quadros , porque a tela inteira está suja (graças à rolagem lateral). Fazemos isso usando este código:

screen.blit(sprite, (0, 0),
(cameraposx, cameraposy, windowheight, windowwidth))

E isso funciona. O problema é que é muito lento: recebo 40 FPS em um PC decente, e isso sem a IA / objetos reais, enquanto pretendemos 60 FPS. Como podemos acelerar isso?

Observe que o código acima é higienizado e retirado de contexto. O código completo pode ser encontrado aqui: https://github.com/nightcracker/PyGG2

E por último mas não menos importante, embora a imagem acima possa parecer 8 bits, existem elementos no jogo que exigem mais profundidade de bits.

Deixe-me listar algumas otimizações gerais comparadas relacionadas a Blitting pixels em uma superfície (pela minha experiência).

1) Geralmente, as imagens da paleta (imagens indexadas) quando são blitadas passam por um nível extra de redirecionamento (para obter a cor).

2) Os dados de pixels de cores reais (suponha que os dados de Alpha - say24 bits) possam ser misturados muito rapidamente, pois podemos fazer um memcpy para cada linha de digitalização da imagem (se estiver copiando uma parte da imagem) no buffer do quadro do dispositivo .Se os dados a serem blitados são uma imagem completa, podemos copiar diretamente todos os dados, o que é muito mais rápido!

3) Blitting Alpha pixel data será o mais caro, pois incluirá o cálculo de cada componente resultante e precisamos compactá-lo novamente para dados RGB. Em termos simples, mais operações para cada pixel para obter a cor final!

Finalrgb = Alpha*(Srgb) + (1-Alpha)*Drgb (this is for normal blend equation)
    where Srgb is source-rgb (we need to apply for each of the component for final color)
       Drgb is the color that will be there in the destination buffer.

Eu não trabalhei no pyGame antes. Mas, uma rápida olhada no código de código, me leva a supor que ele está usando as funções 'sdl' Blit sob o capô. Normalmente, o Sdl blit será muito mais rápido e otimizado, portanto, faça um dos pontos e perfil acima novamente! Boa sorte!

* Atualização: * Definir chave de cor é como adicionar uma verificação extra ao misturar cada pixel na superfície.

       for(eachPixelColor in allPixels)
         {
            if(eachPixelColor is NOT colorKeyColor)
            {
              copy color to the frame buffer!
            }

         }

Portanto, aqui, se você vir, estamos limitados a não usar o memcpy, pois precisamos verificar a validade das cores de cada pixel!

sprite.convert() não faz o que você pensa que faz.

sprite = sprite.convert() é o que você precisa.