Blender para Desenvolvimento de Jogos: Guia Prático Completo

Blender é gratuito, open source e faz tudo que um pipeline de assets 3D para jogos precisa: modelagem, UV, texturização, rigging, animação e export. Você não precisa de Maya nem 3ds Max pra entregar asset profissional. Estúdios usam Blender em produção de verdade (a Ubisoft adotou no fluxo de animação, a Epic financia o desenvolvimento via Epic MegaGrant), e milhares de indies tocam o jogo inteiro nele.

Este guia é o caminho prático: o setup que eu deixaria pronto antes de tocar em qualquer asset, as decisões de modelagem que economizam retrabalho, e o que de fato importa na hora de exportar pra Unity, Unreal ou Godot. Sem encher linguiça. Foco no que vai pro engine.

Por Que Blender no Game Dev Indie

A vantagem real não é só o preço (apesar de zero custo ajudar muito quando você está começando). É o seguinte:

• Sem trava de licença. Você instala em qualquer máquina, comercializa o que produzir, e ninguém vem cobrar assinatura no meio do projeto.
• Pipeline completo num programa só. Modelar, abrir UV, texturizar, riggar e animar sem pular entre ferramentas. Pra quem trabalha sozinho ou em equipe pequena, isso é tempo de produção.
• Python embutido. Quase tudo que você faz no mouse dá pra automatizar com script. Quando o projeto cresce, isso vira ouro: export em lote, geração de LOD, checagem de poly count.
• Workflow não-destrutivo via modifiers. Você empilha operações (espelhar, subdividir, decimar) sem destruir o mesh base, e ajusta a qualquer momento.
• Ciclo de versões rápido. Costumam sair três a quatro releases grandes por ano, com features novas voltadas pra produção.

Não vou inventar número de download nem ranking. O ponto é que Blender é ferramenta de produção séria, e a única coisa que separa você de um asset bom é prática, não orçamento.

O Que Mudou nas Versões Recentes

Algumas features que fazem diferença direta no fluxo de game asset:

• Geometry Nodes: modelagem procedural baseada em nós. Bom pra gerar variação (pedras, plantas, detalhes repetidos) sem modelar cada peça na mão.
• Principled BSDF: shader PBR único que mapeia bem pra qualquer engine moderna, então o que você vê no Blender chega perto do que aparece no jogo.
• Suporte a USD: facilita troca de cena com outras ferramentas do pipeline.
• Export glTF maduro: o caminho natural pra Godot e pra web, com PBR nativo.

Setup Inicial para Game Development

Antes de modelar qualquer coisa, vale ajustar três coisas: preferências, unidades e um workspace que faça sentido pro fluxo.

Preferências que Valem a Pena

Em Edit > Preferences, ajuste:

• System > Cycles Render Devices: ative GPU Compute (CUDA, OptiX, HIP ou Metal, conforme sua placa). Render e bake voam.
• System > Memory & Limits > Undo Steps: suba pra algo como 64 ou 128. Modelagem dá muito Ctrl+Z.
• Viewport > Clip Start / End: se você modela objetos pequenos, baixe o Clip Start pra 0.01m pra não perder precisão no zoom.
• Add-ons: ative os que já vêm no Blender e ajudam direto no fluxo de asset: Node Wrangler (atalhos no editor de shader), LoopTools (helpers de modelagem) e Bool Tool (operações booleanas rápidas).

Unidades: Configure Antes de Começar

Engines trabalham em metros. Se você modelar fora de escala, o objeto chega gigante ou minúsculo no jogo, e corrigir depois dá dor de cabeça. Em Scene Properties > Units:

• Unit System: Metric
• Unit Scale: 1.0
• Length: Meters

Deixe a escala correta desde o primeiro objeto e modele com referência de tamanho real (um personagem humano em torno de 1.8m, por exemplo). Mudar Unit Scale no meio do projeto bagunça exports antigos, então decida cedo.

Workspace para Asset de Jogo

