OpenSCAD na escola: modelagem 3D por código para regras e agentes

Como referenciar este texto: OpenSCAD na escola: modelagem 3D por código para regras e agentes. Rodrigo Terra. Publicado em: 02/11/2026. Link da postagem: https://www.makerzine.com.br/openscad-na-escola-modelagem-3d-por-codigo-para-regras-e-agentes/.


 
 

OpenSCAD é um ambiente de modelagem 3D controlado por código. Em vez de arrastar e soltar, descrevemos objetos com variáveis, funções e laços. Para quem ensina Ciências e Matemática, isso abre uma porta direta para discutir regras locais, estados e emergências — a base do pensamento em modelos baseados em agentes — enquanto se produz algo concreto, visual e, se quiser, imprimível.

 

Por que vale a pena ensinar OpenSCAD

Transparência e parâmetro caminham juntos: quando um objeto nasce de variáveis e operações, a “receita” fica visível e repetível. Nomes bem escolhidos contam a história do projeto (largura_ponte, espessura_tabuleiro, vao_principal), e pequenos ajustes permitem testar hipóteses sem refazer nada. Trocar vao_principal de 60 para 80 mm e observar o que muda é mais rápido do que reconstruir no mouse. Essa clareza também ajuda os estudantes a justificarem escolhas com números e relações, não só com estética.

OpenSCAD favorece pensar em regras. Funções capturam padrões (“como é um degrau?”), e laços geram populações (“quantos degraus cabem aqui?”). Isso abre a porta para modelos por agentes: cada “peça” segue regras locais simples e o conjunto produz formas ricas. Um exemplo rápido de atividade: espalhar “árvores” em uma praça simulada usando um laço que evita colisões mínimas e varia a altura dentro de limites. Ou montar uma grade de células em que a altura de cada pilar depende do número de vizinhos ocupados — um caminho direto para discutir emergência sem sair do 3D.

No cotidiano de escola, a logística conta. É software livre, funciona offline e roda bem em computadores modestos do laboratório. A entrada é honesta: com meia dúzia de comandos — translate, rotate, cube, sphere, union e difference — a turma já resolve projetos simples e significativos. Para quem já modela no Tinkercad ou Blender, ele complementa: quando a intenção é explicitar a regra, medir o efeito de parâmetros e guardar versões com sentido, o código ajuda a “engenheirar” a ideia.

 

Regras locais em geometria: do agente ao sólido

Comece tratando cada “agente” como um estado (dados) que é convertido em um sólido. Um módulo simples recebe atributos como posição, orientação e tamanho e, dentro dele, aplica translate() e rotate() a uma forma base (um cubo, cilindro ou o que fizer sentido). Essa separação ajuda a trocar a “pele” do agente sem tocar nas regras: o estado decide onde e como, o módulo desenha.

Para ter uma população, use listas de estados e um laço for para instanciar o módulo. Dá para gerar posições com rands(min,max,n,seed): duas listas (xs e ys) e depois combinar em [for (i=[0:n-1]) [xs[i], ys[i], ang]]. Como a semente é fixa, a turma compara cenários idênticos com regras diferentes; trocando a semente, mudam só as posições iniciais. Esse controle é útil para perguntas do tipo “foi a regra ou o acaso?”.

Uma regra local clássica é manter distância mínima. Em OpenSCAD, calcule para cada agente a menor distância aos demais e tome uma decisão simples (por exemplo, reduzir o tamanho quando estiver “apertado” ou deslocar um pouco). Conceitualmente: d_viz = min([norm(p – q) para q em posições, q ≠ p]); tam = d_viz < d_min ? tam_pequeno : tam_normal. Visualmente, já é suficiente para discutir como colisões se resolvem sem coordenador global. Se precisar de deslocamento, aplique um pequeno translate() na direção oposta ao vizinho mais próximo — limitado a alguns passos para não virar simulação contínua.

  • Mantenha populações modestas e formas simples; se ficar lento, reduza $fn das curvas e evite laços aninhados muito grandes.
  • Prefira regras que mudam propriedades baratas de desenhar (tamanho, cor, altura) antes de reposicionar muitos sólidos por vez.
  • Guarde a semente usada no rands() no próprio código para que a turma possa reproduzir exatamente o “fotograma”.

 

