Aprenda a criar jogos 3D com IA em 2 horas ou menos – sem programação.

O processo geral do trecho de código (que pode ser usado como um prompt para gerar código):

1. Lógica de Movimento do Jogador e Geração de UI

  1. O GameLogic representa o componente central de gerenciamento do jogo. Ele recebe todos os eventos do jogo e os distribui para os subsistemas apropriados, reduzindo efetivamente o acoplamento do código.
  2. Quando o jogador se aproxima de um quadro que contém um BoxCollider, seu componente Transponder anexado detecta automaticamente a interação e passa o evento de aproximação do jogador para o componente GameLogic. Em resposta, o UIFactory instancia um painel de UI para entrada do usuário.
  3. Este painel de UI inclui o componente InputDialog, que escuta a entrada do teclado do jogador. Quando o jogador pressiona Enter pela primeira vez, a caixa de entrada é ativada e captura o foco do teclado. Depois que o jogador termina de digitar e pressiona Enter novamente, a entrada é submetida como um evento ao GameLogic.
  4. Quando o jogador se afasta do quadro que contém o BoxCollider, o painel de UI é imediatamente destruído.

2. Geração de Modelo e Mapeamento de Esqueleto (Fornecido pelo TripoSDK)

  1. Depois que o componente GameLogic recebe a entrada do prompt do jogador, ele passa o prompt para o componente TripoClient (Nota: uma TripoAPIKey válida deve ser fornecida previamente).
  2. O TripoClient chama o componente TripoAPI para enviar o prompt ao Tripo Server. Durante este processo, o TripoAPI monta a requisição, a envia e começa a consultar o servidor em intervalos regulares para verificar atualizações. Uma vez bem-sucedido, o jogador recebe um TaskID para o modelo gerado do Tripo Server. Este TaskID é então usado para solicitar a geração do esqueleto.
  3. Após a conclusão do processo de Rigging, o TripoAPI retorna a URL de download do modelo para o TripoClient. O TripoClient então carrega e analisa o modelo em formato GLB através do plugin glTFfast.
  4. Em seguida, o componente RuntimeHumanoidAvatarBuilder é montado no modelo. Este componente mapeia o esqueleto do modelo GLB para o sistema Humanoid Avatar do Unity, permitindo o retargeting de animação.
  5. Finalmente, o TripoClient instancia o modelo na cena. Neste ponto, os desenvolvedores podem usar recursos de animação humanoide existentes para controlar o modelo recém-gerado.

3. Transferência de Controle

  1. O componente GameLogic escuta a entrada do teclado do jogador para alternar dinamicamente o controle entre o jogador e o modelo gerado. Especificamente, ele ajusta a prioridade da câmera e reatribui o alvo de controle do ThirdPersonController.
  2. Quando o jogador pressiona a tecla F, o controle é transferido do personagem do jogador para o modelo, permitindo que o jogador o opere. Pressionar a tecla F novamente retorna o controle ao jogador.
  3. Dependendo do modelo gerado, seu tamanho pode variar; desde extremamente grande até extremamente pequeno - permitindo interações de jogabilidade únicas e permitindo que o jogador passe por diferentes obstáculos.
  4. Além disso, a aparência do modelo pode ser facilmente trocada, suportando efetivamente um sistema de personalização de personagens e skins de baixo custo dentro do jogo.

Lógica geral do código:

GameObject Principal

Etapas de implementação específicas:

Versão do Unity: 2022.3.55

Caminho do código-fonte e das cenas: Assets-LowPoly Environment Pack - Demo - Demo1