Monte um workspace com o que você usa o tempo todo: viewport 3D em modo Solid, o UV Editor de um lado e o Shader Editor embaixo. Salve esse layout (botão + na barra de workspaces) pra abrir o arquivo já no ambiente de trabalho certo. Pequeno, mas economiza cliques toda sessão.

Modelagem Low-Poly para Performance

A regra mental de game art: cada triângulo precisa justificar a existência. No cinema você renderiza um frame por minuto e ninguém liga pra contagem de polígono. No jogo, a placa renderiza a cena inteira 60 vezes por segundo. Polígono que não aparece na silhueta nem segura uma deformação é desperdício.

Quanto de Polígono Usar

Não existe número sagrado, e depende muito do jogo e da plataforma. Os intervalos abaixo servem de referência inicial, não de lei:

• Mobile costuma ser apertado: personagem na casa de poucos milhares de triângulos, props na casa das centenas.
• PC e console indie dá folga: personagem na casa das dezenas de milhares, props de alguns milhares.
• Produção AAA trabalha com personagens na casa das centenas de milhares, contando com LOD agressivo pra segurar a cena.

O caminho prático é: olhe jogos parecidos com o seu, abra os assets quando der (muitos vêm em ferramentas como o RenderDoc), e calibre o seu budget a partir daí. Comece enxuto. É mais fácil adicionar detalhe do que tirar.

Topologia que Deforma Bem

Pra qualquer coisa que vá animar (personagem, criatura, parte mecânica que dobra), a topologia importa mais que a contagem:

• Edge loops nas articulações. Cotovelo, joelho, ombro precisam de loops o suficiente pra dobrar sem achatar.
• Quads nas áreas de deformação. Evite triângulos e n-gons onde o mesh vai dobrar. Eles deformam de forma imprevisível.
• Densidade uniforme. Mudança brusca de resolução no mesh aparece como artefato na hora de animar.
• Poles longe das dobras. Os pontos onde cinco ou mais arestas se encontram criam tensão. Esconda em áreas rígidas.

Modifiers no Fluxo Não-Destrutivo

A stack de modifiers deixa você trabalhar sem se comprometer cedo demais. Um arranjo comum num asset de jogo:

• Mirror: modela metade, o Blender espelha a outra. Some o Mirror antes de abrir UV se quiser ilhas separadas.
• Subdivision Surface: só pra preview da forma. Em low-poly você raramente aplica de verdade.
• Array: pra elementos repetidos (degraus de escada, elos de corrente).
• Decimate: reduz polígono automaticamente. Bom pra LOD, não pro mesh principal (a topologia que sai é feia pra deformação).
• Weighted Normal: melhora o sombreamento em mesh de poucos polígonos, suavizando a transição de luz nas faces.

Exemplo: Gerar um Prop com Script

Quando você precisa de variações ou de repetir um setup, o bpy resolve. Esse script cria um cilindro low-poly e empilha os modifiers de um prop simples (um barril). Roda no editor de scripting do Blender:

import bpy

def create_optimized_barrel():
    # Cilindro base de 12 lados (low poly)
    bpy.ops.mesh.primitive_cylinder_add(vertices=12, radius=0.5, depth=1.0)
    obj = bpy.context.active_object
    obj.name = "Barrel"

    # Espessura de parede
    solidify = obj.modifiers.new(name="Solidify", type='SOLIDIFY')
    solidify.thickness = 0.02

    # Bevel pra suavizar as quinas (pega melhor a luz)
    bevel = obj.modifiers.new(name="Bevel", type='BEVEL')
    bevel.width = 0.01
    bevel.segments = 2

    return obj

create_optimized_barrel()

O argumento do type em modifiers.new() é o identificador interno do Blender ('SOLIDIFY', 'BEVEL', 'DECIMATE', 'MIRROR', e por aí vai). Se errar a string, o Blender reclama na hora, então é fácil testar.

LOD: Level of Detail

LOD é a sua malha vista de longe. Quando o objeto está distante da câmera, o jogo troca por uma versão mais pobre que ninguém percebe. É uma das otimizações que mais rende em cena aberta.

