Gizmos

Gizmos são a camada de visualização e manipulação no mundo do editor. Eles desenham linhas, caixas, esferas e rótulos sobre a Scene View, mostram o que os componentes nativos estão fazendo (frustums de câmera, formatos de luz, limites de colisor) e fornecem um gizmo de transformação (transform gizmo) interativo para mover, rotacionar e redimensionar objetos diretamente na viewport.

Navegando na Scene View

A viewport possui sua própria câmera de visualização livre, independente das câmeras do jogo. Segure o botão direito do mouse para olhar ao redor; enquanto estiver pressionado:

• WASD move, Q/E desce e sobe, Shift acelera.
• A roda do mouse (scroll) avança/recua a câmera a qualquer momento.
• F centraliza a câmera na seleção atual.

O menu Camera ▾ na barra de ferramentas ajusta a sensação de navegação — Move speed (Velocidade de movimento), Look sensitivity (Sensibilidade do olhar) e Zoom speed (Velocidade de zoom - útil quando o avanço da roda do mouse parecer muito agressivo). Suas configurações persistem entre as sessões por meio do armazenamento de configurações (Settings store) do editor.

Selecionando objetos

Clique em um objeto na Scene View para selecioná-lo — as meshes são selecionadas por um ray cast contra os limites reais da mesh, e luzes/câmeras/vazios (empties) são selecionados clicando em seus ícones. Clicar em um espaço vazio limpa a seleção. (Você também pode selecionar a partir da Scene Tree, como anteriormente).

O gizmo de transformação

Selecione um objeto e uma alça colorida aparecerá em sua origem na Scene View. A alça segue a sua câmera em um tamanho constante na tela.

Passe o mouse sobre um eixo para destacá-lo e depois arraste para manipular. Cada arrasto é uma única etapa de desfazer (Ctrl+Z). Os botões de modo ficam na barra de ferramentas da Scene View.

Snapping

Ative o Snap na barra de ferramentas para restringir os arrastos a incrementos fixos — 0.5 unidades para movimentos, 15° para rotações, 0.25 para escala. O snapping arredonda a alteração que você faz, permitindo que você ajuste os valores para uma grade limpa.

Gizmos de componente

Componentes nativos desenham seus próprios visualizadores, filtrados pelo menu Gizmos ▾ na barra de ferramentas:

• Câmeras — um contorno do frustum mais um ícone de câmera. O frustum é desenhado apenas quando essa câmera está selecionada.
• Luzes — luzes direcionais mostram um disco solar e raios paralelos; luzes pontuais (point lights) mostram um esfera de arame em seu alcance; holofotes (spot lights) mostram um cone de arame. A forma é desenhada apenas para a luz selecionada, de modo que uma cena cheia de luzes permaneça legível; cada luz sempre mostra um ícone de lâmpada tingido com sua respectiva cor.
• Colisores — uma caixa de arame ao redor dos limites do colisor.
• Ícones — os ícones de outdoor (billboard) para luzes/câmeras (e tipos personalizados).
• Contorno de seleção — uma caixa laranja ao redor da mesh do objeto selecionado, abraçando os limites reais da mesh. Nós imateriais (luzes, câmeras, empties) não possuem extensão espacial, por isso não recebem contorno — em vez disso, seu ícone e as alças de transformação marcam a seleção.
• Grade — uma grade de solo no plano XZ com eixos centrais mais brilhantes.

Cada tipo pode ser ativado ou desativado de forma independente, permitindo limpar a viewport enquanto mantém as visualizações que lhe interessam.

A API de Gizmos

Os gizmos são gravados em um buffer de comandos de dados puros (engine.Gizmos) — sem dependências de GPU ou GUI — de modo que qualquer componente, incluindo seus próprios scripts, pode gravá-los. Cada forma se decompõe em segmentos de linha coloridos.

const engine = @import("engine");

fn draw(giz: *engine.Gizmos, center: engine.Vector3) void {
    giz.setColor(.green);
    giz.wireSphere(center, 0.5);

    giz.setColor(.yellow);
    giz.arrow(center, center.add(.{ .x = 0, .y = 2, .z = 0 }));

    giz.setColor(engine.Gizmos.Color.rgb(0.2, 0.6, 1.0));
    giz.box(center, .{ .x = 1, .y = 1, .z = 1 });
    giz.label(center, "spawn point");
}

Primitivas disponíveis: line, lineW, ribbon, ray, polyline, arrow, tube, box, wireCube (orientada por matriz), circle, wireSphere, wireCone, frustum e label. setColor, setLineWidth e setMatrix se aplicam a tudo gravado após eles; setMatrix permite desenhar no espaço local de um objeto.

Espessura da linha

As linhas possuem uma espessura em pixels no espaço da tela, carregada por vértice — o renderizador expande cada segmento em um quad voltado para a câmera, de modo que a linha mantém a mesma largura independentemente da distância da câmera. Defina uma largura uniforme com setLineWidth ou varie por ponto final:

giz.setLineWidth(3);                 // 3px para tudo após isso
giz.arrow(a, b);                     // uma seta grossa e fácil de ler

// Um rastro de cometa que afunila até sumir — largura por ponto.
const pts = [_]engine.Vector3{ head, mid, tail };
const widths = [_]f32{ 8, 4, 0 };
giz.ribbon(&pts, &widths);

lineW(a, b, wa, wb) desenha um único segmento afunilando de wa para wb; ribbon(points, widths) encadeia estes em uma faixa de largura variável. As alças de mover/redimensionar do gizmo de transformação usam setLineWidth para que pareçam (e sejam selecionáveis como) barras sólidas em vez de fios de 1px.

Gizmos, ícones e camadas de componente personalizados

As extensões se registram contra um nome de tipo de componente no sistema de gizmo do editor — um desenhador (drawer - grava linhas/rótulos), um ícone de outdoor (billboard) e/ou uma camada (layer) de visibilidade (estilo Unity):

GizmoSystem.registerGizmo("WaypointPath", drawWaypoints);
GizmoSystem.registerIcon("WaypointPath", dvui.entypo.flag);
GizmoSystem.setLayer("WaypointPath", "Navigation");

fn drawWaypoints(giz: *engine.Gizmos, node: *const engine.SceneNode, comp: *const engine.Component) void {
    _ = comp;
    giz.setColor(.cyan);
    giz.wireSphere(node.transform.position, 0.25);
}

Gizmos e ícones personalizados respeitam as alternâncias de visibilidade Custom / Icons junto com os componentes nativos.

Notas

• Os gizmos são renderizados apenas na viewport do editor, nunca no jogo finalizado (shipped).
• Os gizmos de mundo passam por teste de profundidade (depth-tested) contra a cena; as alças de transformação sempre são desenhadas por cima para que permaneçam fáceis de segurar.
• As alças de rotação giram em torno dos eixos globais (world axes); em objetos já rotacionados, o resultado é aplicado ao ângulo de Euler correspondente.

← Toda a documentação Editar esta página