Padrão comum para dimensionar "unidades reais" para pixels?

Esta é uma pergunta de acompanhamento para esta outra .

Gostaria de saber se existe um padrão comum / típico / melhor para dimensionar minha representação do mundo (atualmente 160Kmx160Km) para ajustá-lo à área de desenho (atualmente 800x600 pixels).

Posso pensar em pelo menos quatro abordagens diferentes:

Um ingênuo (do jeito que eu fiz até agora). Eu implementei uma função global sc(vector)que simplesmente retornará uma cópia reduzida do vetor passado. Isso obviamente funciona, mas me obriga a escrever código como:

drawCircle(sc(radius), sc(position))

Funções de quebra automática . Eu poderia definir várias funções, cada uma envolvendo o middleware original. Por exemplo, eu poderia definir myDrawCircleque primeiro escalaria os argumentos que precisam de escala e depois chamasse drawCirclecom o último. Isso tornaria meu código talvez mais legível e mais fácil de manter, mas eu deveria escrever muitas funções de agrupamento, que parecem bobas.

Decorador de funções . Eu poderia simplesmente decorar as funções de middleware existentes, fornecendo escala automática para todos os parâmetros que são uma instanciação da classe Vector3D, mas o problema é que essas funções também funcionam com os mesmos parâmetros, listou Vector2Dseja, e o decorador não teria como saber quais listas precisam ser redimensionadas (o raio, por exemplo) e quais não (os valores RGB).

Inicialização de superfície . Ao definir a superfície em que vou desenhar, eu poderia definir o fator de escala (para então usar metros e não pixels como parâmetros). Isso funcionaria de forma transparente para mim e seria minha solução preferida, mas é claro que deveria ser implementado no middleware, portanto não é uma opção real.

... de qualquer maneira: como esse é um problema muito comum, pergunto-me se existe um padrão estabelecido que resolva elegantemente esse problema que não consegui encontrar.

PS: Para este projeto, estou usando python (com pygame ), mas - embora uma resposta específica para python / pygame seja muito apreciada, estou mais interessado na descrição geral / de alto nível do padrão do que em sua implementação concreta.

Agradecemos antecipadamente pelo seu tempo e experiência.

A maneira padrão de fazer isso é configurar uma matriz de transformação para fazer a conversão durante a renderização. Para renderização em 3D, é a matriz de transformação de exibição da câmera que faz isso.

A maioria das APIs 2D também tem uma maneira de especificar uma transformação de exibição, como uma matriz 2x3 ou como uma escala, translação e rotação separadas.

Uma rápida olhada na documentação do pygame sugere que você precisará implementar uma matriz de transformação de exibição. Permite derivar sua própria classe da classe de superfície para permitir que você adicione essa funcionalidade?

Como esse é um problema muito comum, pergunto-me se existe um padrão estabelecido que resolva elegantemente esse problema que não consegui encontrar.

Geralmente, as pessoas não tentam executar a escala de tempo de execução em jogos 2D. Não concordo que seja um problema comum. Se as pessoas desejam um mini-mapa ou algum outro redimensionamento fixo, geralmente há um novo conjunto de gráficos para esse fim. É raro que você precise de uma única rotina para executar em 2 níveis de zoom diferentes em um jogo 2D.

Se você usa uma API 3D, pode obter essa funcionalidade gratuitamente - basta alterar os parâmetros da câmera / porta de visualização.

PyGame é uma API muito antiga e, infelizmente, só é realmente adequada para 2D. Mesmo que você possa trabalhar com sistemas de dimensionamento adequados para os diferentes níveis de zoom, o desempenho não será bom o suficiente e a aparência provavelmente será inaceitavelmente ruim.

Eu recomendaria que, se você quiser aumentar e diminuir o zoom, mude para uma API 3D moderna o mais rápido possível. Eu recomendaria o pyglet, mas provavelmente também haverá outros.