Acelere os fluxos de trabalho de seus programadores

Recentemente, publicamos duas postagens no blog, Cinco maneiras de acelerar seus fluxos de trabalho no Editor e Acelerar seus fluxos de trabalho de artista, ambas baseadas em nosso e-book para desenvolvedores profissionais, Mais de 70 dicas para aumentar a produtividade com o Unity 2020 LTS. Nesta terceira e última postagem do blog da série, vamos nos concentrar nos fluxos de trabalho e nos recursos que ajudam os programadores a fazer mais em menos tempo. Vamos começar falando sobre como o senhor pode economizar tempo de compilação ao fazer testes de jogo.

Quando o senhor entra no modo Play, o projeto começa a ser executado como em uma compilação. Todas as alterações feitas no Editor durante o modo Play serão redefinidas quando o usuário sair do modo Play.

Cada vez que o senhor entra no modo Play no Editor, a Unity realiza duas ações importantes:

• Recarga de domínio: O Unity faz backup, descarrega e recria estados de script.
• Recarga de cena: A Unity destrói a cena e a carrega novamente.

Essas duas ações levam cada vez mais tempo à medida que os scripts e as cenas se tornam mais complexos.

Se o senhor não planeja fazer mais alterações no script, aproveite as Enter Play Mode Settings (Edit > Project Settings > Editor) para economizar tempo de compilação. A Unity oferece ao senhor a opção de desativar o Domain Reload, o Scene Reload ou ambos. Isso pode acelerar a entrada e a saída do modo Play.

Lembre-se de que, se o senhor planeja fazer outras alterações no script, precisará reativar o Domain Reload. Da mesma forma, se o senhor modificar a hierarquia da cena, deverá reativar o Scene Reload. Caso contrário, pode ocorrer um comportamento inesperado.

Um assembly é uma biblioteca de código C#, uma coleção de tipos e recursos criados para trabalhar em conjunto e formar uma unidade lógica de funcionalidade. Por padrão, a Unity compila quase todos os seus scripts de jogo em um assembly predefinido, Assembly-CSharp.dll. Isso funciona bem para projetos pequenos, mas tem algumas desvantagens:

• Toda vez que o senhor altera um script, a Unity recompila todos os outros scripts.
• Um script pode acessar tipos definidos em qualquer outro script.
• Todos os scripts são compilados para todas as plataformas.

A organização de seus scripts em conjuntos personalizados promove a modularidade e a reutilização. Isso impede que eles sejam adicionados automaticamente aos assemblies padrão e limita os scripts que eles podem acessar.

O senhor pode dividir seu código em vários assemblies, conforme mostrado no diagrama acima. Aqui, qualquer alteração no código em Main não pode afetar o código em Stuff. Da mesma forma, como a Library não depende de outros assemblies, o senhor pode reutilizar facilmente o código da Library em praticamente qualquer outro projeto.

Assemblies in .NET contém informações gerais sobre assemblies em C#. Consulte Definições de assembleias na documentação do Unity para obter mais informações sobre como definir suas próprias assembleias no Unity.

O senhor já se pegou repetindo as mesmas alterações ao criar um novo script? O senhor instintivamente adiciona um namespace ou exclui a função de evento de atualização? Economize alguns toques no teclado e crie consistência em toda a equipe configurando o modelo de script no ponto de partida de sua preferência.

Toda vez que o senhor cria um novo script ou shader, a Unity usa um modelo armazenado no

%EDITOR_PATH%\Data\Resources\ScriptTemplates:

• Windows: C:\Arquivos de Programas\Unity\Editor\Data\Resources\ScriptTemplates
• Mac: /Applications/Hub/Editor/[version]/Unity/Unity.app/Contents/Resources/ScriptTemplates

O modelo padrão do MonoBehaviour é este:

81-C# Script-NewBehaviourScript.cs.txt

Há também modelos para shaders, outros scripts de comportamento e definições de montagem.

Para modelos de script específicos do projeto, crie uma pasta Assets/ScriptTemplates e, em seguida, copie os modelos de script para essa pasta para substituir os padrões.

O senhor também pode modificar os modelos de script padrão diretamente para todos os projetos, mas certifique-se de fazer backup dos originais antes de fazer qualquer alteração.

O arquivo original 81-C# Script-NewBehaviourScript.cs.txt tem a seguinte aparência:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

