✨ Vibecode 101 | 3D VR AR XR ✨
Trilha 101 | Aprenda Programar | Tito Petri
Trilha 101 | Aprenda Programar | Tito Petri
Acervo com mais de 100 treinamentos e tutoriais completos, com instruções passo a passo para aprender, praticar e evoluir no desenvolvimento de projetos.
Mais de 150 projetos para criar, visualizar e explorar, com possibilidade de interação, download dos projetos finalizados e acesso aos códigos-fonte.
Jogo para se divertir e aprender ainda mais. Atraves de um Advenure /Plataforma RPG o aluno deve resolver o enigma e sair da ilha , onde via conhecer tudo sobre tecnologia desing e ecologia. Experiencie do computador. Funciona com Joystick!
Prepare-se para o vibecode em 2027 3d vr ar xr todas essasa apolicacoes agora podem ser ciradas sem codigo, usando apenas os prompts ea s novas ias. preparem-se para o futuro dos aplicativos interativos nas redes sociais oculos vr e smartglasses.
Nova geração de VR da Meta — Novos dispositivos e experiências impulsionando a evolução da realidade virtual e computação espacial.
Apple Vision Pro — AR, VR, XR, 3D e computação espacial avançam com o Vision Pro e a evolução dos chips Apple.
Ray-Ban e Smart Glasses — Óculos inteligentes incorporam câmeras, IA e novas formas de interação diretamente no campo de visão.
Snapchat Spectacles — Óculos voltados à realidade aumentada aproximam cada vez mais o mundo físico do conteúdo digital.
Nova geração dos Tamagotchis — Companheiros virtuais ganham IA, personalidade e interação contínua, reinventando o conceito dos antigos Tamagotchis. (Veja MetaAI Muse e Open AI Dots).
Este tutorial apresenta fundamentos de Informática, Computação Gráfica, Arquitetura de Computadores, Sistemas Operacionais e linguagens de desenvolvimento.
Esses conceitos ajudam a criar prompts mais precisos para gerar games, experiências 3D, AR, VR e XR, entendendo melhor como cada tecnologia funciona.
Aprenda a gerar imagens e renders 3D com IA usando ChatGPT, Google Gemini, Meta AI e Bing. Esse conhecimento ajuda a criar referências visuais, personagens, cenários e objetos para seus projetos, além de escrever prompts mais eficientes para desenvolver games e experiências 3D, AR, VR e XR.
Explore a Visão Artificial criando projetos com VibeCode: Animojis, leitores de QR Code e experiências de Realidade Aumentada com AR Maker. Use a IA para gerar prompts que integrem reconhecimento facial, detecção de objetos e interações em tempo real. Transforme conceitos de computação visual em aplicações interativas!
Aprenda a usar IA para remover objetos, trabalhar com camadas, atalhos e otimizar imagens no Photoshop. Esses conhecimentos ajudam a preparar e editar texturas, personagens, cenários e elementos visuais para games e experiências 3D, além de criar prompts mais claros para orientar a IA no desenvolvimento.
Aprenda lógica de programação com Scratch e conheça Java, C#, Swift e Python, linguagens usadas em apps e games. Aula conceitual explica os fundamentos da Lógica de Programação e primeiro contato com códigos.
Todo conhecimento de algoritmos, lógica e programação é importante para o VibeCode e para a criação de prompts.
Aprenda Blender 3D do Zero ao Avançado!
Trilha Completa de Aulas no AprendaProgramar!
Aprenda a criar personagens 3D com Blender, explorando escultura, modelagem, rigging e animação. Esses fundamentos são importantes para o VibeCode, pois permitem compreender como preparar personagens, criar movimentos e integrar modelos 3D em games, metaversos e experiências interativas com IA.
Aprenda os 100 primeiros e principais comandos, atalhos e as ferramentas essenciais para começar na animação 3D e criação de games. Vídeoaula prática para iniciantes e profissionais ganharem fluência no 3D.
Aprenda o processo completo de criação de um personagem 3D no Blender, da modelagem ao rigging e animação.
Esse conhecimento ajuda a compreender como personagens são construídos e preparados para games, sendo importante para descrever personagens, animações e comportamentos em prompts para projetos 3D, AR, VR e XR.
Explore a galeria 3D do Aprenda Programar, do professor Tito Petri, no Sketchfab! Descubra modelos 3D criados em aulas de Blender, personagens, objetos e projetos para estudar, baixar e utilizar em games, animações e experiências digitais.
Faça aqui o Download do Modelo 3D do Felpudo para examinar e estudar. Você pode baixar o modelo 3d do sketchfab em diversos extensoes/formatos de arquivos 3D (como .fbx .blend .usdz .glb).
Até aqui você já deve saber modelar um personagem/NPC para estudo.
Ou pode fazer o download do modelo 3D do personagem que usaremos nos projetos 3D e XR.
Examine o modelo no Blender e use de referência para criar seu próprio personagem 3D.
Aprenda a usar o Sketchfab para buscar, visualizar e publicar modelos 3D, além de trabalhar com diferentes formatos.
Esse conhecimento facilita encontrar referências e assets para seus projetos e entender formatos 3D ao criar prompts para incorporar modelos em games, AR, VR e XR.
Blender e Python aproximam criação 3D e programação, permitindo automatizar tarefas, manipular objetos e criar ferramentas.
Esse conhecimento é importante para entender scripts, lógica e processos que podem ser descritos em prompts para gerar e transformar conteúdos 3D em projetos de games, AR, VR e XR.
Aprenda como usar IA para criar e debugar scripts Python no Blender e até conectar agentes de IA dentro da cena.
O mais importante é dominar os fundamentos de programação em Python e conhecer Add-ons e plugins do Blender para ampliar as possibilidades de criação e automação.
Curso Completo | Vibecode para Blender-Python Scripts
Aprenda criar seu primeiro script Blender-Python usando VibeCoding. O curso mostra como transformar instruções em código para automatizar tarefas e manipular cenas 3D.
Os fundamentos de Python e lógica são essenciais para escrever prompts melhores e entender, corrigir e evoluir scripts gerados por IA.
ADICIONA MENU AO SIDEBAR - ( TECLA N -NA VIEWPORT 3D )
...
Crie um Blender Python Script - adicione menu de ferramentas ao menu lateral N da viewport
LABEL TITULO NOME DO TOOLSET - "Felpudo NPC Tools"
BOTAO RESET SCENE OBJECT NAMES - renomeia todos objetos da cena como felpudo.001 em diante - nome unico - com dialogbox de confirmação
BOTAO RESET SCENE MATERIALS - apaga todos os materias da cena e remove todos os materiais de todos os objetos da cena - use box de confirmação
...
EXECUTE O SCRIPT PYTHON NO BLENDER E VEJA O RESULTADO:
NO FINAL DO PROCESSO, PEDI PRO CHAT GPT CONVERTER MEU SCRIPT PY EM UM PROMPT TÉCNICO E CONCISO
(PARA RECRIAR O SCRIPT NOVAMENTE) O RESULTADO FOI O PROMPT ABAIXO:
Crie um addon completo em Python para Blender chamado Felpudo NPC Tools, destinado ao painel N (Sidebar) do 3D Viewport, na categoria Felpudo.
IMPORTANTE: gere o script Python completo, pronto para colar e executar no Blender. Não entregue trechos, pseudocódigo ou explicações. Preserve exatamente todas as funcionalidades descritas abaixo e não altere, remova ou simplifique nenhuma funcionalidade.
Criar uma seção Rename Objects com:
Campo de texto Prefix, valor padrão felpudo.
Campo de texto Object Name.
Botão OK.
Checkbox Hide objects after rename.
O botão OK deve renomear os objetos selecionados usando:
PREFIX_NOMEOBJETO
Quando houver vários objetos selecionados, adicionar numeração .001, .002, .003 etc., garantindo nomes únicos.
Usar nomes temporários durante renomeações em lote para evitar conflitos de nomes entre objetos.
Criar botões:
_OLHO
_SOBRANCELHA
_PALP. UP
_PALP. DOWN
_ESQ
_DIR
Os botões devem adicionar respectivamente:
_OLHO
_SOBRANCELHA
_PALPEBRA_CIMA
_PALPEBRA_BAIXO
_ESQ
_DIR
O sufixo só deve ser acrescentado se o objeto ainda não terminar com ele.
O checkbox Hide objects after rename também deve funcionar nos botões de sufixo.
Adicionar o botão REMOVE DIGITS.
Ele deve remover todos os caracteres numéricos 0–9 dos nomes dos objetos selecionados.
O checkbox Hide objects after rename também deve funcionar nessa operação.
Adicionar o botão RENAME MESHES.
Para cada objeto selecionado que possua dados de mesh, renomear o datablock da mesh (obj.data.name) para o mesmo nome do objeto.
Adicionar o botão RENAME MATERIALS.
Para cada objeto selecionado, renomear os materiais atribuídos a ele usando o nome do objeto.
Logo abaixo de RENAME MATERIALS, adicionar o botão:
SET VIEWPORT COLORS
Esse botão deve ser uma ação manual.
Para os objetos selecionados, pegar a cor Base Color do shader Principled BSDF de seus materiais e copiar essa cor para material.diffuse_color, permitindo que a cor do material seja utilizada também como Viewport Color.
Essa operação NÃO deve ser automática.
Adicionar o botão:
SHOW HIDDEN OBJECTS
Ele deve funcionar exatamente como o comando Alt+H do Blender, mostrando novamente todos os objetos ocultos através de:
for obj in bpy.context.scene.objects:
obj.hide_set(False)
O checkbox Hide objects after rename deve executar somente o equivalente ao comando H do Blender.
Portanto, ao esconder objetos, usar exclusivamente:
obj.hide_set(True)
NÃO usar:
obj.hide_viewport = True
O comportamento deve ser equivalente ao H do Blender, permitindo que o Alt+H / SHOW HIDDEN OBJECTS revele os objetos novamente.
Não misturar hide_set() com hide_viewport nessa funcionalidade.
Criar uma seção Animation Sets com os seguintes botões:
Entrada → frames 0–30
Idle → frames 31–90
Walk → frames 91–110
Run → frames 110–120
Backflip → frames 121–150
Ao clicar em um botão:
Definir scene.frame_start.
Definir scene.frame_end.
Ir para o frame inicial.
Reproduzir a animação.
Criar uma seção Scene Reset.
Criar o botão:
RESET SCENE OBJECT NAMES
Ao clicar:
Exibir confirmação antes de executar.
Renomear todos os objetos da cena para:
felpudo.001
felpudo.002
felpudo.003
etc.
Garantir nomes únicos.
Aplicar a todos os objetos da cena, não apenas aos selecionados.
Criar o botão:
RESET SCENE MATERIALS
Ao clicar:
Exibir confirmação.
Remover todos os materiais dos slots dos objetos.
Remover os datablocks de materiais da cena.
Criar uma seção Color Palette com um slider inteiro de 0–23.
O slider deve aplicar automaticamente a paleta ao ser alterado.
Não criar botão Apply.
A alteração do slider deve imediatamente executar a aplicação das cores.
Aplicar a cor aos objetos cujo nome contenha:
CORPO
ASA
PALPEBRA
Usar os materiais desses objetos.
Aplicar a cor selecionada da paleta ao Base Color do Principled BSDF.
Definir:
Roughness = 0.42
Gerar uma versão mais escura da cor do corpo.
Definir:
Roughness = 0.25
Gerar uma versão ainda mais escura da cor do corpo.
Não alterar a roughness da pálpebra.
Para gerar as cores relacionadas, utilizar HSV, dobrando a saturação e reduzindo o valor de brilho conforme os parâmetros abaixo:
def felpudo_related_color(body_color, darkness):
r = body_color[0]
g = body_color[1]
b = body_color[2]
h, s, v = colorsys.rgb_to_hsv(r, g, b)
s = min(1.0, s * 2.0)
v = v * (1.0 - darkness)
v = max(0.0, min(1.0, v))
r, g, b = colorsys.hsv_to_rgb(h, s, v)
return (r, g, b, 1.0)
Para as cores não especiais:
wing_color = felpudo_related_color(body_color, 0.825)
eyelid_color = felpudo_related_color(body_color, 0.75)
A cor 0 deve preservar exatamente estas cores:
Body:
#529219FF
Wing:
#376A0DFF
Eyelid:
#2C5040FF
Não recalcular essas três cores através da função HSV.
Usar exatamente esta lista:
FELPUDO_COLOR_PALETTE = [
(0x52 / 255, 0x92 / 255, 0x19 / 255, 1.0), # 00 original green
(0xE8 / 255, 0x1B / 255, 0x23 / 255, 1.0), # 01 red
(0xFF / 255, 0xD9 / 255, 0x00 / 255, 1.0), # 02 yellow
(0x20 / 255, 0x78 / 255, 0xE8 / 255, 1.0), # 03 blue
(0x08 / 255, 0x08 / 255, 0x0A / 255, 1.0), # 04 black
(0xA9 / 255, 0x16 / 255, 0x1C / 255, 1.0), # 05 dark red
(0xFF / 255, 0xFF / 255, 0xF5 / 255, 1.0), # 06 white
(0x3C / 255, 0xC6 / 255, 0x39 / 255, 1.0), # 07 green
(0x00 / 255, 0xD4 / 255, 0xC7 / 255, 1.0), # 08 turquoise
(0xFF / 255, 0x76 / 255, 0x00 / 255, 1.0), # 09 orange
(0xFF / 255, 0x3B / 255, 0x91 / 255, 1.0), # 10 pink
(0x8B / 255, 0x32 / 255, 0xD6 / 255, 1.0), # 11 purple
(0x00 / 255, 0x66 / 255, 0xD9 / 255, 1.0), # 12 strong blue
(0x6E / 255, 0xC9 / 255, 0x24 / 255, 1.0), # 13 pig green
(0x39 / 255, 0x8A / 255, 0x20 / 255, 1.0), # 14 dark green
(0xFF / 255, 0x4D / 255, 0x00 / 255, 1.0), # 15 strong orange
(0xFF / 255, 0xB8 / 255, 0x00 / 255, 1.0), # 16 gold yellow
(0x3D / 255, 0xB9 / 255, 0xFF / 255, 1.0), # 17 light blue
(0x00 / 255, 0xE5 / 255, 0xFF / 255, 1.0), # 18 cyan
(0xE8 / 255, 0x00 / 255, 0xA8 / 255, 1.0), # 19 magenta
(0xA8 / 255, 0x00 / 255, 0xFF / 255, 1.0), # 20 vibrant purple
(0xFF / 255, 0x28 / 255, 0x28 / 255, 1.0), # 21 vivid red
(0xA8 / 255, 0xE6 / 255, 0x00 / 255, 1.0), # 22 lime
(0xFF / 255, 0xC4 / 255, 0x00 / 255, 1.0), # 23 orange-yellow
]
Criar uma seção Eye Texture com um slider inteiro de 0–4.
A textura deve ser aplicada automaticamente quando o slider mudar.
Não criar botão APPLY EYE TEXTURE.
As imagens estão na mesma pasta do arquivo .blend.
Usar exatamente estes arquivos:
EYE_TEXTURES = [
"mapaOlhoVerde.jpg",
"mapaOlhoAzul.jpg",
"mapaOlhoAmarelo.jpg",
"mapaOlhoVermelho.jpg",
"mapaOlhoMarrom.jpg",
]
Ao alterar o slider:
Localizar a pasta do arquivo .blend.
Localizar a imagem correspondente.
Carregar a imagem.
Aplicá-la ao Base Color do Principled BSDF.
Aplicar somente aos objetos cujo nome contenha OLHO ou EYE.
Se a imagem não existir, simplesmente não executar a aplicação e não interromper o addon.
O slider deve possuir uma callback update que execute automaticamente a aplicação da textura.
Usar:
import bpy
import os
import colorsys
Criar funções auxiliares para:
localizar o Principled BSDF;
definir Base Color;
copiar Base Color para Viewport Color;
calcular cores relacionadas;
renomear objetos evitando conflitos;
esconder objetos usando exclusivamente hide_set(True);
mostrar objetos usando hide_set(False);
aplicar a paleta;
aplicar textura dos olhos.
Criar operadores Blender separados para cada função.
Criar propriedades da cena:
felpudo_prefix
felpudo_object_name
felpudo_hide_after_rename
felpudo_color_index
felpudo_eye_texture_index
Tanto felpudo_color_index quanto felpudo_eye_texture_index devem possuir callbacks update para aplicação automática.
Criar um painel com:
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
E categoria:
bl_category = "Felpudo"
Nome do painel:
Felpudo NPC Tools
Registrar e desregistrar corretamente todos os operadores, propriedades e classes.
Usar confirmação para as duas operações de RESET.
O resultado final deve ser um único script Python completo, autocontido e funcional, pronto para ser executado no Blender.
NÃO modificar nenhuma funcionalidade especificada acima.
NÃO adicionar funcionalidades extras.
NÃO remover funcionalidades.
NÃO substituir o comportamento do hide_set(True) por hide_viewport.
O comportamento do Hide objects after rename deve ser exatamente equivalente ao comando H, e SHOW HIDDEN OBJECTS deve ser equivalente ao Alt+H.
Explore a geração de modelos 3D com IA usando Meshy AI e Tripo 3D. Transforme textos e imagens em objetos tridimensionais para jogos, animações, metaversos e experiências de AR/VR. Experimente diferentes prompts e leve seus modelos para projetos desenvolvidos com VibeCode.
Crie avatares 3D com IA e explore o formato USDZ para visualizar seus modelos no iPhone e iPad usando o AR Quick Look. Experimente importar personagens, ajustar materiais e posicionar avatares no ambiente real com Realidade Aumentada. Use o VibeCode para prototipar novas experiências interativas.
Explore a computação sem tela usando Hand Tracking, MediaPipe e WebGL. Crie experiências em que gestos das mãos controlam objetos e cenas 3D sem mouse ou teclado. Use o VibeCode para prototipar interfaces naturais, explorar reconhecimento de gestos e experimentar novas formas de interação com ambientes virtuais.
Aprender modelagem Low Poly, loops, deformações e rigging de personagens no Blender é importante para o VibeCode 3D. Esses conhecimentos ajudam a implementar, refinar e controlar personagens em projetos interativos. Assista à aula, pratique e desenvolva suas habilidades em modelagem e animação 3D.
Aprenda a criar personagens 3D com Blender, explorando escultura, modelagem, rigging e animação. Esses fundamentos são importantes para o VibeCode, pois permitem compreender como preparar personagens, criar movimentos e integrar modelos 3D em games, metaversos e experiências interativas com IA.
Aprenda a criar personagens 3D com Blender, explorando escultura, modelagem, rigging e animação. Esses fundamentos são importantes para o VibeCode, pois permitem compreender como preparar personagens, criar movimentos e integrar modelos 3D em games, metaversos e experiências interativas com IA.
Aprenda a usar o Pocket da Meta AI para criar Gizmos, pequenas experiências interativas geradas com IA.
O tutorial mostra como transformar ideias em protótipos funcionais usando prompts, ajudando a desenvolver experiências criativas, jogos e aplicações interativas com VibeCoding.
Dowload do Pocket - Crie Gizmos | iOS e Android
Download | AppStore - iOS iPhone iPad - https://apps.apple.com/br/app/pocket-crie-gizmos/id6761221765
Download | Android - Google PlayStore - https://play.google.com/store/apps/details?id=com.facebook.gizmo&hl=pt_BR
Crie seu primeiro game VibeCoded, o Flappy-Capivara, usando Meta AI, GPT, Gemini e Claude.
O tutorial mostra na prática como transformar uma ideia em um game usando prompts e diferentes agentes de IA, ajudando a desenvolver lógica e estratégias para criação de games com código gerado por IA.
Crie seus primeiros Gizmos (miniaplicativos) com VibeCode usando o Pocket da Meta AI. Experimente pedir para criar um Microsoft Paint. Dica: descreva as funcionalidades desejadas, peça ao ChatGPT para transformá-las em um prompt e use a Meta AI para aprimorá-lo antes de enviar ao Pocket.
Crie seus primeiros Gizmos (miniaplicativos) com VibeCode usando o Pocket da Meta AI. Experimente pedir para criar um Microsoft Paint. Dica: descreva as funcionalidades desejadas, peça ao ChatGPT para transformá-las em um prompt e use a Meta AI para aprimorá-lo antes de enviar ao Pocket.
Aprenda os fundamentos do WebGL aplicados à criação de games 2D para a web. Esse conhecimento ajuda a entender como jogos funcionam no navegador, facilitando a criação de prompts para gerar mecânicas, interfaces, animações e código de games com IA.
Crie um jogo de aventura e plataforma 3D para explorar os conceitos de metaverso com VibeCode. Peça à IA para gerar cenários, personagens, obstáculos, moedas, física de movimento, câmera em terceira pessoa e controles interativos. Comece com uma fase simples e evolua seu mundo virtual com novos desafios!
Crie um Gizmo com VibeCode para visualizar modelos e cenas 3D diretamente no navegador usando WebGL. Peça à Meta AI para gerar um viewport 3D com controles de órbita, zoom, iluminação e carregamento de modelos. Use o ChatGPT para estruturar o prompt com as funcionalidades desejadas.
Exemplo prático travado
PROMPT TRAVADO:
Crie APENAS um cubo vermelho #FF0000 girando no centro da tela.
Canvas ocupa 100% da tela.
Uma única luz direcional branca.
Fundo preto sólido.
REGRAS ABSOLUTAS: PROIBIDO adicionar OrbitControls, PROIBIDO adicionar qualquer elemento HTML, texto, botão ou painel. PROIBIDO adicionar chão, grid ou segundo objeto. Entregue SOMENTE o cubo.
Se você me mandar assim, eu não vou colocar nem o controle de arrastar o mouse.
DICA PARA GERAÇÃO DE APLICAÇÕES
Para travar e fazer eu gerar SÓ o que você escreveu, use o modo "lista fechada". É o oposto do prompt criativo.
Use essa estrutura:
Template anti-invenção
CRIE APENAS ISTO - NADA A MAIS:
[seu objeto principal aqui]
REGRAS ABSOLUTAS:
1. PROIBIDO adicionar UI, HUD, botões, painéis, textos, legendas, gradientes, ícones
2. PROIBIDO adicionar luzes, objetos, chão ou efeitos que não estão na lista acima
3. PROIBIDO inferir features - se não está escrito, não existe
4. O código deve conter SOMENTE o necessário para renderizar o item descrito
5. Fundo: [defina - ex: #000000 liso]
Se precisar de algo que não está listado, NÃO crie, deixe vazio.
Por que funciona
Eu sou treinado para ser "útil" e completar. Quando você diz "um carro", eu penso "vou colocar um painel de cor, um chão bonito, um botão de reset". Para bloquear isso, você tem que usar linguagem de negação forte.
3 truques que travam de verdade:
1. Use "APENAS" e "SOMENTE" no início
Ruim: "Crie um cubo 3D"
Bom: "Crie APENAS um cubo 3D. SOMENTE o cubo."
2. Liste o que é PROIBIDO explicitamente
"PROIBIDO: OrbitControls extras, grid helper, stats, dat.GUI, botões HTML, CSS adicional"
3. Defina o que é o vazio
Se você não disser o que fazer com o resto, eu invento.
"Todo o resto da tela deve ser vazio. Sem UI overlay. Sem HTML fora do canvas."
Experimente criar um Gizmo que gere o clássico Utah Teapot em 3D, como no 3ds Max. Use o VibeCode para explorar algoritmos de geometria 3D e treinar diferentes estilos de UI, como o Swift. Peça à IA para combinar a visualização interativa com uma interface moderna.
A estrutura que mais funciona pra IA gerar uma aplicação WebGL/3D boa tem 6 blocos.
Se você mandar assim, eela já cria direto com `Three.js` + React. Veja a fórmula que eu uso:
Copie e preencha:
1. O QUE É: [tipo de app + objetivo em 1 frase]
2. STACK: [Three.js / R3F / Babylon - se não souber, eu uso Three.js]
3. CENA: [o que tem na cena, estilo visual, referências]
4. INTERAÇÃO: [como o usuário mexe - orbit, drag, click, WASD, VR?]
5. LÓGICA: [o que precisa acontecer - física, dados, animação]
6. VISUAL / UI: [cores, HUD, responsivo, performance]
```
Detalhando cada bloco
1. O QUE É
Não diga só "um jogo 3D". Diga o loop.
Ex: "um visualizador de tênis 3D que gira 360° para e-commerce" é 10x melhor que "site 3D de tênis"
2. STACK
Se você não definir, meu padrão é:
- Three.js com React Three Fiber (R3F) - melhor custo/benefício
- `drei` para controles prontos
- `gsap` para animações suaves
Se precisar de física pesada, fale: `rapier` ou `cannon-es`. Se precisar de shaders, fale: `GLSL custom`.
3. CENA
Me diga 3 coisas:
- Objetos: o que tem? Ex: 1 tênis, 2 luzes, chão infinito
- Estilo: realista PBR? low-poly? cyberpunk? voxel?
- Iluminação: studio? HDR? noite com neon?
4. INTERAÇÃO
- Câmera: `OrbitControls`, primeira pessoa, fixa?
- Input: mouse drag, scroll para zoom, clique para trocar material, WASD?
- Mobile: tem que funcionar no toque?
5. LÓGICA
É aqui que a maioria esquece. Ex:
- "ao clicar no tênis, troca a cor"
- "carregar modelo .glb de URL"
- "física de gravidade nos cubos"
6. VISUAL / UI
- Cores, tipografia, tem painel HTML por cima?
- Precisa ser leve? < 5mb? 60fps obrigatório?
Exemplo de prompt perfeito (pronto pra colar)
Crie uma aplicação WebGL 3D de um showroom de carros.
Cena: 1 carro esportivo low-poly no centro, chão reflexivo, fundo estúdio escuro com HDR, 2 spotlights.
Interação: OrbitControls com damping, scroll para zoom limitado, clique no carro troca a cor (vermelho, preto, prata).
Lógica: carregar modelo GLB, rotação automática lenta quando parado.
UI: painel minimalista no canto inferior com 3 bolinhas de cor, título em branco, totalmente responsivo.
Performance: 60fps, sombras suaves, sem post-processing pesado.
HandTrack permite rastrear as mãos pela câmera para controlar aplicações com gestos. No Vibecode, aprender a configurar o layout, integrar a câmera e usar ferramentas de debug é essencial para desenvolver experiências interativas, identificar erros e testar interfaces gestuais diretamente no navegador.
Crie um web app WebGL single-file em um ÚNICO arquivo HTML com `<style>` e `<script type="module">`, sem build, usando Three.js + MediaPipe Tasks Vision.
**OBJETIVO:** Debug de mãos em fullscreen, pronto para Desktop webcam, iOS Safari e Android Chrome.
**REGRA DE OURO - OBRIGATÓRIA:**
PROIBIDO CRIAR QUALQUER ELEMENTO, ITEM, BOTÃO, MENU, LEGENDA, CARD, MODAL OU UI EXTRA QUE NÃO FOI SOLICITADO ABAIXO. Interface deve ser a mais CLEAN possível, minimalista absoluta. NÃO invente. Entregue EXATAMENTE o que foi pedido e nada mais.
**ESTILO VISUAL OBRIGATÓRIO:**
Interface CLEAN, BRANCA com detalhes em AZUL CLARO #E0F2FF ou VERDE CLARO #E0F7E9. Fundo branco #FFFFFF ou #F8FBFF. NADA de dark mode, nada de tema premium escuro. Visual limpo, tech minimalista, light theme.
**STACK OBRIGATÓRIO:**
- importmap: three@0.160.0 + three/addons/ + @mediapipe/tasks-vision@0.10.14
- HandLandmarker de @mediapipe/tasks-vision@0.10.14 com wasm de https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@0.10.14/wasm
- Model asset: https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task
- Config: maxNumHands: 2, minDetectionConfidence: 0.7, minTrackingConfidence: 0.5, modelComplexity: Lite ou Full
- Three.js: WebGLRenderer { alpha: true, antialias: true } + OrthographicCamera cobrindo tela em pixels.
**ESTRUTURA VISUAL - APENAS 2 CAMADAS:**
1. Camada Fundo: `<video id="video">` fullscreen 100vw/100vh, object-fit: cover, position: absolute, playsinline muted autoplay. Grid sutil por cima: overlay CSS com 2 repeating-linear-gradient (32px rgba(0,0,0,0.04) e 8px rgba(0,0,0,0.02)) + fade radial leve.
2. Camada Topo: `<canvas id="canvas">` Three.js transparente, 100% opacity SEMPRE, pointer-events: none, cobrindo tudo, z-index 2.
**RENDER THREE.JS - ESQUELETO - OBRIGATÓRIO:**
- Resize handler atualiza renderer, camera, DPR.
- Para cada mão detectada (max 2), desenhe:
a) CONEXÕES: Use THREE.Line2 + LineMaterial do addon `three/addons/lines/` para espessura real de 3px. Cor #008CFF azul. Use HAND_CONNECTIONS exata: [,,,,,,,,,,,,,,,,,,,,]. worldUnits false, linewidth 3px.
b) JUNTAS: Para CADA um dos 21 landmarks, crie um GROUP com 2 círculos para garantir visibilidade: fundo preto raio 7.8px opacidade 0.9 + frente amarelo #FFD600 raio 6px. Use CircleGeometry + MeshBasicMaterial. Tamanho fixo em pixels via ortho.[0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20]
- Mapeamento: MediaPipe retorna x,y normalizado 0-1. Calcule: x_px = mirrored? (1 - x)*width : x*width, y_px = y*height. Depois para Three: x_three = x_px - width/2, y_three = height/2 - y_px.
**UI PERMITIDA - APENAS ISSO, NADA MAIS:**
1. HUD no canto superior esquerdo: Apenas texto monospace pequeno: `STATUS: PRONTO | TRACKING: X HANDS` + `FPS: XX`. Cor cinza escuro sobre fundo branco semi-transparente.
2. PAINEL no canto superior direito (position: absolute, z-index: 10, background branco 90%, backdrop-blur, borda azul clara, rounded 16px): Apenas 2 switches estilo iOS, nada mais:
- Switch 1 - Label "VÍDEO" - ON: video opacity 1, OFF: opacity 0.1. Canvas Three.js NUNCA muda opacidade.
- Switch 2 - Label "ESPELHAR" - Default ON - Controla mirror X de TUDO junto: ON: video transform scaleX(-1) + skeleton usa (1 - x). OFF: scaleX(1) + skeleton usa x direto. Transição 0.3s ease.
**LÓGICA CRÍTICA:**
- getUserMedia { facingMode: 'user', width: {ideal:1280}, height:{ideal:720} }. Tratar erro com overlay simples branco pedindo permissão + botão retry. Este é o ÚNICO elemento extra permitido além da UI listada.
- Mirror handler atualiza variável isMirrored e aplica no video + no cálculo das coordenadas no mesmo frame.
- Loop: requestAnimationFrame -> handLandmarker.detectForVideo(video, timestamp). Use trava isProcessing para não enfileirar.
- iOS: video playsinline, muted, autoplay obrigatório.
ENTREGUE: Um único arquivo HTML completo, funcional, sem placeholders, sem UI extra.
Crie um aplicativo WebGL single-file chamado **HandTrack Debug - Fullscreen**, utilizando HTML, CSS, JavaScript, Three.js e MediaPipe Tasks Vision, totalmente funcional e responsivo para desktop com webcam, iOS Safari e Android Chrome.
**STACK OBRIGATÓRIA**
- Um único arquivo HTML completo, com CSS e JavaScript em `script type="module"`, sem build.
- Three.js 0.160.0 via importmap, incluindo addons necessários.
- `@mediapipe/tasks-vision@0.10.14`, usando HandLandmarker e WASM via jsDelivr.
- Modelo oficial HandLandmarker `.task`, carregado de uma URL válida e funcional.
- WebGLRenderer com `alpha: true` e `antialias: true`.
- OrthographicCamera para renderização precisa e responsiva em coordenadas de tela.
**INTERFACE E DESIGN**
- Interface fullscreen, minimalista, clean e moderna, com fundo branco e detalhes em azul-claro ou verde-claro.
- Vídeo da webcam ocupando 100vw × 100vh, com `object-fit: cover`, posicionado atrás de um canvas Three.js transparente.
- Canvas sobreposto cobrindo toda a tela, sempre com opacidade 100% e `pointer-events: none`.
- Adicione apenas um grid técnico muito sutil, com linhas finas em baixa opacidade e um leve gradiente radial, sem prejudicar a visualização das mãos.
- No canto superior esquerdo, exiba somente o status do tracking, a quantidade de mãos detectadas e o FPS, com tipografia discreta e legível.
- No canto superior direito, exiba exclusivamente dois switches compactos, estilo iOS, com fundo translúcido discreto: **VÍDEO** e **ESPELHAR**.
- Não crie menus, botões extras, painéis adicionais, legendas, ícones decorativos, controles, elementos gráficos ou qualquer componente de UI que não tenha sido explicitamente solicitado. A interface deve ser o mais limpa possível.
**RASTREAMENTO E VISUALIZAÇÃO DAS MÃOS**
- Detecte até duas mãos simultaneamente, utilizando confiança mínima de detecção e rastreamento de 0.5.
- Desenhe os 21 landmarks de cada mão como círculos amarelos (#FFD600), com raio visual de 6 px e contorno escuro discreto para garantir contraste sobre qualquer imagem.
- Desenhe as conexões do esqueleto em azul (#008CFF), com espessura visual de 3 px, utilizando a lista oficial `HAND_CONNECTIONS` do MediaPipe.
- Utilize `THREE.Line2` e `LineMaterial` para linhas com espessura real em pixels, ou uma implementação equivalente que mantenha a espessura constante em diferentes resoluções.
- Crie os elementos gráficos uma única vez e atualize suas posições a cada frame, sem recriar geometrias desnecessariamente.
- Mapeie corretamente as coordenadas normalizadas dos landmarks para pixels da tela, considerando dimensões, proporção do vídeo, `object-fit: cover` e espelhamento horizontal. O esqueleto deve coincidir visualmente com as mãos reais.
**CONTROLES**
1. **VÍDEO:** ligado por padrão. Ao desligar, reduza a opacidade do vídeo para 0.1; ao ligar, restaure para 1. O canvas e o esqueleto nunca devem perder opacidade.
2. **ESPELHAR:** ligado por padrão. Ao ligar, aplique `transform: scaleX(-1)` ao vídeo e inverta simultaneamente as coordenadas X dos landmarks com `1 - x`. Ao desligar, remova o espelhamento dos dois. A atualização deve ocorrer de forma sincronizada, sem desalinhamento entre vídeo e esqueleto.
**CÂMERA E EXECUÇÃO**
- Solicite acesso à webcam com `navigator.mediaDevices.getUserMedia`, preferindo `facingMode: 'user'`, resolução ideal de 1280 × 720 e compatibilidade com câmeras móveis.
- Configure o vídeo com `autoplay`, `muted` e `playsinline`, garantindo suporte ao iOS Safari.
- Inicialize o MediaPipe com o modelo e os arquivos WASM corretos.
- Utilize `requestAnimationFrame` e `detectForVideo(video, timestamp)`, evitando processamentos simultâneos com uma trava `isProcessing`.
- Atualize landmarks, conexões, FPS e quantidade de mãos detectadas em tempo real.
- Implemente redimensionamento responsivo, atualização do renderer, câmera ortográfica e resolução das linhas.
- Trate permissões negadas, ausência de câmera, falhas de carregamento e erros de inicialização com mensagens claras e um botão **Tentar novamente** somente quando necessário para recuperar a execução.
- Gerencie corretamente a inicialização e a limpeza dos recursos para evitar loops duplicados e vazamentos de memória.
**RESULTADO FINAL**
Entregue o HTML completo, funcional, sem placeholders, com rastreamento de mãos em tempo real e visualização precisa do esqueleto. Priorize desempenho, compatibilidade multiplataforma, sincronização do espelhamento e simplicidade visual. **Não invente funcionalidades nem adicione nenhum elemento de interface que não esteja explicitamente especificado.**
Crie um arquivo único index.html (HTML+CSS+JS em ES Modules, sem build) chamado HandTrack Debug Fullscreen.
Stack: Three.js 0.160.0 via importmap (three + three/addons/ com Line2, LineGeometry, LineMaterial), @mediapipe/tasks-vision@0.10.14 via jsDelivr (FilesetResolver + HandLandmarker), WASM https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@0.10.14/wasm e modelo https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task.
Visual: fullscreen #17191D, video 100vw/vh object-fit:cover, canvas WebGL alpha+antialias transparente sobreposto pointer-events:none, OrthographicCamera(0,width,0,height) para Y top=0. Grid sutil + gradiente radial. Top-left: ESTADO, MÃOS, FPS. Top-right: switches compactos iOS VÍDEO (opacity 1/0.1) e ESPELHAR (scaleX(-1) sincronizado em video+landmarks+cursor). Bottom faixa: DEDOS 0-10, GESTO, CURSOR, PINCH.
Tracking: HandLandmarker numHands:2, confidences 0.5, runningMode VIDEO, detectForVideo com isProcessing lock. Mapeamento cover: calcule scale=max(vw/vv,vh/hv), dispW/H, ox/oy=(vw-dispW)/2, (vh-dispH)/2, normalizedToScreen com mirror: x=vw-x. 21 landmarks.
Render Three: 2 mãos, para cada: 21 círculos amarelos #FFD600 raio 5.2px (6px em [0,1,5,9,13,17]) + contorno escuro #101217 raio 7.2/8px. 23 Line2 separados (não um polyline único), um por conexão oficial [[0,1],[1,2],[2,3],[3,4],[0,5],[5,6],[6,7],[7,8],[0,9],[9,10],[10,11],[11,12],[0,13],[13,14],[14,15],[15,16],[0,17],[17,18],[18,19],[19,20],[5,9],[9,13],[13,17]], cor #008CFF linewidth 3, resolution atualizado no resize. Geometrias criadas uma vez, update por setPositions.
Lógica dedos: conte por relações geométricas, não só Y. Funções isFingerExtended(tip,pip,mcp,wrist) por distância wrist e cos angle, isThumbExtended por distância + palmSize. Total 0-10, histerese com histórico 6 + majority vote.
Musical: Web Audio, 11 notas pentatônica C3 130.81,D3 146.83,E3 164.81,G3 196,A3 220,C4 261.63,D4 293.66,E4 329.63,G4 392,A4 440,C5 523.25, sine+triangle envelope 0.02/0.38s ganho 0.22, toca só em mudança estável, desbloqueia em primeira interação.
Gestos: Punho fechado 0 ext, Mão aberta 5, Apontar só index, Paz index+middle, Polegar cima/baixo (thumb só + y relativo), Pinch por distância normalizada thumb-index/palmSize. Mostra Nenhum gesto se incerto.
Cursor: Cx=(x4+x8)/2, Cy=(y4+y8)/2, smoothing 0.68/0.32, ring 8-10.5px cor #7CFFB2. Pinch com histerese close 0.32 open 0.48, cooldown 320ms, um clique por fechamento, som curto 880->440Hz 0.16s.
Ciclo: requestAnimationFrame, FPS medido, resize atualiza renderer, camera, LineMaterial resolution. Erros: camera negada, file://, WASM/model, WebGL, com mensagem discreta e botão Tentar novamente que para tracks e reboot.
Entregue index.html completo funcional, sem TODOs, sem placeholders.
Crie um único arquivo HTML chamado HandTrack Debug - Fullscreen, single-file, HTML+CSS+JS em <script type="module">, fullscreen, responsivo desktop/iOS Safari/Android Chrome.
STACK: Three.js 0.160.0 via importmap (three + addons), @mediapipe/tasks-vision@0.10.14 via https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@0.10.14/vision_bundle.mjs, modelo https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task, WASM em https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@0.10.14/wasm, WebGLRenderer alpha:true antialias:true, OrthographicCamera (left:0 right:innerWidth top:0 bottom:innerHeight).
DESIGN: bg #1a1a1e, video 100vw/vh object-fit:cover atrás, canvas Three 100% transparente pointer-events:none z-index 2, grid sutil: linhas opacity 0.06 + radial central leve. Top-left STATUS/MÃOS/FPS/CONTAGEM 0-10/GESTO monospace discreto. Top-right apenas 2 switches iOS translúcidos VÍDEO e ESPELHAR. Zero UI extra.
TRACKING: HandLandmarker max 2 mãos, confidences 0.5, VIDEO mode. Botão INICIAR CÂMERA+ÁUDIO obrigatório (iOS precisa gesto), log de erro visível, tratamento de permissão.
RENDER DEBUG: 21 landmarks/mão como círculos amarelos #FFD600 raio 6px + stroke escuro #101012 raio 7.8px (2 Meshes por junta, criados uma vez). Conexões HAND_CONNECTIONS oficiais como SEGMENTOS separados usando LineSegments2 + LineSegmentsGeometry + LineMaterial linewidth 3px cor #008CFF resolução-dependente (não Line2 contínuo). Criar geometrias uma vez, só atualizar posições.
MAPEAMENTO: normalized [0-1] -> pixels tela considerando videoWidth/Height, container aspect, object-fit:cover (scale=max(cW/vW,cH/vH), disp=v*scale, off=(c-disp)/2, x=offX+nx*dispW, y=offY+ny*dispH) e mirror x=>1-x sincronizado com video transform:scaleX(-1).
FEATURES:
1) CONTAGEM 0-10: dedo estendido se tip.y<pip.y, polegar tip.x vs ip.x considerando handedness e mirror (effRight). Soma 2 mãos. Ao mudar: Web Audio sine 180ms, escala C4-F5 (0=C4 261Hz ...10=F5 698Hz) + número grande centralizado fade 800ms.
2) GESTOS: PINCH thumb-index dist<0.04, OPEN_PALM 5, FIST 0, POINT só index, PEACE index+middle, OK pinch+3 dedos estendidos, THUMBS_UP só polegar acima. Exibir no top-left.
3) CURSOR: ponto branco + halo azul #008CFF em meio entre THUMB_TIP 4 e INDEX_TIP 8, segue em pixels. CLICK quando PINCH>150ms, debounce 400ms, som click 800Hz 60ms, pulso visual scale 1.5.
CONTROLES: VÍDEO ON default (OFF opacity 0.1), ESPELHAR ON default (ON video scaleX(-1) + landmarks x=1-x).
PERFORMANCE: getUserMedia facingMode:user ideal 1280x720 audio:false playsinline muted, requestAnimationFrame + detectForVideo(timestamp) com isProcessing lock, resize atualiza renderer/camera/resolution, start/stop limpo sem loops duplicados.
Aprenda a criar games e experiências 3D interativas com WebGL diretamente no navegador.
Esse conhecimento ajuda a compreender cenas, objetos, câmera, interação e lógica em ambientes 3D, tornando mais fácil criar prompts para desenvolver games e experiências interativas com IA.
Explore a computação sem teclado e mouse usando Hand Tracking e avatares com IA. Experimente criar interfaces controladas por gestos, permitindo interagir com personagens virtuais, comandos e objetos 3D. Use o VibeCode para prototipar experiências que combinam reconhecimento de mãos, inteligência artificial e interação natural.
Aprenda a criar interfaces de usuário (UI) usando VibeCoding. Esse conhecimento ajuda a planejar menus, botões, telas, HUDs e controles para games e experiências interativas, além de melhorar a criação de prompts ao descrever visualmente e funcionalmente cada elemento da interface.
crie uma arte layout
adicione algumas UIs sobre esta tela / use estilo ui ios 6/7 - iphone 3 4 5...
- imagem logotipo - top left align - 15% do tamanho do palco (alterne com transicao entre 3 logotipos aprendaprogramar escoladovideogame e metaversosteam)
- grid de cores - paleta com 12 cores primarias - top right align - slots esfericos - estilo materiais 3d
- slider com label "cor dos olhos" - bottom right align
- dropdownlist - bottom left align - "clipes de animação"
- switchbutton - bottoncenteralign - handtrack
Aprenda a transformar um rascunho de UI em JPG em um app WebGL 3D interativo usando VibeCoding. O tutorial mostra como usar uma referência visual para orientar a IA na criação de interfaces, tornando mais fácil escrever prompts detalhados para layout, navegação, controles e interação 3D.
Aprenda a criar um visualizador 3D do Felpudo com Hand Tracking, permitindo controlar e interagir com o modelo usando as mãos. O conteúdo ajuda a entender interação por gestos e controle de objetos 3D, além de ensinar a descrever essas funções em prompts para experiências WebGL, AR, VR e XR.
# CRIE O APP WEBGL COMPLETO — FELPUDONPC | 3D VIEWER PRO 1.0
Crie um app WebGL completo, funcional e pronto para publicação em S3, compatível com Desktop, iOS, Android e Meta Quest / WebXR.
## STACK OBRIGATÓRIA
Three.js r160 (three + OrbitControls + GLTFLoader via importmap), JavaScript, HTML, CSS, MediaPipe Hands (hands + camera_utils + drawing_utils via CDN), WebXR. Projeto em arquivo único HTML, sem dependências locais.
## REGRA FUNDAMENTAL
Carregue TUDO por URL absoluta, nunca por arquivo local:
GLB: https://felpudo.s3.sa-east-1.amazonaws.com/FelpudoNPC_WebGL/FelpudoNPC_Final.glb
Logos (nesta ordem):
1 https://felpudo.s3.sa-east-1.amazonaws.com/FelpudoNPC_WebGL/logo+metaverso+steam.png
2 https://felpudo.s3.sa-east-1.amazonaws.com/FelpudoNPC_WebGL/logo+escola+do+videogame.png
3 https://felpudo.s3.sa-east-1.amazonaws.com/FelpudoNPC_WebGL/logo+aprenda+programar.png
Olhos:
Amarelo https://felpudo.s3.sa-east-1.amazonaws.com/FelpudoNPC_WebGL/mapaOlhoAmarelo.jpg
Azul https://felpudo.s3.sa-east-1.amazonaws.com/FelpudoNPC_WebGL/mapaOlhoAzul.jpg
Marrom https://felpudo.s3.sa-east-1.amazonaws.com/FelpudoNPC_WebGL/mapaOlhoMarrom.jpg
Verde https://felpudo.s3.sa-east-1.amazonaws.com/FelpudoNPC_WebGL/mapaOlhoVerde.jpg
Vermelho https://felpudo.s3.sa-east-1.amazonaws.com/FelpudoNPC_WebGL/mapaOlhoVermelho.jpg
Título HTML: FelpudoNPC | 3D Viewer Pro 1.0
Hospedagem final: https://felpudo.s3.sa-east-1.amazonaws.com/FelpudoNPC_WebGL/Felpudo-3d-Viewer-Webgl.html
## OBJETIVO E VIEWPORT
Visualizador 3D do mascote Felpudo com viewport estilo Blender: grid 3D, câmera orbital, fundo #2b2b2f ou #3c3c3c, modelo centralizado. Preservar geometria, materiais, rig, hierarquia e nomes do GLB.
Iluminação estilo Super Mario Galaxy: realista, suave, cinematográfica. PBR com MeshStandardMaterial/Physical quando apropriado. Luzes: Ambient 0.8, Directional key 2,5,3 intensidade 1.2 com sombras 1024 PCFSoft, Hemisphere e Fill -2,2,-2 0.4. ToneMapping ACESFilmic, exposure 1.0, sombras suaves com qualidade adaptativa.
## UI — POSIÇÕES EXATAS (sem labels amarelos, sem elementos extras)
Top-left 15vw max 200px: logo fixo. CSS: position fixed top 20px left 20px width 15vw pointer-events none user-select none z-index 10 background transparent. Img: width 100% height auto display block user-select none -webkit-user-drag none pointer-events none transition opacity 0.6s ease draggable false. Lógica: inicia src logos[0] opacity 1, setInterval 5000ms -> opacity 0, setTimeout 600ms -> src = (index+1)%3, opacity 1. Sem drag, sem seleção.
Top-center: botão pill MODO-XR #6a6a6a borda verde #2ecc71 3px. Clique inicia WebXR immersive-vr.
Top-right: color picker 12 cores [#FF0000,#00FF00,#0000FF,#FFFF00,#FF00FF,#00FFFF,#FF8000,#8000FF,#FF0080,#80FF00,#0080FF,#FFFFFF] ou paleta primária similar, slots circulares esféricos com box-shadow 3D. Ao clicar: encontrar materiais por nome (corpo/body, asa/wing, palpebra/eyelid). Aplicar: corpo=cor, asa=30% mais escura (lerp to black 0.3), pálpebra=70% mais escura (0.7).
Bottom-right: slider Cor dos Olhos, input range 0-4 com 5 ticks. Trocar textura material olho (nome olho/eye). Carregar via TextureLoader das 5 URLs.
Bottom-left: dropdown Clipes de animação com 7 opções nesta ordem: Entrada, Idle, Walk, Run, Backflip, Saída, Frontflip.
Bottom-center: switch HandTrack ON/OFF.
## ANIMAÇÃO — LÓGICA QUE FUNCIONA (copiar exatamente)
GLB exportado Blender: Animation Type Scene, Split OFF, 1 clip longo com 150 frames totais.
Definição: uO = [{name:"Entrada",s:0,e:30},{name:"Idle",s:31,e:90},{name:"Walk",s:91,e:110},{name:"Run",s:110,e:120},{name:"Backflip",s:121,e:150},{name:"Saída",s:0,e:30,reverseOf:"Entrada"},{name:"Frontflip",s:121,e:150,reverseOf:"Backflip"}]
FPS dinâmico: let fps = 30; if(baseClip && baseClip.duration>0) fps = 150 / baseClip.duration;
createSubClip(baseClip,name,startFrame,endFrame,fps): tenta THREE.AnimationUtils.subclip, se falhar fallback manual filtrando tracks por time entre startFrame/fps e endFrame/fps, normalizando times.
createReversedClip(sourceClip,newName): duration = sourceClip.duration; para cada track, n=times.length, valueSize=values.length/n, criar newTimes = duration - times[revIdx] e newValues copiando bloco reverso, depois ordenar pares por tempo crescente mantendo values, criar novo AnimationClip.
Criação: clipsMap = {}; para defs sem reverseOf criar subclip; se clipsMap.Entrada existe clipsMap["Saída"]=createReversedClip(Entrada,"Saída"); se Backflip existe clipsMap.Frontflip=createReversedClip(Backflip,"Frontflip");
Playback: mixer.clipAction, setLoop LoopRepeat Infinity, reset, fadeIn 0.25, play. Iniciar com Idle. Cada seleção stopAllAction antes.
## HANDTRACK
Video fullscreen opacity 0.10 (10% quase invisível) não espelhado, z-index 5, pointer-events none. Canvas overlay z-index 6. MediaPipe Hands max 2 mãos, minDetection 0.7.
Debug visual preservado: linhas amarelas #ffeb00 nos dedos, círculos verdes #00ff66 nas juntas.
Gestos por landmarks:
isPinch = dist thumb_tip(4) + index_tip(8) <0.05
isOpen = dedos estendidos, isClosed = curl
- 2 mãos pinch = ZOOM (distância entre mãos controla dolly)
- 1 aberta + 1 pinch = ORBIT (movimento mão pinch controla rotação)
- 2 fechadas = PAN (média movimento)
- 1 aberta + double pinch rápido <600ms = RESET câmera com transição animada suave (lerp 800ms cubic)
Máquina de estados com suavização para evitar jitter e conflito. OrbitControls desabilitado quando HandTrack ON.
Feedback sonoro futurista suave via Web Audio (oscillator sine 440-880Hz gain 0.12 duration 0.2s).
Mouse/touch: orbit, zoom, pan. Double click/tap reset câmera suave.
Responsivo desktop/iOS/Android/Quest.
## REGRA ABSOLUTA
NÃO criar menus, toolbars, botões extras, painéis, configs, textos amarelos explicativos, indicadores, sliders adicionais, download/upload/share.
Entregue HTML completo funcional.
HandTrack STEAM Cards combina rastreamento das mãos com cartões visuais para criar experiências interativas de aprendizagem. No Vibecode, esse projeto integra programação, visão computacional e criatividade, permitindo controlar aplicações com gestos e explorar conceitos de Ciência, Tecnologia, Engenharia, Artes e Matemática (STEAM).
# PROMPT COMPLETO — HAND TRACK STEAM | WEBGL + THREE.JS + MEDIAPIPE HANDS + SONS
Crie uma aplicação web interativa em tempo real, fullscreen, utilizando **Three.js, WebGL, MediaPipe Hands, getUserMedia e Web Audio API**, que permita manipular uma galeria com gestos naturais.
## 1. TECNOLOGIAS
- Three.js 0.160.0 via importmap
- MediaPipe Hands via CDN: `https://cdn.jsdelivr.net/npm/@mediapipe/hands@0.4.1646424915/hands.js` + camera_utils
- WebGL renderer com alpha:true
- Web Audio API para sons eletrônicos divertidos (OscillatorNode, sem arquivos externos)
- HTML5/CSS3/JS ES Modules em arquivo único standalone
- requestAnimationFrame loop único, sem alocações no loop
## 2. IMAGENS - 11 URLs EXATAS
Preservar ordem circular, aspect ratio, carregamento assíncrono com TextureLoader, fallback visual se falhar:
1. LOGOTIPO (uso fixo + galeria)
https://felpudo.s3.sa-east-1.amazonaws.com/AprendaProgramarVibecode/HandTrackImagesSTEAM/00+LOGOTIPO.png
2. GATO LARANJA
https://felpudo.s3.sa-east-1.amazonaws.com/AprendaProgramarVibecode/HandTrackImagesSTEAM/01+GATO+LARANJA.png
3. CANÁRIO MAKER
https://felpudo.s3.sa-east-1.amazonaws.com/AprendaProgramarVibecode/HandTrackImagesSTEAM/02+CANARIO+MAKER.png
4. GATO BRANCO
https://felpudo.s3.sa-east-1.amazonaws.com/AprendaProgramarVibecode/HandTrackImagesSTEAM/03+GATO+BRANCO.png
5. PAPAGAIO SOLAR
https://felpudo.s3.sa-east-1.amazonaws.com/AprendaProgramarVibecode/HandTrackImagesSTEAM/04+PAPAGAIO+SOLAR.png
6. GATO CINZA
https://felpudo.s3.sa-east-1.amazonaws.com/AprendaProgramarVibecode/HandTrackImagesSTEAM/05+GATO+CINZA.png
7. COLIBRI AZUL
https://felpudo.s3.sa-east-1.amazonaws.com/AprendaProgramarVibecode/HandTrackImagesSTEAM/06+COLIBRI+AZUL.png
8. SABIÁ ROSA
https://felpudo.s3.sa-east-1.amazonaws.com/AprendaProgramarVibecode/HandTrackImagesSTEAM/07+SABIA+ROSA.png
9. BILL GAMER
https://felpudo.s3.sa-east-1.amazonaws.com/AprendaProgramarVibecode/HandTrackImagesSTEAM/08+BILL+GAMER.png
10. VISION PRO
https://felpudo.s3.sa-east-1.amazonaws.com/AprendaProgramarVibecode/HandTrackImagesSTEAM/09+VISIONPRO.png
11. GATO PRETO
https://felpudo.s3.sa-east-1.amazonaws.com/AprendaProgramarVibecode/HandTrackImagesSTEAM/10+GATO+PRETO.png
## 3. LOGO FIXO
Criar `<div id="fixed-logo">` fixed top:80px left:20px z-index 50 com img do LOGOTIPO 140px, drop-shadow, opacity 0.95, pointer-events none. Sempre visível, independente da galeria.
## 4. LAYERS (ordem z-index)
1. Fundo: div fixed 100vw/vh gradiente vertical #020a1f 0% → #0a1d4a 45% → #1e3a8a 100%
2. Vídeo webcam: fullscreen object-fit cover, opacity controlada por switch CAMERA (OFF padrão 0.1, ON 1.0, transição 400ms), mirror via scaleX(-1)
3. Three.js canvas: fullscreen transparent, imagens como PlaneGeometry com height base 3 e width = height * aspect, MeshBasicMaterial transparent, sombra suave atrás
4. Debug canvas: fullscreen pointer-events none, linhas amarelas #FFEB3B espessura 3, círculos azuis #2196F3 raio 6, pontas 4 e 8 raio 9, topologia mão completa
## 5. UI
Barra topo translúcida backdrop-blur com switches: CAMERA, MIRROR X (ON padrão), DEBUG (ON padrão), FULLSCREEN. Switch estilo iOS animado. Indicador status bottom center: "Inicializando...", "Câmera ativa - Aguardando mãos", "MODO NAVEGAÇÃO ATIVO", etc. Contador "3/10 - GATO BRANCO". Botões laterais: btn-prev left:20px e btn-next right:20px, 80px circulares, blur, borda translúcida, hover amarelo.
## 6. MEDIAPIPE + COORDINATE MAPPER
- maxNumHands 2, modelComplexity 1, minDetection 0.7, minTracking 0.7
- Função centralizada `applyMirror(x) = mirrorOn ? 1 - x : x`
- Função `mapNormToWorld(normX,normY)` com aspect e frustum
- `isHandOpen(hand)`: verifica tip vs pip (8<6,12<10,16<14,20<18) se 3+ dedos estendidos = aberta
- Suavização lerp 0.35 para posição mão, sem delay perceptível
- Tolerância perda momentânea detecção
## 7. GESTOS FINAIS (prioridade)
**GESTO RESET - MÃO ESQUERDA ABERTA + DOUBLE PINCH DIREITA:**
- Detecta right pinch: distância thumb 4 ↔ index 8 <0.05 close, >0.07 open (histerese)
- Double pinch: dois fechamentos em 600ms
- Condição: leftOpen && doublePinchRight
- Ação: animar imagem para pos 0,0 scale 1 rotation.z 0 com easeOutBack 500ms, badge "RESET!", som ta-da, debounce 800ms
**GESTO NAVEGAÇÃO - MÃO ESQUERDA ABERTA + SWIPE DIREITA:**
- Condição: leftOpen (3 frames consecutivos aberta para estabilidade) && rightHand existe && !rightPinch && !dualPinch
- Histórico 18 frames da mão direita (landmark 9), calcula dx e velocidade
- Se |dx|>0.28 em <350ms e vel>0.7: dx< -0.28 = próxima foto, dx>0.28 = anterior
- Animação transição 450ms easeOutCubic: atual sai x ±5 opacity 1→0 scale 1→0.85, próxima entra oposto
- Cooldown 700ms, som swish ascendente/descendente
- Alternativa: pinch sobre btn-prev/btn-next também navega, com highlight amarelo e pulse
**GESTO ZOOM + ROTAÇÃO - PINCH DUAS MÃOS SIMULTÂNEO:**
- Quando ambas pinch ativas, salvar initialDistance (distância entre pinch points), initialScale, initialAngle = atan2(rightY-leftY, rightX-leftX), initialRotation
- A cada frame:
scale = initialScale * (currentDist/initialDist) clamp 0.25-4 lerp 0.18
rawDelta = currentAngle - initialAngle
if mirrorOn rawDelta = -rawDelta
imageRotation = initialRotation + rawDelta * -1 // INVERSÃO * -1 OBRIGATÓRIA para ficar natural horário=horário
mesh.rotation.z = imageRotation lerp 0.18
Tick sonoro a cada 15° e bonk se limite atingido
- Prioridade sobre navegação
**GESTO DRAG - 1 MÃO PINCH SOZINHA:**
- Quando single pinch sem leftOpen modo navegação e sem dual pinch, mover imagem com offset inicial e lerp 0.25
## 8. SONS - WEB AUDIO API
Criar audioCtx no primeiro clique. Funções playTone(freq,dur,type,vol,slide). Sons:
- CAMERA ON pop 800→1200Hz 0.15s, OFF blop 400→200Hz
- MIRROR whoosh 300-900Hz, DEBUG blip 1000Hz, FULLSCREEN arpeggio C5,E5,G5,C6
- Swipe próxima 400→800Hz, anterior 800→400Hz
- Pinch grab 600Hz, zoom stretch 200→600Hz, tick rotação 1200Hz, limite bonk 150Hz, reset ta-da C-E-G-C + boing 200→50Hz
## 9. FULLSCREEN + PERFORMANCE
Botão requestFullscreen no documentElement, recalcular renderer e câmera, preservar posição/escala, suportar ESC e resize/orientation. Reutilizar geometrias/materiais/vetores, texturas assíncronas, tratar permissão câmera, fallback teclado/mouse (setas navega, drag mouse, scroll zoom), 60FPS.
Entregar HTML único funcional em HTTPS/localhost, sem build, pronto para abrir.
Aprender Body Tracking com WebGL é importante para o VibeCode 3D, pois permite explorar o reconhecimento dos movimentos corporais e sua integração com personagens e objetos virtuais. Esses conhecimentos ajudam a criar experiências interativas controladas pelo corpo. Assista à aula e pratique seus próprios protótipos.
Explore como o Animoji e o ARKit transformaram a interação com dispositivos Apple. Conheça tecnologias de captura facial, animação 3D e realidade aumentada, além das aquisições da Apple que contribuíram para sua evolução. Use o VibeCode para experimentar conceitos semelhantes em aplicações interativas.
Aprenda sobre o Apple AR Quick Look e o formato USDZ para visualizar modelos 3D em realidade aumentada no iPhone e iPad. Esse conhecimento é importante para entender formatos, publicação e visualização de assets 3D e criar prompts voltados a experiências AR para dispositivos Apple.
Aprenda sobre o Apple AR Quick Look e o formato USDZ para visualizar modelos 3D em realidade aumentada no iPhone e iPad. Esse conhecimento é importante para entender formatos, publicação e visualização de assets 3D e criar prompts voltados a experiências AR para dispositivos Apple.
Aprenda a usar o Reality Composer no iPhone e iPad para criar experiências de realidade aumentada com objetos e cenas 3D.
Esse conhecimento ajuda a entender como estruturar e posicionar conteúdos espaciais e a criar prompts para desenvolver experiências AR e projetos de computação espacial.
Explore recursos de Realidade Aumentada com VibeCode, inspirados no ARKit da Apple. Experimente criar aplicações com Plane Tracking para detectar superfícies reais e segmentação de pessoas para separar indivíduos do fundo da imagem. Use a IA para prototipar experiências que combinem ambientes físicos e objetos virtuais.
Aprenda os conceitos de Image Tracking com ARKit e Xcode Swift. Explore como reconhecer imagens do mundo real e usá-las como gatilhos para exibir objetos 3D, animações e conteúdos interativos em Realidade Aumentada. Use o VibeCode para prototipar experiências semelhantes com o auxílio da IA.
Explore o Multiple Image Tracking com ARKit para reconhecer várias imagens simultaneamente e associar conteúdos digitais a cada uma delas. Com VibeCode, experimente criar protótipos de Realidade Aumentada com modelos 3D, animações e interações acionadas por diferentes imagens do mundo real.
Explore a segmentação de pessoas com ARKit e VibeCode. Aprenda como a IA identifica pessoas e separa suas silhuetas do fundo da imagem, permitindo combinar pessoas reais com objetos 3D, efeitos visuais e cenários virtuais. Experimente criar protótipos de Realidade Aumentada com interações em tempo real.
Explore a segmentação de pessoas com ARKit e VibeCode. Aprenda como a IA identifica pessoas e separa suas silhuetas do fundo da imagem, permitindo combinar pessoas reais com objetos 3D, efeitos visuais e cenários virtuais. Experimente criar protótipos de Realidade Aumentada com interações em tempo real.
Explore a estimativa de iluminação com ARKit e VibeCode. Aprenda como analisar a luz do ambiente real para ajustar a iluminação de objetos 3D virtuais, criando sombras e integração visual mais realistas. Experimente desenvolver protótipos de Realidade Aumentada que conectam o mundo físico ao digital.
Explore a estimativa de iluminação com ARKit e VibeCode. Aprenda como detectar as condições de luz do ambiente real para iluminar objetos 3D virtuais de forma mais natural. Experimente criar protótipos de Realidade Aumentada com sombras, reflexos e integração visual entre o mundo físico e o digital.
Explore o reconhecimento de objetos com ARKit e VibeCode. Experimente criar aplicações que identificam objetos do mundo real e associam informações, animações ou modelos 3D a eles. Use a IA para desenvolver protótipos interativos que conectam visão computacional e Realidade Aumentada.
Explore a digitalização de objetos com ARKit e a criação de experiências no Reality Composer. Aprenda como capturar objetos do mundo real e transformá-los em referências para experiências 3D interativas. Use o VibeCode para prototipar aplicações de Realidade Aumentada com modelos virtuais, animações e interações.
Explore o reconhecimento de objetos com ARKit usando o Apple Park, o icônico Spaceship em Cupertino, como inspiração. Experimente criar um protótipo em VibeCode que reconheça edifícios e modelos arquitetônicos, exibindo informações, animações e reconstruções 3D em experiências de Realidade Aumentada.
Explore a técnica AR Portal Mask com VibeCode e ARKit para criar portais virtuais que revelam outros ambientes dentro do mundo real. Use a IA para prototipar máscaras espaciais, efeitos de profundidade e transições entre cenários 3D, criando experiências imersivas de Realidade Aumentada.
Explore o Face Tracking com ARKit e VibeCode para criar experiências interativas baseadas no reconhecimento facial. Experimente mapear expressões, movimentos da cabeça e pontos faciais para animar personagens 3D, criar Animojis e aplicar efeitos de Realidade Aumentada em tempo real.
Conhecer o VisionKit e o simulador do visionOS é importante para compreender como desenvolver e testar experiências espaciais. Esses conhecimentos ajudam a implementar, refinar e controlar interfaces e interações 3D no VibeCode. Assista à aula e pratique os conceitos em seus projetos.
Explore o Spline, ferramenta de criação 3D interativa para a web. Desenvolva cenários, objetos, animações e experiências interativas diretamente no navegador, sem programação complexa. Aprenda a integrar elementos 3D em sites, portais e projetos digitais, combinando design, criatividade e tecnologia.
Aprender a publicar projetos Unity em WebGL é importante para o VibeCode 3D, pois permite compreender como exportar e disponibilizar experiências interativas diretamente no navegador. Esses conhecimentos ajudam a testar, integrar e refinar jogos e aplicações 3D para a web. Assista à aula e pratique a publicação do seu projeto no Unity Play.
Aprender a publicar projetos na Amazon AWS é importante para o VibeCode, pois permite compreender como hospedar aplicações, disponibilizar arquivos e integrar serviços na nuvem. Esses conhecimentos ajudam a implementar e manter experiências 3D acessíveis pela internet. Assista à aula e pratique a publicação do seu projeto.
Explorar química em Realidade Aumentada com Vuforia e Unity é importante para o VibeCode 3D, pois permite compreender como integrar modelos 3D e conteúdos interativos ao mundo real. Esses conhecimentos ajudam a criar simuladores e experiências educacionais. Assista à aula e pratique a criação de projetos de AR.
Como Criar uma Realidade Aumentada com Unity 2021 e Vuforia SDK Tutorial em Português Atualizado!
Criar um Flappy Bird com Vuforia e Image Target é uma oportunidade para aplicar conceitos de VibeCode 3D, combinando reconhecimento de imagens, lógica de jogo, física e interação em Realidade Aumentada. Assista à aula, pratique e explore como transformar uma imagem real em palco para seu jogo.
Criar uma aventura de plataforma 3D com Vuforia e Image Target ajuda a aplicar conceitos de VibeCode 3D, combinando reconhecimento de imagens, movimentação de personagens, colisões e cenários virtuais em Realidade Aumentada. Assista à aula e pratique a criação de jogos interativos acionados por imagens reais.
Aprender Cylinder Target com Vuforia é importante para o VibeCode 3D, pois permite reconhecer imagens aplicadas em superfícies cilíndricas, como latas e embalagens. Esse conhecimento ajuda a criar experiências de Realidade Aumentada com objetos 3D e conteúdos interativos. Assista à aula e pratique.
Aprender Unity com OpenXR para Meta Quest é importante para o VibeCode 3D, pois permite compreender como desenvolver aplicações de Realidade Virtual, configurar ambientes imersivos e controlar interações em 3D. Esses conhecimentos ajudam a implementar e refinar experiências XR. Assista ao tutorial e pratique criando seu primeiro app de VR.
Explore dezenas de projetos 2D e 3D criados em Unity no portal, analisando o código linha a linha. Esses protótipos podem ser revisados com IA e adaptados ao VibeCode. Baixe projetos e gráficos para estudar, modificar e implementar novas funcionalidades em suas próprias experiências interativas.
O projeto Segredos da Floresta une folclore brasileiro, educação ambiental, jogos e animações. Com VibeCode, você pode estudar seus protótipos, recriar mecânicas, desenvolver novos minijogos e usar a IA para implementar, refinar e expandir experiências interativas que conectam tecnologia, cultura e educação.
Sinfonia Amazônica é uma obra marcante da animação brasileira que inspira novas possibilidades criativas.
Explore como o VibeCode 3D e a IA podem ajudar a reinventar histórias, personagens e cenários por meio de games e animações. Estude a obra e pratique novas formas de expressão digital, respeitando os direitos autorais aplicáveis.
Visite também a Galeria de Projetos do AprendaProgramar no Scratch para jogar e explorar as aplicações criadas em aula.
Scratch MIT é uma plataforma visual para criar jogos 2D e aplicações interativas usando blocos de programação. No Vibecode, ajuda a aprender lógica, testar ideias e desenvolver experiências digitais.
A visão computacional permite que aplicações reconheçam movimentos e interajam com o ambiente usando a câmera. No Vibecode, estudar essa tecnologia com Scratch ajuda a criar jogos e experiências interativas que respondem aos movimentos do usuário.
A detecção de direção permite identificar para onde um objeto ou movimento está se deslocando usando visão computacional. No Vibecode, esse conceito ajuda a criar jogos e aplicações interativas que respondem aos gestos e movimentos do usuário.
Processing é um ambiente de programação criativa baseado em Java, ideal para criar gráficos, animações e jogos 2D. No Vibecode, estudar essa tecnologia ajuda a compreender lógica, movimento e interação, transformando ideias em experiências visuais interativas.
Processing e Java permitem criar visualizações gráficas e explorar dados de forma interativa. No Vibecode, estudar essas tecnologias ajuda a transformar informações em gráficos, animações e experiências visuais, facilitando a compreensão de padrões e conceitos de ciência de dados.
Processing, Java e OpenCV merecem um momento especial! Explore os projetos dos cursos do AprendaProgramar: jogos 2D criados com código Java, orientação a objetos, ciência de dados e visão computacional. Uma jornada para aprender lógica, algoritmos e programação aplicados a gráficos, animações e artes visuais.
Processing, Java e OpenCV permitem criar aplicações que analisam imagens e vídeos para detectar objetos, movimentos e padrões visuais. No Vibecode, estudar visão computacional ajuda a desenvolver experiências interativas que conectam programação, câmeras e inteligência artificial.
A Tabela Periódica organiza os elementos químicos por número atômico e propriedades. No Vibecode, ferramentas como Gizmo, Pocket e Meta AI ajudam a criar aplicações educativas interativas para explorar elementos, visualizar informações e aprender Química por meio de experiências digitais.
Um Sistema Solar 3D permite explorar planetas, órbitas e movimentos celestes em um ambiente interativo. No Vibecode, ferramentas como Gizmo, Pocket e Meta AI ajudam a criar experiências educativas com visualização espacial, programação e simulações, tornando o aprendizado de Astronomia mais visual e envolvente.
Mapas interativos em WebGL permitem visualizar dados geográficos em ambientes 3D diretamente no navegador. No Vibecode, esse projeto explora geografia, história e visualização de dados, mostrando como criar aplicações educativas interativas com ferramentas como Pocket, Gizmos e Meta AI.
A visão espacial combina realidade virtual, rastreamento das mãos e interação com ambientes 3D usando tecnologias como Meta Quest e WebXR. No Vibecode, estudar computação espacial permite criar experiências imersivas, interfaces gestuais e aplicações que conectam o mundo físico ao digital.
O Mapa das Teorias da Web combina visualização 3D com rastreamento das mãos para explorar ideias, conceitos e conexões do universo digital. No Vibecode, esse projeto integra WebGL, computação espacial e interação gestual, mostrando como transformar conhecimento em experiências visuais imersivas diretamente no navegador.
O Tennis Ball Motion Tracker utiliza visão computacional para detectar e acompanhar o movimento de uma bola de tênis em vídeo. No Vibecode, esse projeto ensina conceitos de rastreamento de objetos, análise de movimento e processamento de imagens, conectando programação, matemática e tecnologia esportiva.
Compre e Aprenda Vibecoding Já!
Crie e Publique os Primeiros Apps.
Aplicações Vibecode 3D AR XR
Início Imediato e Acesso Vitalício
Toda segunda-feira (de 07 às 09 h)
GoogleMeet (interação prof-alunos)
1 Projeto Novo todo Mês | 3D AR XR
Modo Mensalidade - R$120,00
Compre pela Hotmart e tenha acesso a:
4 Horas de Mentoria Particular
Aulas Ao Vivo (por 1 ano | seg. 7às9)
Novo Curso Vibecode-XR (1 hora)