A ideia é simples: o LOD0 é o modelo cheio (close-up), e cada nível seguinte corta detalhe que a distância já esconde. Você reduz polígono, remove detalhes pequenos e, nos níveis bem distantes, mantém só a silhueta. Em casos extremos, o objeto longe vira um billboard (uma imagem plana).

Dá pra gerar os níveis na mão (mais controle, melhor resultado) ou automatizar com o modifier Decimate quando o asset é simples. O script abaixo duplica o objeto base e cria LODs com proporções decrescentes de polígono:

import bpy

def generate_lods(base_object, ratios=(0.5, 0.25, 0.1)):
    lods = []
    for i, ratio in enumerate(ratios, start=1):
        # Duplica o objeto base
        bpy.ops.object.select_all(action='DESELECT')
        base_object.select_set(True)
        bpy.context.view_layer.objects.active = base_object
        bpy.ops.object.duplicate()

        lod = bpy.context.active_object
        lod.name = f"{base_object.name}_LOD{i}"

        # Decimate na proporção do nível
        decimate = lod.modifiers.new(name="Decimate", type='DECIMATE')
        decimate.ratio = ratio
        bpy.ops.object.modifier_apply(modifier=decimate.name)

        lods.append(lod)
    return lods

base = bpy.context.active_object
generate_lods(base)

Decimate automático funciona bem em rocha, caixa, prop sem deformação. Pra personagem, prefira retopologia manual: o Decimate gera triângulos longos que estragam a animação.

UV Unwrapping Profissional

UV é onde você "desdobra" o modelo 3D num plano 2D pra pintar a textura. UV ruim significa textura esticada, costura aparecendo e desperdício de resolução. Vale o tempo que você gastar fazendo direito.

Princípios de UV para Jogos

• Use o espaço. O quadrado UV é o seu orçamento de textura. Ilhas pequenas e espaço vazio jogam resolução fora. Empacote bem.
• Densidade de texel consistente. Texel é o pixel da textura projetado na superfície. Se uma parte do modelo tem textura mais "apertada" que outra, fica óbvio no jogo. Mantenha a densidade parecida entre as peças.
• Esconda as costuras. Toda ilha UV gera uma costura no modelo. Coloque essas costuras onde o jogador não olha: embaixo do braço, dentro de dobras, atrás do objeto.
• Endireite o que der. Ilhas retas (canos, faixas) empacotam melhor que ilhas tortas e gastam menos espaço.

Densidade de Texel na Prática

A conta é direta: densidade de texel é resolução da textura dividida pelo tamanho do objeto no mundo. Uma textura de 2048px num objeto de 2m dá 1024 pixels por metro. O importante não é o número exato, e sim usar o mesmo alvo de densidade em todos os assets da cena, pra que a nitidez seja uniforme.

Pra não fazer isso no olho, instale o add-on Texel Density Checker (gratuito). Ele mede e ajusta a densidade das ilhas pra um alvo definido, e é o jeito mais rápido de manter consistência num conjunto grande de assets.

Smart UV Project para Asset Rápido

Pra prop que não é hero, o Smart UV Project entrega um UV decente em segundos. Ele corta o modelo por ângulo automaticamente. No editor de scripting:

import bpy

obj = bpy.context.active_object
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='SELECT')

# angle_limit em radianos. 1.15 rad = ~66 graus (o default)
bpy.ops.uv.smart_project(angle_limit=1.15, island_margin=0.02)
bpy.ops.object.mode_set(mode='OBJECT')

Um detalhe que pega muita gente: o angle_limit do smart_project é em radianos no script (1.15 ≈ 66°), apesar da interface mostrar graus. A island_margin é o espaço entre ilhas, pra evitar que a cor de uma vaze na outra (0.02 é um ponto de partida razoável).

Trim Sheets e Atlas

Duas técnicas que economizam memória de textura:

Atlas junta o UV de vários objetos numa textura só. Menos arquivos, menos draw calls. Bom pra um conjunto de props que aparecem sempre juntos.