1. Configuração do Projeto e Importação de Recursos:

  1. Criar um Novo Projeto
    1. Abra o Unity e clique em New Project.
    2. Selecione o template URP (Universal Render Pipeline).
    3. Nomeie o projeto como TripoRuntimeTutorial e clique em criar.
  2. Importar Pacotes de Recursos Necessários
    Por favor, abra seu navegador e vá para a Unity Asset Store. Pesquise e baixe os seguintes pacotes gratuitos (também disponíveis nos arquivos do projeto fornecidos):
    Adicione aos Meus Recursos e, nos pop-ups subsequentes, clique em "Open in Unity" e faça o download.
    Após baixar cada pacote, vá para Unity > Assets (no topo do Menu Unity) > Import Package > Custom Package e importe-os um por um. Clique em Import em cada solicitação.
  3. Converter Materiais para URP
    Alguns materiais importados podem aparecer rosados (indicando problema de shader). Para converter:
    • Filtre ou selecione todos os modelos rosados e estranhos na cena.
    • Em seguida, navegue até Editor > Rendering > Materials e converta-os para materiais compatíveis com URP.
  4. Instalar Dependência glTFast (para Carregar modelos GLB)
    Opção 1: Instalar via Git (requer um ambiente Git local)
    Opção 2: Baixar do site oficial da Tripo, que também inclui o plugin glTFast.
    • Visite a página inicial da Tripo e vá para a seção Recursos.
    • Baixe o Plugin Unity, que já inclui a dependência glTFast.
    • Siga o vídeo tutorial incluído no pacote para instruções de instalação.
  5. Abrir a cena Demo
    • Na janela do projeto Unity, navegue até: Assets > LowPoly Environment Pack > Demo > Demo1
    • Dê um duplo clique em Demo1 para abri-la.

    Para configurar seu ambiente personalizado:
    • Arraste assets como tanques, rochas ou árvores da pasta Assets > ithappy para a cena.
    • Agora você pode mover o jogador livremente dentro do ambiente.
  6. Adicionar prefab relacionados ao jogador
    Navegue até: Assets > StarterAsset > ThirdPersonController > Prefabs
    Arraste os três seguintes prefabs para o painel Hierarchy:
    • MainCamera
    • PlayerFollowCamera
    • PlayerArmature
  7. Definir Parâmetros da Câmera
    • Selecione PlayerFollowCamera na cena,
    • No painel de propriedades (Inspector), localize o componente CinemachineVirtualCamera.
    • Defina Follow e Look At para PlayerCameraRoot (Nota: pode ser encontrado nos componentes filho de PlayerArmature).

A configuração acima usa o script de controlador de terceira pessoa fornecido pelo Unity. Neste ponto, clique no botão Play na barra de ferramentas do Unity, você pode usar as teclas WASD para controlar o movimento do personagem. O personagem e a câmera agora devem se mover e se ajustar de acordo!

Exibindo o Painel de Prompt na Proximidade do Jogador

