1.1 Os territórios reais

1.2 Quando não usar Unity

1.3 O que muda em relação a um jogo

1.4 Licenças, em uma frase cada

• Personal: gratuita até um teto de receita/financiamento anual da empresa; o teto muda, confira na página oficial de planos.
• Pro / Enterprise: por assento, obrigatória acima do teto e necessária para alguns recursos (por exemplo, o suporte a visionOS via PolySpatial exigia licença paga à data desta apostila).
• Unity Industry: o pacote para uso industrial, que inclui ferramentas de importação de CAD (Pixyz) e licenciamento próprio para distribuir aplicações não-jogo.

A taxa por instalação (Runtime Fee) anunciada em 2023 foi cancelada em setembro de 2024; o modelo voltou a ser por assento. Isto importa porque muito conteúdo online ainda discute a taxa como se estivesse em vigor.

2.1 O problema do MonoBehaviour-para-tudo

Tutoriais ensinam a colocar lógica, estado e acesso a dados no mesmo componente pendurado num GameObject. Num jogo pequeno funciona. Numa aplicação, o resultado é previsível: regra de negócio que só roda com a cena aberta, impossível de testar sem Play Mode, FindObjectOfType espalhado, e uma mudança na API do servidor que obriga a editar vinte componentes visuais.

2.2 Três camadas

A regra que sustenta tudo: as dependências apontam para dentro. A apresentação conhece o domínio; o domínio nunca conhece a apresentação. Na prática, isso se impõe com Assembly Definitions (.asmdef): um assembly App.Domain sem referência a UnityEngine (opção "No Engine References") torna fisicamente impossível importar coisa do motor ali dentro — e ainda acelera a compilação.

2.3 MVP / MVVM com componentes finos

// Domínio — C# puro, sem using UnityEngine
public sealed class Sensor
{
    public string Id { get; }
    public double Valor { get; private set; }
    public double Limite { get; }
    public bool EmAlarme => Valor > Limite;
    public event System.Action<Sensor> Mudou;

    public Sensor(string id, double limite) { Id = id; Limite = limite; }
    public void Atualizar(double v) { Valor = v; Mudou?.Invoke(this); }
}

// Apresentação — só traduz estado em visual
public sealed class SensorView : MonoBehaviour
{
    [SerializeField] Renderer indicador;
    [SerializeField] Color normal = Color.green, alarme = Color.red;
    Sensor _sensor;

    public void Ligar(Sensor s) { _sensor = s; s.Mudou += Redesenhar; Redesenhar(s); }
    void OnDestroy() { if (_sensor != null) _sensor.Mudou -= Redesenhar; }
    void Redesenhar(Sensor s) => indicador.material.color = s.EmAlarme ? alarme : normal;
}

2.4 Composição e injeção de dependência

Alguém precisa criar o cliente de API, o repositório e os serviços e entregá-los a quem precisa. Em vez de singletons estáticos, use um composition root: um único ponto que monta o grafo de objetos no arranque. Bibliotecas de DI feitas para Unity, como VContainer (leve, rápida) ou Zenject/Extenject (mais antiga, mais recursos), fazem isso e injetam nas MonoBehaviours da cena. Em projetos pequenos, um composition root escrito à mão num único MonoBehaviour de bootstrap é perfeitamente suficiente.

2.5 Estado da aplicação e cenas aditivas

• Máquina de estados de alto nível: Login → Carregando projeto → Navegação → Modo inspeção → Relatório. Cada estado sabe entrar e sair; nada de flags booleanas espalhadas.
• Cenas aditivas: uma cena "Core" persistente (serviços, câmera, UI raiz) e cenas de conteúdo carregadas e descarregadas com SceneManager.LoadSceneAsync(..., LoadSceneMode.Additive). Trocar de projeto não reinicia os serviços.
• ScriptableObjects servem bem como configuração (limites, URLs por ambiente, paletas) editável no Inspector. Cuidado ao usá-los como estado mutável em tempo de execução: no editor, alterações feitas em Play Mode persistem no asset.

3.1 Os dois sistemas