Trim sheet é uma folha de textura com tiras de material (madeira, metal, concreto) que você reaproveita mapeando várias peças pra mesma seção. Em ambiente modular (paredes, pisos, corredores), trim sheet rende muito: uma textura serve dezenas de objetos. O segredo é alinhar os UVs ao grid de pixels da folha pra o tiling fechar sem emenda.

Texturização PBR para Engines Modernas

PBR (Physically Based Rendering) é o padrão das engines atuais. Em vez de pintar como a superfície deve parecer, você descreve as propriedades físicas dela (cor base, rugosidade, se é metal ou não) e deixa a iluminação resolver. Por isso o mesmo material fica coerente em qualquer luz.

Shader Universal: Principled BSDF

O Principled BSDF é o shader que mapeia direto pro modelo PBR das engines. Um material de jogo costuma ligar três texturas nele: cor base (Base Color), rugosidade (Roughness) e normal map. O pulo do gato é o espaço de cor: a textura de cor é sRGB (Color), mas roughness, metallic e normal são dados, não cor, então precisam ficar como Non-Color. Errar isso deixa a superfície com rugosidade e relevo errados.

O script abaixo monta um material PBR ligando as texturas no Principled BSDF, já tratando o espaço de cor:

import bpy

def setup_pbr_material(obj, textures):
    mat = bpy.data.materials.new(name=f"{obj.name}_Material")
    mat.use_nodes = True
    nodes = mat.node_tree.nodes
    links = mat.node_tree.links
    principled = nodes["Principled BSDF"]

    # Cor base (sRGB, fica como Color)
    if 'diffuse' in textures:
        tex = nodes.new('ShaderNodeTexImage')
        tex.image = bpy.data.images.load(textures['diffuse'])
        links.new(tex.outputs['Color'], principled.inputs['Base Color'])

    # Roughness (dado, precisa ser Non-Color)
    if 'roughness' in textures:
        tex = nodes.new('ShaderNodeTexImage')
        tex.image = bpy.data.images.load(textures['roughness'])
        tex.image.colorspace_settings.name = 'Non-Color'
        links.new(tex.outputs['Color'], principled.inputs['Roughness'])

    # Normal map (Non-Color + node Normal Map no meio)
    if 'normal' in textures:
        tex = nodes.new('ShaderNodeTexImage')
        tex.image = bpy.data.images.load(textures['normal'])
        tex.image.colorspace_settings.name = 'Non-Color'

        normal_map = nodes.new('ShaderNodeNormalMap')
        links.new(tex.outputs['Color'], normal_map.inputs['Color'])
        links.new(normal_map.outputs['Normal'], principled.inputs['Normal'])

    obj.data.materials.append(mat)
    return mat

setup_pbr_material(bpy.context.active_object,
                   {'diffuse': '//textures/diffuse.png'})

O normal map nunca liga direto no input Normal: ele passa por um node Normal Map, que converte os valores da imagem na direção certa. É um erro comum, e o sintoma é o relevo aparecer estranho ou invertido.

Baking: do High-Poly pro Low-Poly

Bake é o que deixa um modelo de poucos polígonos parecer detalhado. Você esculpe a versão cheia de detalhes (high-poly), "assa" esse detalhe numa textura, e aplica no modelo leve (low-poly). O jogo roda o leve, mas a luz se comporta como se o detalhe estivesse lá.

Os bakes mais úteis no fluxo de jogo:

• Normal map: o principal. Captura o relevo do high-poly numa imagem. Use a opção Selected to Active (seleciona o high, depois o low como ativo) e ajuste o ray distance pra cobrir o relevo sem captar geometria errada.
• Ambient Occlusion: as sombras de contato (cantos, frestas) assadas numa textura. Dá profundidade sem custar sombra dinâmica em tempo real.

Para iluminação estática (cenário que não muda), o lightmap bake queima a luz numa textura. Isso exige um segundo conjunto de UV, sem ilhas sobrepostas, porque cada ponto da superfície precisa de um lugar único no lightmap. O script abaixo cria esse segundo UV e prepara o Cycles pra um bake de difusa:

import bpy

def setup_lightmap_uv(obj):
    # Segundo UV exclusivo pra lightmap
    obj.data.uv_layers.new(name="Lightmap")
    obj.data.uv_layers["Lightmap"].active = True

    bpy.context.view_layer.objects.active = obj
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='SELECT')
    # Margem maior evita vazamento de luz entre ilhas
    bpy.ops.uv.smart_project(angle_limit=1.15, island_margin=0.05)
    bpy.ops.object.mode_set(mode='OBJECT')

    # Configura o Cycles pro bake
    scene = bpy.context.scene
    scene.render.engine = 'CYCLES'
    scene.cycles.bake_type = 'DIFFUSE'
    scene.render.bake.use_pass_direct = True
    scene.render.bake.use_pass_indirect = True
    scene.render.bake.use_pass_color = False

setup_lightmap_uv(bpy.context.active_object)

Rigging e Animação para Games

Rig é o esqueleto que move o modelo. Pra jogo, o rig precisa ser eficiente: a CPU calcula a pose de cada personagem em cena, todo frame, então osso a mais custa.

Hierarquia de Ossos

A estrutura padrão de um humanoide segue a anatomia: um Root na base, a pelve como pai do tronco, a coluna subindo em alguns segmentos até pescoço e cabeça, os braços saindo dos ombros e as pernas da pelve. Engines como a Unity esperam algo parecido com isso pra mapear no sistema de humanoide e reaproveitar animação entre personagens.

Sobre quantidade de osso: mobile pede o mínimo (junte os dedos num osso só ou dois, corte ossos intermediários), PC indie dá pra usar mais, e AAA usa muito mais com ossos de apoio. A regra que vale em qualquer plataforma é limitar a influência a no máximo 4 ossos por vértice, que é o que a maioria das engines suporta no shader de skinning.

Weight Painting

Weight paint define o quanto cada osso puxa cada vértice. O caminho mais rápido é o automático e depois limpar: parenteia o mesh ao armature com pesos automáticos, limita o número de grupos por vértice e remove os pesos minúsculos que não fazem diferença e só pesam.

import bpy

def auto_weight_cleanup(mesh, armature, max_groups=4):
    bpy.ops.object.select_all(action='DESELECT')
    mesh.select_set(True)
    armature.select_set(True)
    bpy.context.view_layer.objects.active = armature
    # Parent com pesos automáticos
    bpy.ops.object.parent_set(type='ARMATURE_AUTO')

    # Limita a 4 ossos por vértice (limite das engines)
    bpy.context.view_layer.objects.active = mesh
    bpy.ops.object.vertex_group_limit_total(limit=max_groups)
    # Remove pesos irrelevantes
    bpy.ops.object.vertex_group_clean(group_select_mode='ALL', limit=0.01)

# auto_weight_cleanup(mesh_obj, armature_obj)

Pesos automáticos quase nunca saem perfeitos. Eles te dão um ponto de partida; depois você abre o weight paint e corrige as áreas que deformam feio (axila, virilha, cotovelo costumam dar trabalho).

Animação para Jogo

Animação de jogo é diferente de animação de filme em alguns pontos práticos:

• Deixe a engine interpolar. Você não precisa de keyframe em todo frame. Marque as poses-chave e deixe a engine preencher o meio. Menos keyframe, arquivo mais leve, edição mais fácil.
• Loop que fecha. Animações cíclicas (andar, correr, idle) precisam que o primeiro e o último frame coincidam, senão dá um "soluço" visível na repetição. Teste o loop rodando em playback contínuo.
• Root motion ou não. Decida cedo: ou o movimento vem do osso root (e a engine usa esse deslocamento pra mover o personagem), ou a animação anima no lugar e o código controla a posição. Misturar os dois gera deslize de pé (foot sliding).

Na hora de exportar, cada animação vira uma Action separada no Blender. Idle, walk, run, attack, death: cada uma na sua Action, com nome claro, pra a engine importar como clipes distintos.

Pipeline de Export para Engines