Exemplo rápido: enxame paramétrico em 15 linhas

Sobre a aleatoriedade: rands(min, max, n, seed) gera listas de números pseudoaleatórios reprodutíveis. Usar seed, seed+1 e seed+2 para xs, ys e zs evita correlação entre eixos sem perder a possibilidade de “refazer” exatamente o mesmo enxame. Se a turma registrar a semente junto com os parâmetros, consegue comparar resultados de forma justa.

Os parâmetros e as restrições fazem o papel de “regras do mundo”. R define o raio do disco de atuação; r_agent define o tamanho das esferas. A condição if (norm(pos) < R && pos[2] >= r_agent) impõe duas coisas: um limite radial (nada sai do círculo) e uma “altura mínima” para não atravessar a base. Com n fixo, aumentar r_agent não muda a contagem de agentes, mas aumenta a ocupação visual; aumentar R espalha o grupo, deixando lacunas maiores.

  • Anel em vez de disco: acrescente && norm(pos) > R/3 na condição. A turma enxerga como uma regra simples cria uma zona de exclusão central.
  • Inclinação suave: troque a parte da altura por pos[2] >= r_agent + (norm(pos)/5). Perto da borda, a “barreira” sobe, formando um halo menos povoado.
  • Cor por parâmetro: mova color() para dentro do laço e use algo como uma cor que dependa de norm(pos)/R. Isso evidencia a relação entre posição e atributo visual sem mexer na geometria.

Se o modelo ficar pesado, reduza temporariamente $fn nas esferas (menos facetas) para testar ideias rapidamente e só depois volte ao valor mais alto para renderizar bonito.

 

Autômato celular em relevo: quando o estado vira objeto

Vale alinhar a orientação da matriz com o que aparece no tabuleiro. Em OpenSCAD, a origem fica no canto inferior esquerdo e o eixo Y cresce para cima; em papel, costumamos escrever a primeira linha no topo. Se você mandar i direto para Y, a peça sai “de cabeça para baixo”. Simples de resolver: use (rows-1-i) no Y para espelhar a matriz verticalmente e manter o que os alunos veem na grade igual ao que aparece na impressão.

Exemplo compacto com parâmetros úteis para sala de aula: defina cell (tamanho da célula), t (espessura da base), h (altura dos blocos) e margin (moldura). Depois, posicione os blocos só quando a célula for 1 e use (rows-1-i) no Y.

cells = [[0,1,0,0,1],[1,1,0,1,0],[0,1,1,1,0],[0,0,1,0,0],[1,0,0,1,1]]; cell=8; t=1.2; h=2.4; margin=4; rows=len(cells); cols=len(cells[0]); translate([-margin,-margin,0]) color([0.85,0.85,0.85]) cube([cols*cell+2*margin, rows*cell+2*margin, t]); for (i=[0:rows-1]) for (j=[0:cols-1]) if (cells[i][j]==1) translate([j*cell, (rows-1-i)*cell, t]) cube([cell, cell, h]);

  • Para FDM comum, ajuda escolher cell como múltiplo da largura de extrusão (ex.: 8 mm se o bico é 0,4 mm) e definir t e h como múltiplos da altura de camada (ex.: t=1,2 mm, h=2,4 mm com camadas de 0,2 mm). Isso reduz rebarbas e tempo de fatiamento.
  • Uma moldura de 3–5 mm dá rigidez à base e facilita manusear o tabuleiro sem quebrar blocos nas bordas.

Para comparar dois estados lado a lado, crie um pequeno módulo e repita com translate. Rótulos impressos ajudam muito a conversa.