Para aplicações, a escolha típica é UI Toolkit para a interface de tela (painéis, menus, tabelas) e uGUI (ou UI Toolkit com render texture) para rótulos presos a objetos 3D e para XR. Misturar os dois no mesmo projeto é normal.

3.2 UXML + USS, em miniatura

<!-- PainelSensor.uxml -->
<ui:UXML xmlns:ui="UnityEngine.UIElements">
  <ui:VisualElement class="painel">
    <ui:Label name="titulo" class="painel__titulo" />
    <ui:Label name="valor" class="painel__valor" />
    <ui:Button name="reconhecer" text="Reconhecer alarme" />
  </ui:VisualElement>
</ui:UXML>

/* PainelSensor.uss */
.painel { padding: 12px; background-color: rgb(21, 34, 44); border-radius: 8px; }
.painel__valor { font-size: 28px; -unity-font-style: bold; }
.painel--alarme .painel__valor { color: rgb(220, 60, 60); }

var raiz = GetComponent<UIDocument>().rootVisualElement;
var valor = raiz.Q<Label>("valor");
raiz.Q<Button>("reconhecer").clicked += () => servicoAlarmes.Reconhecer(sensor.Id);
// mudar o estado visual trocando classe, não cor no código:
raiz.EnableInClassList("painel--alarme", sensor.EmAlarme);

3.3 Localização

Aplicações corporativas quase sempre precisam de mais de um idioma. O pacote Localization (com.unity.localization) gerencia tabelas de strings e de assets por idioma, formatação de números e datas por cultura e troca de idioma em tempo de execução. Duas regras: nunca concatenar frases ("Há " + n + " alarmes" quebra em idiomas com outra ordem ou outras regras de plural — use strings com marcadores e as regras de plural do pacote) e reservar espaço: textos em alemão costumam ser bem mais longos que em inglês.

3.4 Acessibilidade

É o ponto fraco do Unity em comparação com web e nativo. Desde o Unity 2023.2 há APIs de acessibilidade para expor uma hierarquia a leitores de tela em Android e iOS, mas o suporte é mais limitado e exige trabalho explícito. Em aplicações de uso obrigatório (treinamento de funcionários, serviço público), trate isso como requisito: contraste, tamanho de texto ajustável, navegação completa por teclado/controle, legendas, e alternativa textual para informação que só existe em cor. Se o requisito legal for forte, é mais um argumento para a UI principal ser web/nativa com Unity embutido (módulo 7).

4.1 A regra da thread principal

Quase toda a API do Unity (Transform, GameObject, materiais, UI) só pode ser tocada na thread principal. Você pode — e deve — fazer parsing de JSON grande, cálculos e I/O noutras threads, mas o resultado tem de voltar à thread principal antes de mexer na cena. No Unity 6, o tipo Awaitable torna isso explícito:

async Awaitable CarregarHistoricoAsync(string url)
{
    using var req = UnityWebRequest.Get(url);
    req.SetRequestHeader("Authorization", "Bearer " + sessao.Token);
    await req.SendWebRequest();                // não bloqueia o frame

    if (req.result != UnityWebRequest.Result.Success)
    { ui.MostrarErro(req.error); return; }

    string json = req.downloadHandler.text;
    await Awaitable.BackgroundThreadAsync();     // sai da thread principal
    var historico = JsonConvert.DeserializeObject<List<Leitura>>(json);

    await Awaitable.MainThreadAsync();           // volta antes de tocar na cena
    grafico.Desenhar(historico);
}

JsonConvert vem do pacote Newtonsoft (com.unity.nuget.newtonsoft-json); o JsonUtility embutido é mais rápido mas não serializa dicionários, propriedades nem tipos polimórficos — para APIs reais, quase sempre falta alguma coisa.

4.2 Tempo real: escolher o transporte

4.3 Não afogue a cena

Receber 3 000 sensores a 10 Hz são 30 000 mensagens por segundo. Nunca aplique cada mensagem diretamente na cena. Acumule num buffer thread-safe (por exemplo, ConcurrentQueue) na thread de rede, e drene uma vez por frame na thread principal, guardando só o valor mais recente de cada sensor. A cena atualiza no ritmo da tela, não no ritmo da rede.

