Práticas recomendadas para animação em Sprite

Eu gostaria de entender melhor como as pessoas no mundo real estão lidando com suas animações.

Você carrega uma imagem grande e desenha retângulos diferentes com base no quadro de animação?

Você carrega arquivos de imagem X em uma matriz e desenha o item na matriz com base no quadro de animação?

Como você lida com diferentes comprimentos de animações para vários sprites.

Digamos que um personagem andando tenha de 4 a 8 quadros, e as ondas na praia apenas de 2 a 3 quadros. Como você lidaria com essa situação? Ver abaixo

Dim Waves(1) as Sprite
Dim Char(5) as Sprite

Sub Animate()
     Frame += 1
     Draw Char(Frame)
     Draw Waves(Frame)
     If Frame = 5 Then Frame = 0
End Sub

Obviamente, o Waves acabaria com um erro fora dos limites.

Ou você tem seu sprite preocupado com a própria animação e não se importa com o quadro? Cada sprite conhece seu próprio loop de animação?

A maneira como eu fiz isso no passado é separando os dados da animação da reprodução da animação . Um Animationpode então se tornar basicamente uma matriz de Framese algumas propriedades que descrevem como a animação deve se comportar (se for repetida, etc.).

Normalmente, carrego uma imagem e desenho partes dela.

Cada Frameanimação é essencialmente um retângulo e um período de tempo. Isso permite que alguns quadros sejam exibidos por mais tempo que outros, o que pode ou não ser o que você deseja. Se você deseja que todos os quadros da animação sejam exibidos pelo mesmo período de tempo, armazene-os no seu Animationobjeto.

Qualquer coisa que precise reproduzir uma animação tem sua própria, AnimationPlayerque pode ser apontada para uma Animation. O objeto player cuida da reprodução da animação e disponibiliza o "quadro atual".

A vantagem disso para mim foi que eu poderia ter uma única instância de uma Animationque muitos objetos poderiam apontar e estar desempenhando diferentes partes ao mesmo tempo. Também foi fácil alterar as animações simplesmente apontando o objeto AnimationPlayerpara outro Animatione redefinindo a reprodução.

Edit : Aqui está uma implementação JavaScript bastante básica do sistema descrito acima . Juntei-o em poucos minutos como demonstração . O código "real" teria mais recursos. Você precisará de um navegador moderno que suporte o Canvas e o URI de dados para que ele funcione.

Eu teria uma animação saber quantos quadros ela tem. Onde e como eles são armazenados é relativamente irrelevante, exceto por problemas de desempenho (como você pode querer na mesma textura). Eu nunca adicionaria 1 ao número de quadros, acrescentaria deltaTime * animSpeed ​​e converteria esse valor em um número inteiro ao exibir. Dessa forma, você pode diminuir ou acelerar as animações e é independente da taxa de quadros.

Assim, um sprite teria uma animação que se atualiza.

Por que não apenas armazenar um número de quadros para cada um de seus objetos? Pessoalmente, passo o número de quadros na animação para meus objetos em seus construtores; então, tenho uma função Animate () padrão que absorve a quantidade de quadros na animação.

Depende da implementação. No meu mecanismo, faço animação no Direct3D e no DirectDraw.

No DirectDraw, crio uma imagem grande. De qualquer maneira, tudo é armazenado na memória do sistema, o que acaba se resumindo a um bloco unidimensional de dados.

Prós:

• Fácil de se mover entre os quadros. Mude o ponteiro inicial, adicione o tom (a largura total da imagem) a cada ano e você estará dourado.

Contras:

• Não é possível copiar apenas um quadro na tela, você deve fazê-lo manualmente.

• gigantesco bloco de memória. Hustling frames ao redor vem em uma penalidade.

Em Direct3D Eu uso texturas distintas. Isso ocorre porque eu não tenho idéia das limitações de textura de um dispositivo, então não sei se ele suporta texturas do tamanho de toda a imagem.

Prós:

• Você pode copiar um quadro diretamente para a tela, porque são todas entidades separadas.

Contras:

• Falta de alinhamento de memória.

Nos meus jogos , eu dei à minha classe base Sprite o conhecimento sobre como desenhar a si mesmo, e todos os elementos animados herdam esse conhecimento: número e duração dos quadros de animação, posição na tela etc. O loop principal do jogo itera por todos dos sprites, pedindo que cada um se desenhe como achar melhor. Parece funcionar bastante bem e é um pouco mais modular para inicializar: se você adicionar um novo sprite com um loop de animação diferente (ou ainda mais complexo: vários estados de animação), não precisará voltar e reescrever o Animate () rotina para acomodar a complexidade adicional:

Dim Waves as Sprite
Dim Char as Sprite

Sub Animate()
     Char.update()
     Waves.update()
End Sub

Cada vez que o método update () de um sprite é chamado, ele sabe se deve redesenhar o mesmo quadro da última vez, passar para o próximo quadro na animação atual, mudar para uma nova animação etc.

Isso tem o benefício adicional de facilitar muito o ajuste da taxa de quadros para acomodar velocidades diferentes de renderização de relógio / plataforma, porque a única alteração é a frequência com que você chama Animate ().