• Leia rápido. Se você já faz, siga. Se travou, é sinal de estudar/praticar.
• → aprofunde em…: Unity (completa), C#, Blender 3D, Computação Gráfica & Three.js.
• Unity é um editor + engine: você monta a cena no editor e escreve o comportamento em C#.
• Caixas ⚠️: o que causa bugs difíceis ou perda de trabalho. Checklist final para marcar.

Q  pan (hand)   W  mover   E  girar   R  escalar   T  rect   Y  transform combinado
F               enquadrar o objeto selecionado
RMB + WASD/QE   voar pela cena (Shift acelera)     |    Alt+LMB  orbitar    |    scroll  zoom
Ctrl (arraste)  snap por incremento     |     V     vertex snap

• Local vs World: transform.position (world) vs transform.localPosition (relativo ao pai). O toggle Pivot/Center e Local/Global na barra muda como o gizmo se comporta.
• Parenting: arraste na Hierarchy; o filho herda transform do pai. Cuidado: escalas não-uniformes no pai distorcem filhos rotacionados.
• Unidades: 1 unidade Unity = 1 metro (importante para física e para bater com modelos do Blender — exporte em escala real).
• Reset: no menu de contexto do Transform → Reset zera para 0/0/1.

Awake()        1x, ao criar o objeto — inicialize referências próprias
OnEnable()     toda vez que o componente é ativado
Start()        1x, antes do 1º Update — use para acessar OUTROS objetos (já passaram por Awake)
Update()       todo frame — input, lógica de jogo (multiplique por Time.deltaTime!)
FixedUpdate()  passo fixo — TODA física / Rigidbody (AddForce, velocity)
LateUpdate()   depois de todos os Update — câmera seguindo o player
OnDestroy()    ao destruir — limpe eventos, timers

public class Mover : MonoBehaviour {
    [SerializeField] float speed = 5f;   // privado, mas editável no Inspector
    Rigidbody rb;

    void Awake() { rb = GetComponent<Rigidbody>(); }   // cache: NÃO chame em Update

    void Update() {
        float h = Input.GetAxis("Horizontal");
        transform.Translate(Vector3.right * h * speed * Time.deltaTime);
    }
}

• Time.deltaTime: multiplique movimento/rotação por ele em Update para ficar independente de FPS.
• Cache GetComponent em Awake/Start; chamá-lo todo frame é lento.
• [SerializeField] private > public: expõe no Inspector sem quebrar encapsulamento.
• Coroutines (IEnumerator + yield return): ações ao longo do tempo (esperar, animar em passos) sem travar o frame.
• Eventos: UnityEvent (liga no Inspector) ou C# event/Actions (código) para desacoplar.
• Null reference: o erro mais comum — uma referência do Inspector ficou vazia, ou o objeto foi destruído.

• Criar: arraste um GameObject da Hierarchy para a pasta Assets/. Vira azul na Hierarchy = instância de prefab.
• Editar: abra o prefab (Prefab Mode) — muda todas as instâncias. Ou edite uma instância e faça Overrides > Apply (ou Revert).
• Prefab Variant: um prefab que herda de outro com ajustes (ex.: "InimigoRápido" baseado em "Inimigo").
• Nested prefabs: prefabs dentro de prefabs — suportado.
• Runtime: Instantiate(prefab, position, rotation) cria cópias em jogo; Destroy(go) remove. Para muitos objetos frequentes (balas), use object pooling em vez de Instantiate/Destroy repetido.

[SerializeField] GameObject bulletPrefab;
[SerializeField] Transform muzzle;

void Fire() {
    Instantiate(bulletPrefab, muzzle.position, muzzle.rotation);
}

• Precisa de Rigidbody em pelo menos um dos objetos para gerar eventos de colisão/trigger. Sem Rigidbody, dois Colliders se atravessam sem avisar.
• Colisão sólida → OnCollisionEnter/Stay/Exit; ambos os Colliders não são triggers.
• Trigger (um Collider com Is Trigger) → OnTriggerEnter/Stay/Exit; passa através, só detecta.
• Kinematic Rigidbody: movido por código/animação, não por forças; ainda dispara triggers.
• Mova via física (rb.MovePosition, rb.velocity, AddForce) em FixedUpdate; mover transform direto "fura" paredes.
• Layers + Collision Matrix (Project Settings > Physics): defina o que colide com o quê — desligue pares desnecessários por performance.
• Raycast: Physics.Raycast(origin, direction, out hit, maxDistance, layerMask) — tiro hitscan, seleção, "está no chão?".
• 2D é separado: Rigidbody2D, Collider2D, OnCollisionEnter2D, Physics2D.Raycast.

• Canvas render mode: Screen Space – Overlay (HUD, padrão), Screen Space – Camera (com efeitos/perspectiva), World Space (UI no mundo 3D).
• RectTransform: âncoras (anchor) prendem os cantos a uma fração do pai; pivot é o ponto de referência do próprio elemento. Modelo mental: âncora define "gruda onde" quando a tela redimensiona.
• Canvas Scaler: modo Scale With Screen Size + Reference Resolution (ex.: 1920×1080) + Match Width/Height → UI escala em telas diferentes.
• Layout Groups (Horizontal/Vertical/Grid) + Content Size Fitter para listas e menus que se ajustam.
• EventSystem: um objeto na cena obrigatório para cliques/toque funcionarem na UI.
• uGUI vs UI Toolkit: uGUI (baseado em GameObjects, maduro, ótimo p/ UI de jogo no mundo) vs UI Toolkit (estilo web, USS/UXML, forte p/ ferramentas de editor) — noção.

• Render pipeline: URP (padrão recomendado — multiplataforma, performática, Shader Graph), HDRP (alta fidelidade, PC/console), Built-in (legado). Trocar depois dá trabalho — decida no início do projeto.
• Import settings (Inspector do asset): texturas (Max Size, compressão, sRGB, tipo Normal Map), modelos (Scale Factor, gerar colliders, importar materiais/animação), áudio (Load Type, compressão). Ajuste — os defaults inflam o build.
• Material + Shader: material = instância de um shader com valores; em URP use Lit/Unlit ou crie no Shader Graph.
• Lighting: Realtime (dinâmico, caro), Baked (assado no lightmap, estático e barato), Mixed. Light Probes iluminam objetos dinâmicos com luz assada; Reflection Probes para reflexos locais. Faça o bake (Window > Rendering > Lighting).
• Sprite Atlas (2D): agrupa sprites para reduzir draw calls.
• Static flag: marque objetos imóveis como Static → batching, occlusion culling, lightmapping.

• Build Settings (Ctrl+Shift+B): plataforma, lista de Scenes in Build (a cena 0 é a que abre), Development Build (liga Profiler/logs).
• Profiler (Window > Analysis > Profiler): CPU, GPU, Memory, Rendering. Ache o pico de frame e o que o causa antes de mexer em qualquer coisa.
• Draw calls / batching: menos materiais, Static batching (objetos estáticos), SRP Batcher (URP/HDRP), GPU Instancing para muitos objetos iguais, atlas de texturas.
• Object pooling: reutilize objetos em vez de Instantiate/Destroy constante (evita GC spikes).
• GC / alocações: evite alocar em Update (LINQ, new, boxing, string +); cause menos garbage.
• Quality Settings + níveis por plataforma; resolução, sombras, LOD Groups, occlusion culling.
• Addressables (noção): sistema moderno de carregar assets sob demanda; prefira a Resources/ (que incha o build e não escala).

Aprofundamento: Unity (completa) · C# · Blender 3D · Computação Gráfica & Three.js.