module estado(cells, label, shift=[0,0,0]) { rows=len(cells); cols=len(cells[0]); translate(shift) { /* base e blocos como acima */ linear_extrude(height=0.8) translate([2, -6]) text(label, size=6); } } estado(cellsA, “t0”); estado(cellsB, “t1”, [cols*cell+12, 0, 0]);

  • Deixe um vão de 10–15 mm entre os tabuleiros para o fatiador não unir as bases. Se o texto ficar miúdo, aumente size ou use uma fonte sem serifa para legibilidade.

Se a turma quiser ir além do binário, é possível mapear valores diferentes para alturas e cores (para visualização na tela). A matriz pode vir de uma planilha que gera números inteiros (ex.: “idade” da célula ou número de vizinhos) e você cola esse array no código.

h = heights[i][j]; if (h>0) { color(h>=4 ? [1,0.4,0.2] : h>=2 ? [1,0.8,0.3] : [0.3,0.7,1]) translate([j*cell,(rows-1-i)*cell,t]) cube([cell, cell, h]); }

Na impressão sai tudo em uma cor (a menos que use troca de filamento), mas a visualização colorida no visor do OpenSCAD ajuda a conduzir a discussão antes de fatiar.

 

Do NetLogo/Python ao OpenSCAD: pipeline simples

Dois pontos costumam decidir se o pipeline flui sem tropeços: como tratar escala/origem e como transformar números em uma forma 3D útil. Vale acertar isso no Python, antes de abrir o OpenSCAD.

1) Escala, origem e eixos

Defina qual tamanho físico quer na peça final e ajuste tudo para milímetros. Uma estratégia prática é calcular a caixa mínima dos pontos, centralizar no (0,0,0) e aplicar um único fator de escala. Se o simulador usa eixos com orientação diferente, inverta o sinal do eixo necessário (por exemplo, y = -y) para ter a visualização desejada.

Exemplo mínimo em Python (adapte os nomes das colunas):

# lê points.csv, centraliza e escala
import csv, math
scale = 2.0 # mm por unidade do simulador
xs, ys, zs, P = [], [], [], []
with open(‘points.csv’) as f:
    r = csv.reader(f)
    for row in r:
        vals = [float(v) for v in row][:3]
        while len(vals) < 3: vals.append(0.0) # se vier só x,y
        P.append(vals)
cx = (min(p[0] for p in P) + max(p[0] for p in P))/2
cy = (min(p[1] for p in P) + max(p[1] for p in P))/2
cz = (min(p[2] for p in P) + max(p[2] for p in P))/2
Q = [[(p[0]-cx)*scale, (-(p[1]-cy))*scale, (p[2]-cz)*scale] for p in P] # inverte y se quiser
open(‘points.scad’,’w’,encoding=’utf-8′).write(‘points = ‘ + str(Q) + ‘;\n’)

No OpenSCAD, confira o encaixe na mesa: reduza ou amplie com um scale() global se precisar de um ajuste fino.

2) Do dado bruto à forma 3D: o que cada número vira

Quando houver um atributo interessante (energia, espécie, velocidade), transforme-o em geometria. O mais simples é converter em raio da esfera. Se o CSV não tiver esse atributo, use um valor padrão.

Na conversão, grave também o raio por ponto:

# supondo que a 4ª coluna seja “estado” entre 0 e 1
def map_raio(estado):
    return 1.2 + 2.0*max(0.0,min(1.0,estado)) # mm
R = []
with open(‘points.csv’) as f:
    r = csv.reader(f)
    for row in r:
        xyzw = [float(v) for v in row]
        estado = xyzw[3] if len(xyzw)>3 else 0.5
        R.append(map_raio(estado))
open(‘radii.scad’,’w’,encoding=’utf-8′).write(‘radii = ‘ + str(R) + ‘;\n’)

No OpenSCAD:

include <points.scad>;
include <radii.scad>;
$fn = 16; // resolução moderada para pré-visualizar
for (i = [0:len(points)-1]) translate(points[i]) sphere(r = radii[i]);

