Ya sabes crear primitivas en OpenSCAD. El verdadero poder llega cuando las combinas. La geometría constructiva sólida (CSG, Constructive Solid Geometry) consiste en construir piezas complejas a partir de operaciones booleanas (sumar, restar y cruzar volúmenes, igual que con conjuntos) entre sólidos simples. Son cinco operaciones las que vas a usar todo el rato: union, difference, intersection, hull y minkowski.

union: sumar sólidos

union() fusiona varios sólidos en uno solo. Todo lo que esté dentro de las llaves se une.

union() {
    cube([30, 20, 10]);
    translate([15, 10, 10])
        cylinder(h = 15, r = 5, $fn = 60);
}

En realidad, si pones varios sólidos sin envolverlos, OpenSCAD ya los muestra juntos; union() es explícito y necesario cuando esa suma es a su vez operando de otra operación.

difference: restar (la operación estrella)

difference() resta del primer sólido todos los que vienen después. Es la operación que más vas a usar, porque vaciar es la forma de hacer agujeros, cajas huecas y rebajes.

difference() {
    cube([30, 20, 10]);                 // sólido base
    translate([15, 10, -1])             // herramienta de corte
        cylinder(h = 12, r = 4, $fn = 60);
}

Esto perfora un agujero pasante en el cubo. Fíjate en dos detalles prácticos:

• El orden importa: el primer hijo es el material, el resto se quita.
• He desplazado el cilindro a z = -1 y le he dado altura 12 (más que los 10 del cubo). Esto es un truco imprescindible: si el corte coincide exactamente con la cara, OpenSCAD deja una “cara coplanar” que se ve mal en preview y a veces da problemas al exportar. Sobresalir un poco evita esas caras de grosor cero.

Una caja hueca clásica se hace restando un prisma interior:

difference() {
    cube([40, 30, 20]);
    translate([2, 2, 2])
        cube([36, 26, 20]);   // pared de 2 mm, abierta por arriba
}

intersection: lo que es común

intersection() conserva solo el volumen que comparten todos los sólidos. Sirve, por ejemplo, para recortar una pieza dentro de un contorno.

intersection() {
    cube([30, 30, 30], center = true);
    sphere(r = 19, $fn = 60);
}

El resultado es un cubo con las esquinas y aristas redondeadas por la esfera: solo queda lo que está dentro del cubo y dentro de la esfera a la vez.

hull: la envolvente convexa

hull() calcula la envolvente convexa de sus hijos, como si los envolvieras con film transparente tensado. Es la forma más cómoda de hacer formas redondeadas a partir de elementos pequeños.

El uso más típico es una placa con esquinas redondeadas: colocas cuatro cilindros en las esquinas y haces el hull.

module placa_redondeada(ancho, alto, grosor, radio) {
    hull() {
        for (x = [radio, ancho - radio])
            for (y = [radio, alto - radio])
                translate([x, y, 0])
                    cylinder(h = grosor, r = radio, $fn = 40);
    }
}

placa_redondeada(40, 25, 3, 4);

El hull une los cuatro cilindros con superficies rectas, dándote un rectángulo con esquinas perfectamente redondeadas. Es muchísimo más sencillo que dibujar arcos a mano.

minkowski: redondear sólidos en 3D

minkowski() realiza la suma de Minkowski: “barre” un sólido sobre la superficie de otro. En la práctica lo usarás para redondear todas las aristas de una pieza pasándole una esfera pequeña.

minkowski() {
    cube([30, 20, 10]);
    sphere(r = 2, $fn = 30);
}

El cubo resultante crece 2 mm en todas direcciones y todas sus aristas quedan redondeadas con radio 2. Es una herramienta potentísima, pero con dos advertencias:

• Crece la pieza: el sólido aumenta el radio de la esfera en cada dirección. Si quieres mantener la dimensión original, parte de un cubo más pequeño.
• Es lento: minkowski es computacionalmente caro. Mantén $fn bajo en la esfera de barrido y no abuses de él en piezas grandes.

De hecho, la librería YAPP_Box que veremos más adelante usa internamente minkowski para generar cajas con bordes redondeados.

Combinar operaciones: el patrón real

En la práctica anidas estas operaciones. Una pieza típica es un sólido redondeado con hull al que luego le restas agujeros con difference:

difference() {
    // cuerpo redondeado
    hull() {
        for (x = [4, 36])
            for (y = [4, 21])
                translate([x, y, 0])
                    cylinder(h = 6, r = 4, $fn = 40);
    }
    // agujero de montaje
    translate([20, 12.5, -1])
        cylinder(h = 8, r = 1.6, $fn = 30);
}

Resumen de las cinco operaciones

Operación	Qué hace	Uso típico
union()	Suma sólidos	Juntar piezas en una sola
difference()	Resta los hijos del primero	Agujeros, vaciados, rebajes
intersection()	Conserva el volumen común	Recortar dentro de un contorno
hull()	Envolvente convexa	Esquinas redondeadas, formas suaves
minkowski()	Barrido de un sólido sobre otro	Redondear aristas, dar tolerancias

Con estas cinco operaciones y las primitivas del artículo anterior ya tienes el vocabulario completo del modelado CSG. En el siguiente paso veremos cómo encapsular estos patrones en variables y módulos para que tus diseños sean reutilizables y parametrizables.