#ROOTNAMESPACEBEGIN#
public class #SCRIPTNAME# : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        #NOTRIM#
    }

    // Update is called once per frame
    void Update()
    {
        #NOTRIM#
    }
}
#ROOTNAMESPACEEND#

É útil ter em mente essas duas palavras-chave:

• #SCRIPTNAME# indica o nome do arquivo inserido ou o nome do arquivo padrão (por exemplo, NewBehaviourScript).
• O #NOTRIM# garante que os colchetes contenham uma linha de espaço em branco.

Reinicie o Unity Editor e suas alterações deverão aparecer sempre que o senhor criar um MonoBehaviour personalizado.

O senhor também pode modificar os outros modelos de forma semelhante. Lembre-se de manter uma cópia do original, além das modificações, em algum lugar fora do projeto Unity, para fins de segurança.

A Unity tem uma variedade de atributos que podem ser colocados acima de uma classe, propriedade ou função para indicar um comportamento especial. O C# contém nomes de atributos entre colchetes.

Aqui estão alguns atributos comuns que o senhor pode adicionar aos seus scripts:

Essa é apenas uma pequena amostra dos inúmeros atributos com os quais o senhor pode trabalhar. O senhor desejarenomear suas variáveis sem perder seus valores? Ou invocar alguma lógica sem um GameObjects vazio? Consulte a API de scripts para obter uma lista completa de atributos e ver o que é possível.

O senhor pode até mesmo criar seu próprio PropertyAttribute para definir atributos personalizados para as variáveis de seu script

Um dos recursos mais poderosos do Unity é seu Editor extensível. Use o Kit de ferramentas da interface do usuário ou o pacote IMGUI para criar UIs do Editor, como janelas e inspetores personalizados.

O UI Toolkit tem um fluxo de trabalho semelhante ao desenvolvimento padrão da Web. Use sua linguagem de marcação inspirada em HTML e XML, a UXML, para definir interfaces de usuário e modelos reutilizáveis de UI. Em seguida, aplique Unity Style Sheets (USS) para modificar o estilo visual e os comportamentos de suas UIs.

Como alternativa, o senhor pode usar o modo imediato, IMGUI, conforme mencionado acima. Primeiro, derive da classe base Editor e, em seguida, use o atributo CustomEditor .

Qualquer uma das soluções pode criar um inspetor personalizado.

Um Editor personalizado modifica a forma como o script MyPlayer aparece no Inspetor:

Consulte Criação de interfaces de usuário (UI) para saber mais sobre como implementar scripts personalizados do Editor usando o UI Toolkit ou o IMGUI. Para uma rápida introdução ao UI Toolkit, assista ao tutorial Getting started with Editor scripting.

O Addressables Asset System simplifica a forma como o senhor gerencia os ativos que compõem o seu jogo. Qualquer ativo, incluindo Scenes, Prefabs, ativos de texto e assim por diante, pode ser marcado como "Addressables" e receber um nome exclusivo. O senhor pode chamar esse alias de qualquer lugar.

Adicionar esse nível extra de abstração entre o jogo e seus recursos pode agilizar determinadas tarefas, como a criação de um pacote separado de conteúdo para download. Esse sistema também facilita a referência a esses pacotes de ativos, sejam eles locais ou remotos.

Para começar, instale o pacote Addressables no Package Manager e adicione algumas configurações básicas ao projeto. Cada ativo ou pré-fabricado do projeto deve ter a opção de se tornar "Addressables". Marque a opção abaixo do nome de um ativo no Inspector para atribuir a ele um endereço exclusivo padrão.

Uma vez marcados, os ativos correspondentes aparecerão na janela Window > Asset Management > Addressables > Groups (Janela > Gerenciamento de ativos > Addressables > Grupos ).

Por conveniência, o senhor pode renomear cada endereço no campo Address individual do ativo ou simplificar todos eles de uma vez.

Agrupe esses ativos para hospedá-los em um servidor em outro lugar ou distribua-os localmente em seu projeto. Onde quer que cada ativo resida, o sistema pode localizá-lo usando a string Addressables Name.

Agora o senhor pode usar seus ativos Addressable por meio da API Addressables.

Vale a pena observar que, sem os Addressables, o senhor teria de fazer o seguinte para instanciar um Prefab na sua cena:

public GameObject prefabToCreate;

public void CreatePrefab() 
{
    GameObject.Instantiate(prefabToCreate);
}
view rawgistfile1.txt hosted with ❤ by GitHub