4.4 Segredos e autenticação

• Um build é um arquivo que o usuário tem na mão. Chaves de API embutidas no código ou em ScriptableObjects podem ser extraídas com ferramentas de descompilação em minutos. Nada de segredo de servidor no cliente.
• O fluxo correto: o usuário autentica (OAuth2/OIDC com o provedor da empresa), o cliente recebe um token de curta duração, e todas as chamadas vão para o seu backend, que guarda as credenciais sensíveis. Veja API Design para o desenho desse backend.

5.1 Por que CAD não entra direto

Um modelo CAD descreve superfícies matemáticas exatas (NURBS) para fabricação. Para renderizar, é preciso tesselar em triângulos — e a tesselação ingênua de uma máquina inteira produz dezenas de milhões de polígonos, inclusive de parafusos internos que ninguém verá. Um BIM de edifício traz, além disso, milhares de objetos separados (cada um virando um draw call) e metadados valiosos que a importação pode perder.

5.2 O pipeline de preparação

5.3 Formatos de intercâmbio

• FBX: o mais comum no Unity; bom para geometria e animação, ruim para metadados ricos.
• glTF 2.0: padrão aberto e leve, excelente para web e para carregar em tempo de execução (pacotes como glTFast).
• OpenUSD: descrição de cena com camadas e composição, cada vez mais usado em pipelines industriais e de gêmeo digital; o suporte no Unity existe via pacotes e evolui.
• IFC: o padrão aberto do BIM; traz a semântica (parede, laje, porta) e as propriedades.

5.4 Conteúdo que não vai no build: Addressables

Uma aplicação que abre projetos diferentes não pode embutir todos no executável. O sistema Addressables empacota conteúdo em bundles carregáveis sob demanda, de disco ou de um servidor, com gestão de dependências e de memória. Para modelos que chegam só em execução (upload do cliente), carregar glTF em runtime é o caminho mais direto. A gestão de memória e a tela de carregamento com Addressables estão detalhadas no capítulo 8 de Serious Games na Web.

6.1 Não renderize o que não mudou

Um jogo redesenha a tela 60 vezes por segundo mesmo com o jogador parado. Uma aplicação aberta o dia todo num tablet, fazendo isso, drena a bateria, aquece o aparelho (que então reduz o clock e fica mais lento) e gasta GPU à toa numa estação de trabalho compartilhada. Duas ferramentas:

// frame rate alvo global
Application.targetFrameRate = 60;

// renderizar só 1 de cada N frames, mantendo o loop (input, lógica) a 60 Hz
using UnityEngine.Rendering;
OnDemandRendering.renderFrameInterval = ocioso ? 12 : 1;   // ~5 fps parado, 60 interagindo

A estratégia: renderização plena durante interação (arrastar, girar, animação, dado chegando) e intervalo alto quando nada muda. Volte a 1 no primeiro evento de input ou mudança de dado.

6.2 Muitos objetos iguais

• GPU Instancing / SRP Batcher: milhares de objetos com a mesma malha e material desenhados em poucas chamadas. Para variar cor por objeto sem quebrar o lote, use MaterialPropertyBlock ou propriedades por instância no shader.
• GPU Resident Drawer (Unity 6, URP/HDRP): automatiza boa parte do instancing para cenas com muitos objetos estáticos — exatamente o perfil de gêmeos digitais e AEC.
• Occlusion culling: não desenhar o que está atrás de paredes; decisivo em interiores de edifícios.

6.3 Memória em sessões longas

Num jogo, um vazamento de 5 MB por minuto pode passar despercebido numa sessão de 30 minutos. Numa app aberta oito horas, são 2,4 GB e um crash no meio do turno. Suspeitos habituais: materiais criados por renderer.material e nunca destruídos, texturas carregadas em runtime sem Destroy, handles de Addressables sem Release, eventos não desinscritos (módulo 2), e alocações de lixo por frame que fazem o garbage collector disparar. O Memory Profiler permite comparar dois snapshots — tirar um no início, usar a app por uma hora, tirar outro e ver o que cresceu é o teste mais valioso desta apostila.