Modelo bonito no Blender que chega quebrado no engine não serve. O export é onde mais se perde tempo de quem está começando, então vale entender as opções.

FBX: o Formato Mais Compatível

FBX é o que Unity e Unreal engolem sem reclamar. Os pontos que mais geram problema:

• Escala e orientação. Unity e Unreal têm convenções diferentes de eixo e escala. Pro Unity, exporte com Apply Scalings: FBX Units Scale e eixos -Z Forward / Y Up. A Unreal historicamente quebra a cabeça de todo mundo com escala (importa 100x menor); o jeito mais limpo é ajustar a escala na importação da Unreal em vez de forçar no Blender.
• Aplique as transforms antes. No Blender, com o objeto selecionado, Ctrl+A > All Transforms. Rotação e escala não-aplicadas viajam pro engine e bagunçam tudo.
• Triangule. Ative Triangulate Faces no export (ou adicione um modifier Triangulate). A engine vai triangular de qualquer jeito; fazendo no Blender você controla como, e evita surpresa no sombreamento.
• Só Deform Bones. Em Armatures, marque Only Deform Bones pra não exportar ossos de controle do rig que a engine não precisa.

glTF 2.0: o Caminho pra Godot e Web

glTF é open standard, gera arquivo menor, carrega PBR nativo e é o formato natural pra Godot e pra qualquer coisa que rode no navegador. Exporte como glTF Binary (.glb) pra empacotar mesh, material e textura num arquivo só. Se precisar de geometria comprimida (web, sobretudo), ative a compressão Draco.

Pra Godot, glTF é a recomendação oficial. Importa material, animação e esqueleto de forma mais previsível que FBX.

Export em Lote com Script

Quando você tem dezenas de assets, exportar um por um na mão é perda de tempo. Esse script percorre os meshes da cena e exporta cada um num FBX separado:

import bpy
import os

def batch_export_fbx(export_dir):
    os.makedirs(export_dir, exist_ok=True)

    for obj in bpy.context.scene.objects:
        if obj.type != 'MESH':
            continue

        bpy.ops.object.select_all(action='DESELECT')
        obj.select_set(True)
        bpy.context.view_layer.objects.active = obj

        filepath = os.path.join(export_dir, f"{obj.name}.fbx")
        bpy.ops.export_scene.fbx(
            filepath=filepath,
            use_selection=True,
            apply_scale_options='FBX_SCALE_ALL',
            mesh_smooth_type='FACE',
            use_mesh_modifiers=True,
            add_leaf_bones=False,
        )
        print(f"Exportado: {filepath}")

batch_export_fbx(bpy.path.abspath("//export/"))

bpy.path.abspath("//export/") resolve um caminho relativo ao arquivo .blend salvo, então funciona em qualquer máquina sem hardcodar C:/.... Se o .blend ainda não foi salvo, troque por um caminho absoluto.

Workflow Completo: do Conceito ao Engine

Pra fechar, a ordem que faz sentido num personagem indie pra Unity. Os tempos são só pra dar noção de proporção; o seu vai variar muito com experiência e com o nível de detalhe.

1. Blockout. Comece com primitivas, acerte a escala (personagem em torno de 1.8m) e jogue cedo no engine pra sentir a proporção em movimento. Errar escala agora é barato; errar depois do rig pronto, não.
2. Modelagem. Suba o detalhe em passos: base mesh, detalhamento, e depois corte de volta pro budget que você definiu. Termine com a topologia limpa pra deformação.
3. UV. Costuras escondidas, densidade uniforme, ilhas bem empacotadas. Resolução maior nos personagens importantes, menor nos NPCs de fundo.
4. Texturização. Monte o set PBR (cor base, normal, roughness, metallic, AO). Aqui é onde o asset ganha vida.
5. Rigging. O add-on Rigify (já incluso no Blender) gera um rig humanoide completo. Ajuste pro seu personagem e teste as deformações nas poses extremas.
6. Animação. Comece pelo essencial: idle, walk, run, jump, um ataque, hit e death. Cada uma numa Action separada.
7. Export e integração. Antes de exportar: aplique as transforms, recalcule as normais pra fora, confira os nomes, garanta material e animações nas Actions certas, exporte o FBX e teste a importação no engine. Sempre teste no engine antes de dar como pronto.