A desvantagem é que qualquer Prefab referenciado (como o prefabToCreate) será carregado na memória, mesmo que a Scene não precise dele.

Usando Addressables, faça isso em vez disso:

public string prefabByAddress;
… 
public void CreatePrefabWithAddress() 
{
    Addressables.Instantiate(prefabByAddress, instantiationParameters, bool);
}

Isso carrega o ativo por sua string de endereço, o que significa que o Prefab não é carregado na memória até que seja necessário (quando invocamos Adressables.Instantiate dentro de CreatedPrefabWithAddress). Além disso, o senhor pode usar os Addressables para contagem de referência de alto nível, para descarregar automaticamente os pacotes e seus ativos associados quando não estiverem mais em uso.

Histórias das trincheiras de otimização: Economia de memória com Addressables mostra um exemplo de como organizar seus Addressables Groups para que sejam mais eficientes em termos de memória. Enquanto isso, o site Addressables: Introdução aos conceitos O tutorial oferece uma visão geral rápida de como o Addressables Asset System pode funcionar em seu projeto.

Se o senhor estiver operando um jogo ao vivo, talvez queira considerar o uso da solução Cloud Content Delivery (CCD) da Unity com Addressables. O sistema Addressables armazena e cataloga os ativos do jogo para que possam ser localizados e chamados automaticamente. Em seguida, o CCD envia esses ativos diretamente para os jogadores, totalmente separado do código. Isso reduz o tamanho da compilação e elimina a necessidade de fazer com que os jogadores baixem e instalem novas versões do jogo sempre que o senhor fizer uma atualização. Para saber mais, leia este blog sobre a integração entre Addressables e Cloud Content Delivery.

O recurso Platform Dependent Compilation (Compilação dependente da plataforma ) permite que o senhor divida seus scripts para compilar e executar códigos para uma plataforma específica.

Este exemplo faz uso das diretivas #define da plataforma existente com a diretiva #if do compilador:

using UnityEngine;
using System.Collections;

public class PlatformDefines : MonoBehaviour 
{
  void Start () 
  {
    #if UNITY_EDITOR
      Debug.Log("Unity Editor");
    #endif

    #if UNITY_IOS
      Debug.Log("Iphone");
    #endif

    #if UNITY_STANDALONE_OSX
      Debug.Log("Stand Alone OSX");
    #endif

    #if UNITY_STANDALONE_WIN
      Debug.Log("Stand Alone Windows");
    #endif

  }          
}

Use a #definição DEVELOPMENT_BUILD para identificar se o seu script está sendo executado em um player que foi criado com a opção Development Build.

O senhor pode compilar seletivamente para versões específicas do Unity e/ou backends de script e até mesmo fornecer suas próprias diretivas #define personalizadas ao testar no Editor. Abra o painel Other Settings (Outras configurações), que faz parte das configurações do Player, e navegue até Scripting Define Symbols (Script Definir símbolos).

Consulte Compilação dependente da plataforma para obter mais informações sobre as diretivas do pré-processador da Unity.

Um ScriptableObject é um contêiner de dados que salva grandes quantidades de dados, separado das instâncias de classe. Os ScriptableObjects evitam a cópia de valores, o que pode reduzir o uso de memória do seu projeto. Confira o e-book completo para ver alguns exemplos de como usar ScriptableObjects. Caso contrário, leia a documentação do ScriptableObject para obter mais detalhes sobre o uso de ScriptableObjects em seu aplicativo.

O senhor está procurando ainda mais? Assista a Better data with ScriptablesObjects in Unity para uma rápida introdução e veja como eles podem ajudar no gerenciamento de cenas em Achieve better Scene workflow with ScriptableObjects.

Dica de otimização

Recomendamos formatos de serialização binária, como MessagePack ou Protocol Buffers, para dados salvos, em vez de formatos baseados em texto, como JSON ou XML. Nas revisões de projeto, esses formatos de serialização binária reduzem os problemas de memória e desempenho associados aos últimos.

A Unity oferece suporte para os seguintes ambientes de desenvolvimento integrado(IDEs):

• Visual Studio: IDE padrão no Windows e no macOS
• Visual Studio Code: Windows, macOS, Linux
• JetBrains Rider: Windows, macOS, Linux

As integrações do IDE para todos esses três ambientes aparecem como pacotes no Package Manager.