6.4 Arranque

Usuários de aplicação toleram muito menos espera que jogadores. Reduza o que a primeira cena carrega (cena de bootstrap mínima, conteúdo pesado por Addressables depois), evite trabalho pesado em Awake/Start de dezenas de objetos, pré-aqueça shaders (coleções de variantes) para não haver engasgos na primeira interação, e mostre algo útil — o último projeto aberto, por exemplo — enquanto o resto carrega.

7.1 O mapa de entrega

7.2 Unity as a Library

Desde o Unity 2019.3 é possível exportar o projeto como uma biblioteca e embuti-lo numa app nativa Android (módulo/AAR) ou iOS (framework). A app nativa cuida de login, navegação, formulários e acessibilidade; o Unity aparece numa tela para o 3D. A comunicação nos dois sentidos passa por mensagens — do nativo para o Unity com UnitySendMessage (nome do objeto, nome do método, uma string), e do Unity para o nativo por plugins nativos. Limites importantes: só uma instância do runtime por processo, e descarregar o Unity não devolve toda a memória. É a resposta certa ao "catálogo com um botão ver em 3D" do exercício 1, quando o 3D justifica o motor.

7.3 Web

Um build Web permite abrir a aplicação por um link. Os problemas de tamanho, compressão, servidor e memória são os mesmos dos jogos e estão tratados em Serious Games na Web. Para aplicações, o ponto extra é a integração com a página (a app Unity dentro de um portal web existente, trocando dados com ele), que é assunto de uma apostila própria de Unity para web interativa.

7.4 XR

• OpenXR como camada de plataforma e o XR Interaction Toolkit para interação (raios, agarrar, teleporte, UI) cobrem a maioria dos headsets com o mesmo código.
• AR Foundation para AR em telemóveis (ARKit/ARCore): planos, âncoras, imagens rastreadas — base de instruções de manutenção sobrepostas ao equipamento. Mais em Realidade Aumentada.
• visionOS via PolySpatial, com modos de janela, volume e espaço imersivo — cada um com restrições diferentes de renderização.

7.5 Streaming de render

Quando o modelo é pesado demais para o aparelho, o Unity pode rodar num servidor com GPU e enviar vídeo ao navegador, recebendo o input de volta (o pacote Unity Render Streaming, baseado em WebRTC, é o ponto de partida). Resolve o limite do cliente, mas cria dois novos: custo de uma GPU por usuário ativo e latência sensível à rede. Faz sentido para configuradores premium e revisões de projeto com poucos usuários simultâneos; raramente faz sentido para milhares.

8.1 A pirâmide de testes no Unity

A arquitetura do módulo 2 é o que torna isto possível: se a regra está num MonoBehaviour, só um teste PlayMode (lento e frágil) a alcança. Se está no domínio, um teste de milissegundos resolve.

[Test]
public void Sensor_AcimaDoLimite_EntraEmAlarme()
{
    var s = new Sensor("T-101", limite: 80);
    s.Atualizar(85);
    Assert.IsTrue(s.EmAlarme);
}

8.2 Testes de conteúdo

Em aplicações, muitos bugs não estão no código, estão nos assets: um prefab sem componente obrigatório, um material com shader errado, uma cena sem câmera. Testes EditMode que varrem os assets e verificam regras do projeto (toda peça importada tem ID de metadado, toda textura de UI tem compressão certa) pegam esses erros antes do cliente.

8.3 Builds automatizados

O Unity roda sem interface em modo batch (-batchmode -nographics -executeMethod ...), o que permite builds e testes em CI. O projeto open source GameCI oferece ações prontas para GitHub Actions e imagens Docker com o editor. Um pipeline mínimo: a cada pull request, rodar EditMode + PlayMode; a cada merge na branch principal, gerar os builds de cada plataforma e guardar os artefatos. A licença do Unity precisa ser ativada no runner — planeje isso antes.

8.4 Git sem sofrimento

