Converter STL para GLB

Três situações explicam quase toda esta conversão. Um campo de upload num anúncio, uma plataforma de documentação ou um sistema de conteúdo que nomeia `.glb` porque é isso que o componente visualizador dele carrega. Um colega ou cliente que precisa olhar uma peça e não tem fatiador nem pacote de CAD e não pretende instalar nenhum dos dois. E um recurso de realidade aumentada ou prévia construído em cima de glTF porque foi isso que a web padronizou.

Em nenhum desses casos quem converte está montando uma cena 3D. Quer um arquivo que o outro lado abra, mostrando a forma, ainda hoje. Vale segurar esse enquadramento, porque a maior parte do conselho sobre glTF é escrita para quem está montando cenas e responde perguntas que este leitor não tem.

Um GLB é o mesmo documento glTF com o dado de vértice concatenado atrás dele: um cabeçalho de doze bytes cujos primeiros quatro soletram `glTF`, depois um bloco JSON, depois um bloco binário, cada um preenchido até uma fronteira de quatro bytes. Um arquivo, uma requisição, nada ao lado.

Isso importa contra a alternativa deste site. Converter um STL para `.gltf` também produz um arquivo só, mas ele precisa carregar o dado de vértice como uma URI de dado base64 dentro do JSON, o que custa quatro caracteres para cada três bytes — cerca de trinta e três por cento — com o JSON indentado por cima. O GLB guarda os mesmos bytes diretamente, então é significativamente menor para exatamente a mesma geometria. Se o arquivo vai ser baixado por alguém, esta é a versão a mandar.

Um STL não tem cor, textura, coordenada UV nem cor por vértice, e o conversor escreve uma primitiva com um acessor de posição e um acessor de índice e nenhuma referência a material. O que aparece na tela é produzido inteiramente pelos padrões do visualizador.

É por isso que o mesmo arquivo pode parecer um objeto de engenharia sólido num visualizador e um borrão cinza em outro. A correção é iluminação, não conversão: o `<model-viewer>` traz iluminação de ambiente neutra e um atributo `shadow-intensity`, e acrescentar os dois são dois atributos que transformam o resultado. No three.js, um mapa de ambiente mais uma luz hemisférica fazem o mesmo trabalho. Se a peça de fato precisa de cor, acrescente um material ao glTF depois com o `gltf-transform` — é uma edição pequena a um documento que já está completo no resto.

Esta é a que faz as pessoas acharem que a conversão falhou. Pacotes de CAD e o mundo inteiro de impressão 3D trabalham com Z para cima: a mesa de impressão é o plano XY e a altura é Z. O glTF especifica Y como para cima, e todo visualizador segue isso. Nada na conversão gira nada, porque inventar uma rotação seria chutar qual convenção a origem seguia.

Então uma peça exportada do Fusion, SolidWorks, FreeCAD ou de um fatiador chega no visualizador tombada noventa graus, deitada de costas. Corrija isso na cena, não no arquivo: o `<model-viewer>` aceita um atributo `orientation="-90deg 0 0"`, e o three.js precisa de uma linha ajustando `object.rotation.x`. Fazer isso no visualizador mantém o GLB batendo com o STL, o que importa se a mesma geometria também vai para uma impressora.

Nenhum dos dois formatos declara uma unidade. STL é tratado como milímetro por todo fatiador já escrito; glTF é escrito como se uma unidade fosse um metro. Os números atravessam intocados, então um suporte de 60 mm vira um objeto de sessenta unidades, que um visualizador dimensionado para metro renderiza como um suporte de sessenta metros e enquadra de bem longe.

Divida por 1000 na cena, e confira contra uma dimensão que você consegue verificar, não a olho. O `<model-viewer>` tem um atributo `scale`; o three.js tem `object.scale.setScalar(0.001)`. Se o visualizador parece certo sem escalar, o STL provavelmente não estava em milímetro, o que vale saber antes de mandar para uma impressora.

Um STL guarda cada triângulo como três vértices independentes sem compartilhamento nenhum, então um cubo chega como trinta e seis posições onde oito bastariam. O leitor mescla vértices coincidentes primeiro, comparando com seis casas decimais, porque dois triângulos que se encontram numa borda rotineiramente discordam no último bit de um float.

Para um arquivo de entrega isso não é um detalhe. A forma não soldada colocaria de quatro a seis vezes mais vértices no buffer e portanto no download, e também quebraria a sombra suave, já que um visualizador que faz média de normais precisa de vértices compartilhados para calcular a média. O resultado é um GLB cuja geometria é ao mesmo tempo menor e mais bem comportada do que uma reescrita ingênua produziria.

Tudo encontrado no STL é escrito como uma única malha com uma única primitiva, porque um STL não tem grupos para preservar. Esse é o modelo mais barato possível para um renderizador — uma chamada de desenho, nenhuma troca de material — que é o formato certo para uma peça numa página de produto ou num painel de prévia.

A primitiva usa índices uint32 e posições float32 do início ao fim. Tipos de índice mais estreitos existem e economizariam um pouco num modelo pequeno, mas uma malha que passa de 65.535 vértices precisaria de um tipo diferente em silêncio, uma condição fácil de errar por poucos kilobytes. O acessor de posição carrega `min` e `max` como a especificação exige, o que deixa um visualizador enquadrar o modelo ao carregar, em vez de abrir zoom em nada.

Este é o uso silenciosamente útil. Um colega, um cliente ou um comprador precisa ver uma peça e não tem software para isso — mandar um STL significa explicar o que instalar, e mandar uma captura de tela significa que a pessoa não consegue girar o objeto. Um GLB abre num visualizador baseado em navegador sem instalação nenhuma, e todo celular e computador atual consegue renderizar um através de uma página.

O que mandar junto: as dimensões reais, numa frase, porque o arquivo não carrega elas e o visualizador vai mostrar a escala que você definir. E uma nota sobre orientação se importar. Duas linhas de contexto transformam um objeto cinza flutuando num visualizador numa peça sobre a qual alguém consegue comentar.

Geralmente bem menos. O STL usa cinquenta bytes por triângulo sem compartilhamento nenhum; o GLB guarda cada vértice uma vez em doze bytes e cada índice em quatro, então uma malha cujos vértices são usados por cinco ou seis triângulos cada comprime bastante no sentido geométrico antes de qualquer compressão ser aplicada.

O teto gratuito é de 100 MB, o que dá cerca de dois milhões de triângulos de STL. Bem antes disso, um modelo fica incômodo de carregar num navegador — algumas centenas de milhares de triângulos é um limite superior sensato para algo que um visitante vai abrir no celular. Se o STL é mais denso que isso, decime antes de converter; o `gltf-transform` também consegue aplicar compressão Draco no GLB resultante, mas lembre que um arquivo comprimido com Draco não pode ser convertido de volta neste site.

Nada. A conversão é JavaScript puro nesta aba, sem módulo WebAssembly para baixar, sem envio, sem conta, sem cota diária. A aba de rede durante uma conversão é a checagem.

Esse é o ponto relevante para uma peça sendo preparada para um anúncio ou revisão de cliente, porque o modelo frequentemente ainda não foi lançado e frequentemente é de outra pessoa. Uma conversão que nunca transmite a geometria elimina a questão em vez de responder ela com uma política de privacidade.