Quando o senhor instala o Unity no Windows e no macOS, o Visual Studio é instalado por padrão. Se o senhor quiser usar outro IDE, basta procurar o editor em Unity > Preferences > External Tools > External Script Editor.

O Rider foi desenvolvido com base no ReSharper e inclui a maioria de seus recursos. Ele oferece suporte à depuração de C# no tempo de execução de scripts do .NET 4.6 no Unity (C# 8.0). Para obter mais informações, consulte a documentação da JetBrains sobre o Rider for Unity.

O VS Code é um editor de código gratuito e simplificado com suporte para depuração, execução de tarefas e controle de versão. Observe que o Unity requer o Mono (macOS e Linux), o Visual Studio Code C# e o Visual Studio Code Debugger for Unity (sem suporte oficial) ao usar o VS Code.

Cada IDE tem seus próprios méritos. Consulte Suporte ao ambiente de desenvolvimento integrado (IDE) para obter mais informações sobre como escolher o IDE certo para suas necessidades.

Dê uma olhada no e-book para obter uma lista de atalhos que podem beneficiar seu projeto e assista às dicas e truques do Visual Studio para aumentar sua produtividade e obter mais melhorias no fluxo de trabalho com o Visual Studio.

Interessado em explorar o JetBrains Rider? Confira o Fast C# scripting in Unity with JetBrains Rider, ou estas dicas sobre como usar o JetBrains Rider como seu editor de código.

O Unity Debugger permite que o senhor depure seu código C# enquanto a Unity Entity está no modo Play. O senhor pode anexar pontos de interrupção no editor de código para inspecionar o estado do código do script e suas variáveis atuais em tempo de execução.

Vá para o canto inferior direito da barra de status do Unity Editor para definir o modo de otimização de código como Debug. O senhor também pode alterar esse modo na inicialização em Edit > Preferences > General > Code Optimization On Startup.

No editor de código, defina um ponto de interrupção onde deseja que o depurador pause a execução. Basta clicar sobre a área da margem esquerda/guia onde deseja alternar um ponto de interrupção (ou clicar com o botão direito do mouse para ver o menu de contexto para outras opções). Um círculo vermelho aparecerá ao lado do número da linha destacada (veja a imagem abaixo).

Selecione Attach to Unity em seu editor de código e, em seguida, execute o projeto no Unity Editor.

No modo Play, o aplicativo será pausado no ponto de interrupção, dando ao senhor tempo para inspecionar as variáveis e investigar qualquer comportamento não intencional.

Como mostrado acima, o senhor pode inspecionar as variáveis durante a depuração, observando a lista ser construída, uma etapa de cada vez, durante a execução.

Use os controles Continue Execution, Step Over, Step Into e Step Out para navegar no fluxo de controle.

Pressione Stop para encerrar a depuração e retomar a execução no Editor.

O senhor também pode depurar o código do script em um Unity Player. Apenas certifique-se de que o Development Build e o Script Debugging estejam ativados em File > Build Settings antes de criar o Player. Marque Wait for Managed Debugger (Esperar pelo depurador gerenciado) para aguardar o depurador antes que o Player execute qualquer código de script. Para anexar o editor de código ao Unity Player, selecione o endereço IP (ou nome da máquina) e a porta do seu Player. Em seguida, prossiga normalmente no Visual Studio com a opção Attach To Unity.

A Unity fornece uma classe Debug para ajudar o senhor a visualizar informações no Editor enquanto ele está em execução. Saiba como imprimir mensagens ou avisos na janela Console, desenhar linhas de visualização nas visualizações Scene e Game e pausar o modo Play no Editor a partir do script. Aqui estão mais algumas dicas para ajudar o senhor a começar:

1. Pausar a execução com Debug.Break. Isso é útil para verificar determinados valores no Inspector quando é difícil pausar o aplicativo manualmente.

2. O senhor deve estar familiarizado com Debug.Log, Debug.LogWarninge Debug.LogError para imprimir mensagens do console. Também é útil Debug.Assertque afirma uma condição e registra um erro em caso de falha. Observe, no entanto, que isso só funciona se o símbolo UNITY_ASSERTIONS estiver definido. Registre mensagens, avisos e erros no Console.

3. Ao usar o Debug.Logo senhor pode passar um objeto como contexto. Se o senhor clicar na mensagem no Console, a Unity destacará o GameObjects na janela Hierarchy.

4. Use o Rich Text para marcar seu Debug.Log declarações. Isso pode ajudar o senhor a melhorar os relatórios de erros no Console.