• Asset Serialization = Force Text e Visible Meta Files (padrão nas versões recentes): cenas e prefabs viram YAML legível, mergeáveis em princípio.
• Commitar sempre os .meta: é neles que vive o GUID de cada asset; perder um .meta quebra todas as referências àquele asset.
• Git LFS para binários grandes (modelos, texturas, áudio).
• UnityYAMLMerge (Smart Merge, que vem com o editor) configurado como ferramenta de merge melhora muito os conflitos em cenas e prefabs — mas a melhor defesa é estrutural: cenas pequenas e aditivas, prefabs aninhados, e duas pessoas não editando a mesma cena ao mesmo tempo.
• O .gitignore padrão de Unity exclui Library/, Temp/, Logs/, obj/ e builds. Mais sobre o fluxo em Git & GitHub.

9.1 O que é (e o que não é) um gêmeo digital

Um modelo 3D bonito de uma fábrica não é um gêmeo digital. Passa a ser quando existe uma ligação de dados contínua entre o objeto físico e a representação virtual, de forma que o virtual reflete o estado real (e, nos casos mais maduros, permite simular o que aconteceria com uma mudança antes de aplicá-la). O 3D é a interface; o valor está na ligação.

9.2 A arquitetura em camadas

O ponto que liga o 3D aos dados é o ID do ativo: a mesma chave precisa existir no modelo 3D (preservada na importação — módulo 5), no sistema de dados e no domínio. Sem uma tabela de correspondência confiável, o projeto trava aqui — e em muitos projetos reais, reconciliar a nomenclatura do CAD com a do sistema de manutenção é a tarefa mais demorada de todas.

9.3 Presente: interpolação e dados atrasados

• Interpolar valores contínuos (posição de um robô, nível de um tanque) entre amostras, em vez de saltar — com o cuidado de não inventar dado: indique quando a última leitura é antiga.
• Estado de dado envelhecido: um sensor sem leitura há 5 minutos não está "normal", está desconhecido. Mostre isso explicitamente (cinzento, tracejado) — o pior erro de um gêmeo digital é exibir um estado antigo com cara de atual.

9.4 Passado: histórico e reprodução

Operadores e engenheiros querem voltar no tempo: "o que aconteceu às 3h14 quando a linha parou?". Isso pede consultar a série temporal por janela e reproduzir na mesma cena, com uma linha do tempo. A arquitetura do módulo 2 paga aqui: se a apresentação só lê o estado do domínio, alimentar esse domínio a partir do histórico em vez do tempo real não exige mudar nenhum componente visual.

9.5 Segurança: a rede industrial não é a internet

10.1 Quem contrata

10.2 Perguntas de entrevista

10.3 Projetos de portfólio

1. Mini gêmeo digital: um modelo simples (uma sala, uma máquina) ligado a um broker MQTT com um simulador de sensores em Python; estados normal/alarme/desconhecido, histórico com reprodução. É o projeto que mais conversa com as vagas industriais.
2. Pipeline de CAD: pegar um modelo aberto de engenharia, documentar antes/depois (triângulos, draw calls, tempo de frame) e a seleção de peças preservada após a fusão.
3. Configurador de produto: troca de materiais e opcionais, UI Toolkit com tema, localização em dois idiomas, build desktop e mobile.
4. Unity as a Library: uma app nativa simples com uma tela Unity embutida, trocando mensagens nos dois sentidos.
5. Projeto com engenharia visível: qualquer um dos anteriores com testes, CI (GameCI) e README explicando a arquitetura — o que diferencia um desenvolvedor de aplicações de alguém que só sabe o editor.

10.4 Fontes para continuar

• Documentação oficial: manual do Unity 6 (UI Toolkit, Addressables, Unity Test Framework, Awaitable, OnDemandRendering), documentação do XR Interaction Toolkit e do AR Foundation.
• E-books gratuitos da Unity: os guias de padrões de arquitetura em C# e de otimização de performance, e os de UI Toolkit.
• Industrial: documentação do Pixyz/Unity Industry; os padrões OPC UA (OPC Foundation) e MQTT (OASIS).
• Engenharia: GameCI (documentação e exemplos de pipeline), VContainer.