Quando o jogador se aproxima de um objeto específico, um painel de entrada da UI deve aparecer. Quando o jogador se afasta, o painel deve desaparecer.

  1. Criação da Área de Gatilho
    • No diretório Assets > ithappy > Military FREE > Perfab, selecione um modelo (por exemplo, um tanque).
    • Clique com o botão direito no modelo e escolha Create Empty Child, em seguida, renomeie-o para Trigger.
    • Selecione o objeto Trigger, vá para o Inspector, clique em Add Component e adicione um Box Collider.
    • Marque a opção Is Trigger.
    • Clique em Edit Collider e ajuste seus manipuladores na visualização Scene para escalar o collider para o dobro do tamanho do modelo, cobrindo sua área circundante.
  2. Criar o Script de Evento de Gatilho
    • No painel Project, clique com o botão direito na pasta Assets > Create > C# Script, nomeie-o Transponder e abra o script com o Cursor.
    • Este script deve detectar quando um jogador entra ou sai do collider, uma mensagem é enviada ao nosso componente GameLogic. Selecione o modelo no Cursor e insira nosso prompt de referência:

    Por favor, gere um script Unity C# chamado Transponder que aciona OnPlayerEnter quando um GameObject com a tag "player" entra no collider, e OnPlayerExit quando o jogador sai.
    • Salve o script e arraste o componente Transponder para o objeto Trigger na cena.
  3. Gerenciamento da Lógica do Jogo
    Clique com o botão direito na cena > Create Empty, renomeie-o para GameLogicManager (Serve como o contêiner de lógica).
    • Sob GameLogicManager, crie outro filho vazio e nomeie-o GameManager.
    • Crie um novo script chamado GameManager, que lidará com a lógica central para a cena.

    Nós citamos o componente Transponder e então escutamos os eventos quando os jogadores entram ou saem. As palavras do prompt de referência são as seguintes:
    Por favor, gere um script Unity C# chamado GameManager que escuta.
    • Eventos OnPlayerEnter e OnPlayerExit de uma instância de Transponder.
    • Em OnPlayerEnter, instancie um prefab de prompt de UI usando o script UIFactory.
    • Em OnPlayerExit, destrua este prefab de UI.

    Após salvar o script, arraste o script GameManager para o objeto GameManager e arraste o componente Transponder para o campo Transponder. Isso completa a escuta dos eventos de entrada e saída do jogador.
  4. Criar Prefab do Painel de UI
    Na Hierarchy, clique com o botão direito > UI > Panel, para criar um novo painel.
    • Adicione 2 componentes filhos sob o painel:
      • Text (para exibir as Instruções do prompt)
      • InputField (para receber a entrada do jogador)
    • Ajuste o layout e o posicionamento usando a visualização Game como prévia.
    • Uma vez terminado, arraste o objeto Panel inteiro para a pasta Assets para criar um prefab.
      • Nomeie-o InputDialogPrefab.

    Nota: Se você estiver usando TextMeshPro, certifique-se de atribuir uma fonte compatível com chinês, como NotoSansSC SDF, para evitar caracteres em forma de quadrado no texto.
  5. Criar o Script InputDialog: Gerenciar Lógica de Entrada
    • Crie um script Unity C# chamado InputDialog.

    Prompt de Referência:
    • Por favor, gere um Script Unity C# chamado InputDialog para gerenciar uma caixa de diálogo de UI baseada em TMP.
    • Ele deve conter um TMP_Text para o prompt e um TMP-InputField para a entrada.
    • No primeiro pressionamento da tecla Enter: ative a caixa de entrada e desative o controlador de movimento do jogador (por exemplo, ThirdPersonController).
    • No segundo pressionamento da tecla Enter: envie a entrada, reative o movimento e destrua a caixa de diálogo.
    • Mantenha o foco da entrada até que uma entrada válida seja inserida.

    Monte o componente InputDialog no InputDialogPrefab. Arraste os objetos Text e InputField correspondentes para seus respectivos campos no componente (Dependencies).
  6. Criar o script UIFactory: Instanciar painel de UI
    Crie um novo script C# chamado UIFactory
    Prompt de Referência:
    • Por favor, gere um Script Unity C# chamado UIFactory que segue o padrão factory para instanciar caixas de diálogo de UI.
    • Dado um prefab de UI, uma posição e uma rotação, instancie o prefab na transformação fornecida e retorne seu componente InputDialog.

    Este componente atua como um intermediário para desacoplar a lógica de criação da UI do tratamento de eventos do jogo.
  7. Dependências de Componentes Associados
    Verifique se todas as dependências dos componentes estão corretamente atribuídas.
    • O objeto PlayerArmature na cena deve ter a Tag definida como "Player".

    No objeto GameManager, atribua:
    • O campo Transponder com o script Transponder do objeto Trigger.
    • O campo UIFactory com o componente UIFactory no objeto GameLogicManager.

    Teste: Clique em Play no Unity.
    • Aproxime-se do objeto com o gatilho - o painel de entrada deve aparecer.
    • Quando você se afastar, o painel deve desaparecer automaticamente.

    Nota: Nosso arquivo-fonte tem uma posição fixa para onde o painel é gerado. Modifique este valor de acordo com as propriedades Transform do Trigger que você selecionou. Alternativamente, você pode definir o Canvas > RenderMode do prefab de UI para ScreenSpace - Overlay, para que a UI seja renderizada em dados de espaço de tela e não entre no espaço do mundo.

Enviar o prompt para a TripoAPI