5. O Unity não remove automaticamente o Debug das compilações que não são de desenvolvimento. Envolva suas chamadas de registro de depuração em métodos personalizados e decore-os com o atributo [Conditional]. Para compilar os registros de depuração de uma só vez, remova o símbolo de definição de script correspondente das configurações do jogador. Isso é idêntico a envolvê-los em blocos de pré-processador #if... #endif . Consulte este guia de otimizações gerais para obter mais detalhes.

6. Solução de problemas de física? Debug.DrawLine e Debug.DrawRay podem ajudá-lo a visualizar o raycasting.

1. Se o senhor quiser que o código seja executado somente quando o Development Build estiver ativado, verifique se Debug.isDebugBuild retorna true.

2. Usar Application.SetStackTraceLogTypeou as caixas de seleção equivalentes em Player Settings, para decidir que tipo de mensagens de registro deve incluir rastreamentos de pilha. Os rastreamentos de pilha podem ser úteis, mas são lentos e geram lixo.

Por padrão, a entrada de registro do console mostra duas linhas. Para melhorar a legibilidade, o senhor pode simplificá-las em apenas uma linha. Veja como abaixo.

Como alternativa, o senhor pode usar mais linhas para entradas mais longas.

Quando o Unity compila, o ícone no canto inferior direito pode ser difícil de ver. Use esse script personalizado do Editor para chamar EditorApplication.isCompiling. Isso cria uma janela flutuante para tornar o status do compilador mais visível.

Inicie o MenuItem para inicializar a janela. O senhor pode até modificar sua aparência com um novo GUIStyle para atender às suas preferências.

using UnityEditor;
using UnityEngine;

public class CustomCompileWindow : EditorWindow
{
    [MenuItem("Examples/CustomCompileWindow")]
    static void Init()
    {
        EditorWindow window = GetWindowWithRect(typeof(CustomCompileWindow), new Rect(0, 0, 200, 200));
        window.Show();
    }
   void OnGUI()
    {
        EditorGUILayout.LabelField("Compiling:", EditorApplication.isCompiling ? "Yes" : "No");
       this.Repaint();
    }
}

O Unity tem integrações com dois sistemas de controle de versão (VCS): Perforce e Plastic SCM. Para definir os servidores Perforce ou Plastic SCM para seu projeto Unity, vá para Project Settings > Editor. Configure o servidor (e suas credenciais de usuário para o Perforce) em Version Control.

As equipes no Unity podem usar o Plastic SCM Cloud Edition gratuitamente, para até 5 GB de armazenamento e um máximo de três usuários. Ao usar o Plastic SCM para Unity, o senhor pode sincronizar suas alterações com o trabalho de seus colegas de equipe e consultar o histórico do projeto sem sair do Unity. Leia sobre algumas atualizações recentes do Plastic SCM aqui.

O senhor também pode usar um sistema externo, como o Git, incluindo o Git LFS (Large File Support) para um controle de versão mais eficiente de ativos maiores, como recursos gráficos e de som. Para a conveniência adicional de trabalhar com o serviço de hospedagem do GitHub, instale o plug-in do GitHub para Unity. Essa extensão de código aberto permite que o senhor visualize o histórico do seu projeto, faça experimentos em ramificações, cometa suas alterações e envie seu código para o GitHub, tudo dentro do Unity.

A Unity mantém um arquivo .gitignore. Isso pode ajudar o senhor a decidir o que deve e o que não deve ir para o repositório Git e, em seguida, aplicar essas regras.

O Unity Teams é outra opção para simplificar seus fluxos de trabalho, pois permite que o senhor armazene todo o seu projeto na nuvem. Isso significa que o backup é feito e pode ser acessado em qualquer lugar, tornando muito mais fácil salvar, compartilhar e sincronizar seus projetos Unity com qualquer pessoa.

Confira as duas primeiras postagens do blog desta série, 5 maneiras de acelerar seus fluxos de trabalho no Editor e Acelerar seus fluxos de trabalho de artista. O senhor também pode baixar o guia gratuito com mais de 70 dicas para aumentar a produtividade com o Unity 2020 LTS , que compila todas as dicas em um e-book prático.

Como sempre, informe-nos sobre quaisquer tópicos ou recursos adicionais que gostaria de ouvir nos comentários e sinta-se à vontade para compartilhar suas próprias dicas de produtividade com a comunidade.