Hasta ahora has escrito medidas a mano: cube([30, 20, 10]). Funciona, pero si tienes que cambiar el ancho, te toca buscar el 30 por todo el archivo. La parametrización resuelve esto: defines las medidas como variables y encapsulas la geometría en módulos reutilizables. Así un mismo diseño se adapta cambiando un puñado de números arriba del archivo.

Variables: el diseño que se recalcula solo

En OpenSCAD declaras una variable con nombre = valor;. Lo habitual es poner todas las variables de configuración al principio:

ancho     = 40;
fondo     = 30;
altura    = 20;
pared     = 2;

difference() {
    cube([ancho, fondo, altura]);
    translate([pared, pared, pared])
        cube([ancho - 2 * pared, fondo - 2 * pared, altura]);
}

Cambia pared = 3; y todas las dimensiones interiores se recalculan solas. Esto es la esencia del diseño paramétrico.

Un detalle importante: en OpenSCAD las variables no son reasignables como en otros lenguajes. El motor no las evalúa de arriba abajo, sino que toma el último valor asignado en cada ámbito. Si escribes x = 1; y más abajo x = 2;, valdrá 2 en todo el archivo (ese “ámbito” es la región donde la variable existe: aquí, el archivo entero). No intentes usar variables como contadores; para repetir, se usan bucles for.

Operaciones y funciones útiles

Puedes calcular valores a partir de otras variables:

diametro = 8;
radio    = diametro / 2;

Y tienes funciones matemáticas (sin, cos, sqrt, max, min, abs) para geometría más elaborada.

Módulos: tus propias piezas

Un módulo es como una función que genera geometría. Se define con module nombre(parámetros) { ... } y se invoca por su nombre. Es la forma de no repetirte.

module agujero(diametro, profundidad) {
    cylinder(h = profundidad, d = diametro, $fn = 40);
}

// uso
translate([10, 10, -1]) agujero(3.2, 12);
translate([30, 10, -1]) agujero(3.2, 12);

Fíjate en que cylinder acepta d (diámetro) además de r (radio); usar el diámetro suele ser más cómodo para tornillos.

Parámetros con valor por defecto

Puedes dar valores por defecto a los parámetros, que se usan si no los pasas:

module espaciador(altura = 5, d_ext = 8, d_int = 3.2) {
    difference() {
        cylinder(h = altura, d = d_ext, $fn = 40);
        translate([0, 0, -1])
            cylinder(h = altura + 2, d = d_int, $fn = 40);
    }
}

espaciador();              // usa los valores por defecto
espaciador(altura = 10);   // solo cambia la altura

Pasar los parámetros por nombre (altura = 10) hace el código mucho más legible que pasarlos por posición.

Repetir con for

Para colocar varias copias se usa for. Combinado con módulos, generas patrones completos con pocas líneas:

module rejilla_agujeros(filas, columnas, paso, d) {
    for (i = [0 : columnas - 1])
        for (j = [0 : filas - 1])
            translate([i * paso, j * paso, -1])
                agujero(d, 12);
}

rejilla_agujeros(3, 4, 10, 3.2);

Organizar proyectos multi-archivo

Cuando un diseño crece, conviene separarlo en archivos. OpenSCAD ofrece dos sentencias para traer código externo:

• use <archivo.scad>: importa los módulos y funciones del archivo, pero no ejecuta su geometría suelta. Es lo que quieres casi siempre.
• include <archivo.scad>: vuelca el archivo entero, incluida su geometría y sus variables, como si pegaras el texto. Útil para archivos de configuración.

Una estructura típica de proyecto:

proyecto/
├── caja.scad          // archivo principal, ensambla todo
├── lib/
│   ├── tornilleria.scad   // módulos: agujero, espaciador, avellanado
│   └── cutouts.scad       // módulos: hueco_usbc, hueco_sma
└── config.scad        // variables de configuración

Y en el principal:

use <lib/tornilleria.scad>
use <lib/cutouts.scad>
include <config.scad>

// aquí ya puedes llamar a espaciador(), hueco_usbc(), etc.
// y usar las variables definidas en config.scad

La diferencia clave: con use la librería aporta herramientas pero no dibuja nada por sí sola; con include heredas también sus variables globales. Para una biblioteca de módulos reutilizables (como la de cutouts que construiremos en el caso práctico), use es la opción correcta.

El panel Customizer

OpenSCAD incluye un Customizer que convierte tus variables en deslizadores y campos editables sin tocar código. Basta con anotarlas con comentarios especiales:

// Ancho de la caja en mm
ancho = 40;   // [20:100]

// Material de impresión
material = "PETG"; // [PLA, PETG, ASA]

Activándolo en View > Customizer, cualquiera puede ajustar la pieza sin saber programar. Es muy útil cuando entregas un diseño a un cliente o a un compañero del taller.

Buenas prácticas

• Pon todas las variables de configuración arriba, agrupadas y comentadas.
• Usa nombres descriptivos (grosor_pared, no g).
• Encapsula la geometría repetida en módulos con parámetros por defecto.
• Separa librerías reutilizables en archivos aparte y trágelas con use.
• Centraliza tolerancias en variables (holgura = 0.2;) para ajustarlas en un solo sitio.

Con variables y módulos tu diseño deja de ser un dibujo fijo y se convierte en una plantilla configurable. Esta mentalidad es justo la que adopta la librería YAPP_Box, que veremos a continuación: una caja entera definida solo a base de parámetros.