.
Processos para gerenciar uma atualização de mecanismo
Se você tem um projeto Blueprint, atualizar o mecanismo deve ser muito simples: não há código para atualizar, basta carregar seu projeto na nova versão do mecanismo, ver quais erros de ativos surgem e corrigir o que o mecanismo está reclamando.
Atualizar um projeto de código é mais complicado e é o que abordaremos aqui. A chave é o quanto você personalizou o mecanismo. Se você deixou o mecanismo inalterado, novamente deve ser muito simples atualizá-lo; no entanto, o esforço aumenta rapidamente se você fizer modificações significativas no motor. Ficamos em algum ponto intermediário e as práticas a seguir nos ajudaram a gerenciar o processo de atualização.
Gerenciando divergências de mecanismo
Ajuda a marcar e rastrear suas alterações no mecanismo, pois isso simplificará o processo de mesclagem de conflitos de código. Para Rouxinolseguimos este processo:
- Todas as alterações no mecanismo são revisadas por um grupo de aprovadores; para nós, esses são os mesmos programadores que cuidam das atualizações do mecanismo para que possam indicar alterações que seriam difíceis de manter.
- Encorajamos que tantas alterações quanto possível sejam adiadas para a Epic, consulte Contribuindo para o Unreal Engine. Isso nos permite remover divergências de código ao realizar uma versão futura.
- Todas as alterações são marcadas em código e rastreadas com um ticket do Jira. Por exemplo:
// NTGL_BEGIN - NTGL-1234 - [IMPROVEMENT] Fixing an uninitialized variable
// int IntVar;
int IntVar = 0;
// NTGL_END
- As divergências são categorizadas da seguinte forma:
- [IMPROVEMENT] – a mudança é adequada para ser enviada para a Epic
- [TEMP] – a mudança é necessária apenas temporariamente, geralmente até a próxima atualização importante do mecanismo
- [PREPORT] – a mudança foi retirada de uma atualização futura
- [DIVERGENCE] – precisamos fazer essa mudança para lançar nosso jogo, mas não é uma mudança adequada para ser adiada para a Epic (geralmente queremos evitar fazer essas mudanças)
- O ticket do Jira nos permite rastrear contexto adicional em torno da alteração, como links para UDN, links para outras tarefas que exigiram a alteração e tarefas necessárias para remover a alteração.
- Quando uma divergência não pode ser facilmente mesclada com uma atualização de mecanismo, normalmente descartamos nossas alterações e as reimplementamos em torno do novo código, ou abandonamos totalmente nossas alterações.
Processo de integração
Atualizar o mecanismo pode inicialmente ser tão simples quanto obter a atualização no Github da Epic, substituir tudo na pasta Engine e reconciliar o trabalho offline por meio do P4V; no entanto, isso rapidamente se tornará incontrolável à medida que você fizer alterações no código do mecanismo.
Aproveitando os stream depots do Perforce, estabelecemos as seguintes filiais:
| Depósito / fluxo | Descrição |
|---|---|
|
//ue4/release-4.27 //ue5/release-5.0 |
Espelhos não modificados das versões UE4/UE5 |
| //ntgl/dev |
Fluxo de desenvolvimento principal, onde a maior parte da sua equipe está trabalhando |
| //ntgl/integrar |
Fluxo filho do desenvolvedor, onde você mesclará as atualizações do mecanismo
|
Antes de iniciar a atualização para UE5, você desejará estabelecer o histórico de revisões mesclando a versão final do UE4 (//ue4/release-4.27) com seu stream integrado. Se você ainda não está no 4.27, pode estar pensando em passar por várias versões ao mesmo tempo. Em nossa experiência, é sempre mais fácil atualizar gradualmente uma versão por vez.
Você então estabeleceria seu branch release-5.0 da seguinte maneira:
- cópia p4 //ue4/release-4.27 -> //ue5/release-5.0 (inicialmente criado como uma cópia do 4.27)
- Atualize o conteúdo de //ue5/release-5.0 do lançamento oficial
As etapas de atualização e mesclagem agora se tornam:
- Mesclar todas as alterações do seu fluxo de desenvolvimento em um fluxo de integração
- Se houver algum conflito com alterações de conteúdo, sempre aceite o que vem do desenvolvedor para não perder nenhum trabalho dos criadores de conteúdo
- Espelhe a versão Unreal desejada em um depósito Perforce separado (por exemplo //ue5/release-5.x)
- Este espelho deve permanecer inalterado e serve para rastrear as alterações do mecanismo no histórico de revisões do Perforce para ajudar na etapa de mesclagem
- Mesclar/integrar de //ue5/release-5.x -> //ntgl/integrate
- Resolva conflitos de mesclagem e envie
Todas essas etapas podem ser executadas manualmente, mas se beneficiam muito com um pouco de esforço para automatizar por meio de scripts.
Depois de mesclar a atualização, você pode dividir a tarefa de atualização do mecanismo nestas etapas distintas:
- Corrigir avisos e erros relacionados à geração de projetos de código
- Corrija erros de compilação e link
- Corrija erros do editor e do cozinheiro
- Corrigir falhas de autoteste
- Corrigir bugs do jogo
Automação
Investir em automação pode realmente ajudar a agilizar o processo de atualização. Idealmente, você teria um processo de construção repetível que pode ser executado em seu fluxo de integração e validar se tudo está funcionando antes de mesclar com seu fluxo de desenvolvimento. Algumas áreas adicionais que nos ajudaram:
- Investir e manter um conjunto abrangente de testes automatizados pode realmente ajudar a detectar muitos problemas antes mesmo de você precisar fazer qualquer teste manual. No nosso caso, com a nossa mudança inicial para o UE5, nossos testes automatizados foram capazes de sinalizar muitas inconsistências entre o mecanismo de física do UE4 e a física do Caos do UE5.
- Escrever scripts pode acelerar bastante o processo de espelhamento de versões e as várias etapas de fusão.
- Adicionar verificações de automação adicionais para executar validadores de ativos e compilar todos os Blueprints (-run=CompileAllBlueprints) antes de preparar seu jogo ajudará a detectar problemas adicionais em seus ativos.
- Executar frequentemente seu fluxo de integração por meio do processo de construção exato pelo qual seu fluxo de desenvolvimento passa ajuda a garantir que quaisquer casos extremos ocultos sejam detectados antes de sua mesclagem final.
- Investir em sistemas para distribuir compilações de teste do seu fluxo de integração para permitir testes de jogo em maior escala pode ajudar a expor problemas do jogo antecipadamente.
Dicas e truques
Estas são uma variedade de dicas que seguimos para agilizar o processo de atualização.
- Ao fazer uma atualização importante do mecanismo, a maioria dos arquivos será resolvida automaticamente, mas você ficará com uma lista de alterações contendo dezenas de milhares de alterações. O seguinte comando p4 permitirá separar os arquivos que precisam ser resolvidos manualmente em uma lista de alterações separada:
p4 -F %localPath% resolve -n | p4 -x - reopen -c [new changelist #]
- Ao corrigir erros de compilação e link, compile com
-DisableUnity. Isso desativará a otimização de compilação no UnrealBuildTool, que combina muitos arquivos .cpp em um. A compilação levará mais tempo, mas rastrear problemas de compilação será muito mais fácil, e isso também permitirá que você detecte problemas relacionados à falta de instruções include. - Se você obtiver o Unreal Engine por meio do github, precisará decidir como preencher os arquivos obtidos em GitDependencies.exe. Você pode fazer com que os desenvolvedores atualizem esses arquivos individualmente ou, em nosso caso, incorporamos esses arquivos nos scripts de automação de espelho, enviando esses arquivos para nosso próprio espelho Perforce.
- Preste muita atenção aos avisos de descontinuação do Unreal Engine, pois eles geralmente apontam a direção certa para atualizar seu projeto. Manter uma compilação de aviso 0 torna muito mais fácil manter o controle dessas depreciações.
- Incluir todos os seus ativos no fluxo de integração significa que você terá a capacidade de atualizar ativos individuais, se necessário. Embora não precisemos fazer muito isso, pode ser complicado gerenciar se esses ativos forem modificados regularmente em seu fluxo de desenvolvimento principal. Algumas sugestões para ajudar com isso:
- Se você puder escolher algumas alterações mínimas de mecanismo em seu fluxo de desenvolvimento e atualizar os ativos no desenvolvimento, isso eliminará a possibilidade de conflitos.
- Se os ativos puderem ser atualizados usando um commandlet, você poderá criar um commandlet que seja executado após cada mesclagem para garantir que todos os ativos relevantes sejam mantidos atualizados. Em muitos casos, o ativo simplesmente precisa ser salvo novamente na versão mais recente do editor.
- A Epic permite que você obtenha acesso às ramificações do lançamento antes mesmo de o lançamento entrar em um estado de visualização antecipada. Isso permite que você tenha uma vantagem inicial na mesclagem de uma versão futura e restrinja o escopo de quanto código você mescla de uma vez. Da mesma forma, mesclar diariamente a partir de sua linha de desenvolvimento permite interceptar mesclagens difíceis assim que elas chegam, para que você possa trabalhar com os desenvolvedores relevantes para resolver o problema.
- Se você depende de plug-ins de terceiros (do Marketplace ou de outros fornecedores), provavelmente é melhor esperar um pouco até que esses plug-ins sejam atualizados. Muitas vezes queremos atualizar antes dessas atualizações, o que significa gastar um esforço adicional para atualizar os plug-ins que você obteria “de graça” se esperasse um pouco mais.
- Cada nova atualização do mecanismo traz alguns recursos realmente úteis. Por mais tentador que seja começar a aproveitar as vantagens dos novos recursos imediatamente, nosso objetivo é sempre lançar inicialmente uma nova atualização de mecanismo com o mínimo possível de alterações significativas no jogo ou nos fluxos de trabalho do desenvolvedor. Somente depois de determinarmos que a atualização é estável em nosso fluxo de desenvolvimento é que começamos a testar novos recursos.
Benefícios do Unreal Engine 5
Atualizar para Lumen e Nanite era uma perspectiva interessante. Quem não gostaria de uma luz refletida mais precisa e a capacidade de aumentar significativamente o orçamento poli do seu jogo?
.