Nesta fase, ainda não somos capazes de enviar prompts para o servidor Tripo em tempo real. No entanto, o código necessário para envio de prompt, requisições de rede, geração de modelo, rigging de esqueleto, mapeamento, adaptador e retargeting de animação está pronto. Esses scripts serão totalmente integrados ao plugin Tripo for Unity em futuras atualizações. (Nota: Certifique-se de que um sistema UIEvent exista em sua cena antes de prosseguir; caso contrário, a UI não responderá!)

  1. Importar Script do Plugin Tripo
    No painel Project do Unity (geralmente à esquerda), localize os arquivos-fonte TripoClient.cs, TripoAPI.cs e RuntimeHumanoidAvatarBuilder.cs de sua pasta de download.
    • Arraste-os para a pasta Assets/Scripts.

    Aqui está o que cada script faz:
    • TripoClient.cs e TripoAPI.cs o envio de prompt e a comunicação de rede com o servidor Tripo.
    • RuntimeHumanoidAvatarBuilder.cs o esqueleto do modelo para o rig humanoide do Unity usando o plugin GLTFast.

    TripoClient.cs e TripoAPI.cs representam versões lite do plugin Tripo For Unity, mas com funcionalidade de rigging. Continuaremos a atualizar e otimizar este processo em futuras versões.
  2. Criar componente Tripo Client
    • Crie um componente vazio filho sob GameLogicManager e nomeie-o TripoClient.
    • Arraste TripoClient.cs e TripoAPI.cs para este novo objeto para anexar os scripts.
    • No Inspector, localize o campo API Key no componente TripoClient. Cole sua chave de API Tripo (você pode registrar uma conta no site oficial da Tripo e receber 600 pontos gratuitos mensalmente).
  3. Lógica de Entrada de Prompt e Callback
    Como atualizamos o sistema de entrada do jogador, precisamos atualizar a lógica de transmissão do prompt no GameManager. Por padrão, o script GameManager já deve estar escutando os eventos OnPlayerEnter e OnPlayerExit. Se você estiver trabalhando com código gerado por IA ou encadeando lógica entre vários componentes, é útil colar o código gerado anteriormente como contexto.
    O script que fornecemos já definiu a função de callback quando o GameManager emite uma chamada de instância para o UIFactory. Definitivamente, existem outras soluções, mas neste caso, o prompt que pode ser usado para completar esta parte da lógica pode ser visto como o seguinte.
    Comportamento Atualizado: No script GameManager
    • Quando OnPlayerEnter é acionado, o UIFactory instancia uma caixa de diálogo de entrada (prefab InputDialog).
    • Quando OnPlayerExit é acionado, a caixa de diálogo de entrada é destruída.

    Assim que o jogador terminar de inserir um prompt, ele será passado para o script TripoClient, com um exemplo de chamada de tripoClient.TextToModel(prompt, pos);. Modifique os scripts associados.
    Modificar GameManager.cs:
    • Abra o script GameManager.cs.
    • Encontre o método OnPromptConfirmed (este lida com a confirmação de entrada do prompt).
    • Complete o código interno e certifique-se de que o campo tripoClient esteja corretamente atribuído no componente GameManager.
  4. Criar um Contêiner de Modelo
    • Na hierarquia da cena, crie um componente vazio filho e nomeie-o ModelContainer
    • Use-o como nó pai para todos os modelos gerados dinamicamente.

    Teste sua Configuração
    1. Pressione o botão Play no Unity.
    2. Insira um prompt no painel.
    3. Você deverá ver o prompt carregado com sucesso para o servidor Tripo.
    4. O progresso da geração aparecerá no Console do Unity e também no campo "Input/Progress" do Componente Tripo API.

    Agora você está pronto para gerar seu próprio modelo de IA no Unity. Divirta-se construindo!

Retargeting de Animação

Uma vez que o modelo tenha sido gerado, o próximo passo é mapear os recursos de animação existentes para o esqueleto do seu modelo. Certifique-se de que o script RuntimeHumanoidAvatarBuilder foi adicionado ao seu projeto. Este script lida com o mapeamento do esqueleto GLB humanoide para o Avatar do Unity, e o script TripoClient o montará automaticamente no modelo gerado.

Vamos primeiro organizar a

Compartilhar o artigo

Gere qualquer coisa em 3D

Clique abaixo para se juntar a milhões de criadores 3D. Experimente a geração de modelos de altíssima fidelidade e texturas PBR de primeira linha.