Se a simulação for 2D, manter z=0 já produz um “mapa de pontos” imprimível. Para uma leitura mais rica, experimente levar um atributo para o eixo z (ex.: altura proporcional ao valor) e reduzir os raios para evitar colisões.

Observação: cores ajudam na análise em tela (color([r,g,b]) no OpenSCAD), mas geralmente não são preservadas ao exportar STL para fatiadores comuns.

3) Tornando leve e imprimível

  • Teste com amostras: antes de carregar milhares de agentes, exporte só uma fração no Python (ex.: manter 1 a cada 5 linhas) para checar escala e orientação.
  • Reduza a complexidade: use $fn menor (12–16) nas esferas durante o ajuste; aumente só se necessário ao exportar.
  • Limite a densidade: muitos pontos muito próximos viram um bloco sólido difícil de imprimir. Uma filtragem simples que descarta pontos a menos de um certo espaçamento já ajuda.
  • Exportação: quando estiver ok, use Render (F6) no OpenSCAD e exporte STL. No fatiador, confirme dimensões em mm e adote preenchimento e altura de camada compatíveis com os detalhes mais finos do modelo.

 

Prática de sala: tempo, materiais e armadilhas comuns

Organização de aula sem estresse: em 10 minutos, faça uma demonstração enxuta com um único modelo simples (ex.: cilindro com altura e raio parametrizados). Mostre duas coisas apenas: a diferença entre Preview (F5) e Render (F6) e como alterar 1–2 parâmetros para ver o efeito imediato. Depois, em duplas, cada grupo escolhe um parâmetro para variar, testa poucos valores e registra hipóteses e observações em capturas de tela com legendas curtas (o que mudou na regra local e o que apareceu no padrão). Deixe a impressão para 2–3 casos representativos; o restante vira STL/PNG para um portfólio digital. Sem impressora, funciona do mesmo jeito: estados lado a lado contam a história com clareza.

Desempenho e fluidez: 95% do tempo, fique no Preview (F5). Renderize (F6) só quando realmente for exportar STL ou conferir o resultado final. Para esferas e cilindros, mantenha $fn baixo durante a edição (algo como 12–24) e aumente só na versão final. Vale a pena centralizar a “resolução” numa variável (por exemplo, uma variável de qualidade) para trocar o nível de detalhe de todo o modelo de uma vez. Quando o arquivo ficar pesado (muitas cópias, diferenças complexas), comente temporariamente partes que você não está testando naquele momento e substitua formas detalhadas por versões simplificadas; volta tudo no fechamento.

Armadilhas comuns (e como evitar):

  • Esquecer ponto e vírgula: a mensagem de erro costuma apontar a linha seguinte; revise a anterior. Se algo “sumir”, verifique também chaves de abertura/fechamento.
  • Escala fora de controle: adote 1 unidade = 1 mm desde o início. Inclua um “bloco de referência” de 10 × 10 × 1 mm no canto ou use echo para conferir valores no console antes de exportar.
  • Objetos “flutuando”: trate z = 0 como chão. Para impressão, uma base fina de 1–2 mm resolve. Lembre que esferas nascem centradas no (0,0,0); para apoiar no plano, posicione o centro a uma altura igual ao raio.

 

Sobre o autor

Rodrigo Terra

Rodrigo Terra é criador e mantenedor do MakerZine, atuando nas áreas de educação, tecnologia, ciência de dados, inteligência artificial e cultura maker. Desenvolve projetos e conteúdos sobre programação, automação, análise de dados, robótica educacional, computação criativa e metodologias ativas, conectando inovação, aprendizagem e tecnologia no cotidiano educacional. Apaixonado por café, boas conversas e aprendizado contínuo, está sempre explorando novas ideias, ferramentas e possibilidades.

Ver perfil no LinkedIn

Próxima leitura

Continue explorando

Carregando sugestões de leitura...