Otimização: o Que Rende de Verdade

Algumas técnicas que valem mais que cortar polígono cego:

• Channel packing. Junte mapas de canal único (metallic, roughness, AO) nos canais R, G e B de uma textura só. Três mapas viram um arquivo, economizando memória e draw call. A maioria das engines lê os canais separados sem problema.
• Retopologia onde importa. Pra mesh que deforma, retopo manual ganha do automático. Comece com o modifier Shrinkwrap sobre o high-poly e construa edge loops em cima. Ferramentas externas como o Instant Meshes (gratuito) ajudam num primeiro passe.
• Cuidado com transparência. Transparência é cara em jogo (gera overdraw). Em mobile especialmente, evite onde der; resolva com geometria ou com textura opaca.

Troubleshooting Comum

Os três problemas que todo mundo enfrenta no começo, e a solução:

Objeto gigante ou minúsculo no engine. Quase sempre é transform não-aplicada ou unidade errada. Aplique a escala no Blender (Ctrl+A > Scale), confira as unidades em Metric/1.0, e cheque o ajuste de escala na importação do engine.

Modelo aparece "do avesso" (inside-out). São normais invertidas. Em Edit Mode, selecione tudo e use Mesh > Normals > Recalculate Outside. Pra enxergar o problema, ative o overlay Face Orientation: azul é a frente, vermelho é a face virada pra dentro.

Textura não aparece no engine. Caminho de arquivo quebrado. Empacote as texturas no .blend (File > External Data > Pack Resources), use caminhos relativos, ou exporte com as texturas embutidas. Conferir o caminho resolve a maioria dos casos.

E uma checagem que economiza apuro: um script curto pra varrer a cena e avisar os meshes acima de um limite de triângulos, antes de exportar.

import bpy

def check_poly_count(threshold=10000):
    for obj in bpy.context.scene.objects:
        if obj.type != 'MESH':
            continue
        tris = sum(len(p.vertices) - 2 for p in obj.data.polygons)
        if tris > threshold:
            print(f"ATENÇÃO: {obj.name} tem {tris} triângulos")

check_poly_count()

A conta len(p.vertices) - 2 funciona porque um polígono de N vértices triangula em N-2 triângulos. Roda antes de cada export e você nunca mais manda um asset estourado por engano.

Add-ons que Valem a Pena

Gratuitos, já inclusos ou fáceis de instalar:

• Node Wrangler: atalhos no editor de shader. Liga texturas em segundos.
• LoopTools: helpers de modelagem (circularizar, suavizar, fazer ponte).
• Texel Density Checker: mede e ajusta densidade de texel.

Pagos que muita gente do mercado usa: Hard Ops e BoxCutter (hard surface), UVPackmaster (empacotamento de UV muito melhor que o nativo), MACHIN3tools (um monte de atalho de fluxo). Nenhum é obrigatório pra começar. O Blender puro já entrega asset profissional; os pagos compram velocidade depois que você sabe o que está fazendo.

Por Onde Começar

Se você está zerado, o caminho é esse: aprenda navegação e modelagem básica primeiro, com os modifiers principais. Depois entre no específico de jogo: técnica low-poly, UV unwrapping e texturização básica. Com essa base, parta pra retopologia, fluxo de baking e o básico de animação. Scripting em Python e rigging complexo vêm depois, quando o atrito manual já estiver te incomodando o suficiente pra querer automatizar.

A real é que ninguém aprende Blender lendo. Você aprende fazendo asset ruim, depois um menos ruim, e repetindo. Faça o tutorial clássico do donut pra pegar a interface, e logo em seguida modele um prop de jogo de verdade, do blockout ao export no engine. É a repetição desse ciclo completo, do conceito ao jogo rodando, que vira habilidade. O resto é prática.