Inizio

Inizio

Introduzione

OpenSCAD è un software di modellazione 3D basato su codice. A differenza dei programmi di modellazione tradizionali dove si disegna con il mouse, in OpenSCAD si scrivono istruzioni per creare oggetti 3D. Questo approccio è particolarmente utile per creare parti meccaniche precise, oggetti parametrici e modelli che richiedono modifiche frequenti.

1 - Installazione

Sito Ufficiale: https://www.openscad.org

Download Snapshots: https://openscad.org/downloads.html#snapshots

Scarica il file .exe per Windows (o il pacchetto appropriato per il tuo sistema operativo) ed esegui l'installazione seguendo le istruzioni senza modificare le impostazioni predefinite.

2 - Configurazione

Vai su Modifica > Preferenze per accedere alle impostazioni.

2.1 - Vista 3D

Tema: Seleziona "Solarized" per una migliore visibilità dei colori.
Notifiche: Disabilita le notifiche/errori nella viewport per avere una vista pulita durante la modellazione.

2.2 - Editor

Dimensione carattere: Cambia da 12 a 14 per migliorare la leggibilità del codice.

2.3 - Funzionalità

Nessuna modifica richiesta.

2.4 - Stampa 3D

Nessuna modifica richiesta.

2.5 - Avanzate

Resa 3D: Aumenta da 100.000 a 10.000.000 (permette di visualizzare mesh più complesse).
Backend: Seleziona "Manifold (new/fast)" che è il motore geometrico moderno e più performante.
Cache CGAL: Aumenta da 100 a 1000 per migliorare le prestazioni con modelli complessi.
Cache PolySet: Aumenta da 100 a 1000 per lo stesso motivo.

2.6 - Assi

Nessuna modifica.

2.7 - Tasti

Nessuna modifica.

2.8 - Mouse

Navigazione: Cambia da "OpenSCAD" a "Blender" per una navigazione più intuitiva.

2.9 - Dialogs

Nessuna modifica.

3 - Panoramica

3.1 - Scheda Editor

Questa è la finestra principale dove scriverai il tuo codice. È un editor di testo con evidenziazione della sintassi. Tutto il codice che scrivi qui verrà interpretato e visualizzato nella viewport 3D. Puoi aprire più file contemporaneamente e passare da uno all'altro tramite le schede in alto.

3.2 - Scheda Console

La console mostra i messaggi di output del programma, inclusi i risultati del comando echo(). È utile per il debugging e per verificare i valori delle variabili durante lo sviluppo. I messaggi di errore e warning vengono visualizzati qui.

3.3 - Scheda Errors

Questa scheda elenca in modo organizzato tutti gli errori di sintassi o di esecuzione del codice. Ogni errore è cliccabile e ti porta direttamente alla riga di codice che lo ha causato, facilitando il debugging.

3.4 - Scheda Viewport 3D

Questa è l'area di visualizzazione tridimensionale dove puoi vedere il risultato del tuo codice. Puoi ruotare, ingrandire e spostare la vista usando il mouse. La viewport si aggiorna in tempo reale quando premi F5 (preview) o F6 (render).

3.5 - Scheda Customizer

Il Customizer è una funzionalità che crea automaticamente un'interfaccia utente con slider, menu a discesa e caselle di controllo basati sui commenti speciali nel tuo codice. Permette di modificare i parametri del modello senza dover toccare il codice, rendendo il modello accessibile anche a utenti non tecnici.

4 - Tastiera e Mouse

4.1 - Tastiera (Scorciatoie Essenziali)

F5 - Preview: Renderizza velocemente il modello (visualizzazione approssimativa)
F6 - Render: Renderizza il modello con calcoli geometrici completi
F7 - Esporta STL: Salva il modello come file STL per la stampa 3D

4.2 - Mouse (Modalità Blender)

Rotazione: Tasto centrale (scroll) premuto + muovi il mouse
Panoramica: Shift + tasto centrale premuto + muovi il mouse
Zoom: Rotellina del mouse (scroll) o Ctrl + tasto centrale premuto + muovi il mouse
Selezione: Click sinistro (non seleziona oggetti ma posiziona il cursore)

5 - Operatori

5.1 - Matematici

+ Addizione
- Sottrazione
* Moltiplicazione
/ Divisione
% Modulo (resto della divisione)
^ Elevamento a potenza (es: 2^3 = 8)

5.2 - Logici

&& AND logico: vero solo se entrambe le condizioni sono vere
|| OR logico: vero se almeno una delle condizioni è vera
! NOT logico: inverte il valore booleano

5.3 - Confronto

== Uguale a
!= Diverso da
> Maggiore di
< Minore di
>= Maggiore o uguale a
<= Minore o uguale a

5.4 - Operatore Ternario

L'operatore ternario è un modo compatto per scrivere un condizionale:

$fn = $preview ? 32 : 128;

Questa sintassi significa: "se $preview è vero, allora $fn = 32, altrimenti $fn = 128".

$preview è una variabile speciale che è vera quando stai visualizzando in anteprima (F5) e falsa quando fai il render finale (F6). Questo è molto utile per usare una qualità bassa durante la modellazione (più veloce) e alta qualità per l'esportazione finale.

6 - Commenti

I commenti sono parti di codice che OpenSCAD ignora. Sono utili per documentare il codice e spiegare cosa fa.

6.1 - Multilinea

Si usano per commenti più lunghi che si estendono su più righe:

/*
Questo è un commento
che occupa più righe
di codice
*/

6.2 - Singola Riga

Si usano per commenti brevi sulla stessa riga del codice:

// Questo è un commento su una singola riga
cube(10); // Questo è un commento dopo il codice

7 - Variabili

Le variabili in OpenSCAD memorizzano valori che possono essere usati nel codice.

7.1 - Interi

Numeri interi senza parte decimale:

lato = 2;

7.2 - Decimali

Numeri con parte decimale (usa il punto come separatore):

cerchio = 2.5;

7.3 - Stringhe

Sequenze di caratteri racchiuse tra virgolette doppie:

nome = "Luigi";

7.4 - Vettori

Liste di valori racchiusi tra parentesi quadre. Sono usati per coordinate, dimensioni o serie di valori:

size = [30, 50, 10];

Per usare un vettore come parametro:

cube(size = size, center = true);

I singoli elementi del vettore si accedono con l'indice (0-based):

size[0] = 30 (larghezza)
size[1] = 50 (profondità)
size[2] = 10 (altezza)

8 - Costanti

8.1 - undef

undef

significa "non definito". È usato per indicare che una variabile non ha un valore valido. Può essere utile per controllare se un parametro è stato specificato:

x = undef;
if (x == undef) {
    echo("x non è definito");
}

8.2 - PI

PI è una costante predefinita che rappresenta il valore di π (pi greco ≈ 3.14159). È utile per calcoli geometrici:

circle(r = PI); // Crea un cerchio con raggio π

9 - Variabili Speciali

Le variabili speciali iniziano con il simbolo $ e hanno significati specifici in OpenSCAD.

9.1 - $fs (Minimum Size)

Definisce la dimensione minima di un frammento per le curve. Valori più piccoli creano curve più lisce. Default: 2 mm.

$fs = 0.1;
// Curve molto lisce

9.2 - $fa (Minimum Angle)

Definisce l'angolo minimo in gradi tra i frammenti. Valori più piccoli creano curve più lisce. Default: 12 gradi.

$fa = 5;

// Angolo più piccolo = curve più lisce

9.3 - $fn (Number of Fragments)

Definisce il numero di frammenti usati per disegnare un cerchio. Valori più alti creano curve più lisce ma rallentano il rendering.

$fn = 100;

// Cerchio con 100 lati (molto liscio)

9.4 - $children

Questa variabile speciale è usata nei moduli per contare il numero di oggetti figli passati al modulo:

module conta_figli() {
    echo("Numero di figli: ", $children);
    children();
}

conta_figli() {
    cube(5);
    sphere(3);
    cylinder(r = 2, h = 4);
}
// Output: Numero di figli: 3

9.5 - $preview

Come visto nell'operatore ternario, $preview è vera durante l'anteprima (F5) e falsa durante il render finale (F6).

$fn = $preview ? 32 : 128;

10 - Oggetti 2D

10.1 - circle

Crea un cerchio bidimensionale.

Opzioni:

r (raggio): Distanza dal centro al bordo
d (diametro): Distanza da un bordo all'altro (r = d/2)
$fn, $fa, $fs: Controllano la qualità della curva

Esempi:

circle(r = 10);           // Cerchio con raggio 10
circle(d = 20);           // Cerchio con diametro 20
circle(r = 10, $fn = 6);  // Esagono (cerchio con 6 lati)

10.2 - square

Crea un quadrato o rettangolo bidimensionale.

Opzioni:

size (dimensione): Può essere un numero (quadrato) o un vettore [larghezza, altezza]
center (centro): Se vero, il quadrato è centrato sull'origine

Esempi:

square(10);                // Quadrato 10x10
square([20, 10]);          // Rettangolo 20x10
square(10, center = true); // Quadrato centrato

10.3 - polygon (Triangolo)

Crea un poligono specificando i punti.

Opzioni:

points (punti): Lista di coordinate [x, y] che definiscono i vertici

Esempio:

polygon(points = [
    [0, 0],   // Vertice 1
    [10, 0],  // Vertice 2
    [5, 10]   // Vertice 3
]);

10.4 - polygon + path (Quadrato con foro)

Crea un poligono con un foro specificando sia i punti che i percorsi.

Opzioni:

points (punti): Lista di tutte le coordinate
paths (percorsi): Lista di liste di indici che definiscono le forme

Esempio:

polygon(
    points = [
        [0,0],   // 0: Angolo in basso a sinistra
        [10,0],  // 1: Angolo in basso a destra
        [10,10], // 2: Angolo in alto a destra
        [0,10],  // 3: Angolo in alto a sinistra
        [2,2],   // 4: Foro in basso a sinistra
        [8,2],   // 5: Foro in basso a destra
        [8,8],   // 6: Foro in alto a destra
        [2,8]    // 7: Foro in alto a sinistra
    ],
    paths = [
        [0,1,2,3], // Percorso esterno (quadrato)
        [4,5,6,7]  // Percorso interno (foro)
    ]
);

10.5 - text

Crea testo 2D.

Opzioni:

text: La stringa di testo da visualizzare
size: Dimensione del testo
font: Nome del font
halign: Allineamento orizzontale ("left", "center", "right")
valign: Allineamento verticale ("top", "center", "bottom")
spacing: Spaziatura tra caratteri (1 = normale, >1 = più distanziati)
direction: Direzione di scrittura ("ltr", "rtl", "ttb")

Esempio:

text(text = "Ciao", size = 10, font = "Arial", halign = "center");

11 - Estrusioni

11.1 - linear_extrude

Estende un oggetto 2D lungo l'asse Z, creando un oggetto 3D.

Descrizione: Prende una forma 2D e la estrude in linea retta verso l'alto.

Opzioni:

height: Altezza dell'estrusione
center: Se vero, centra l'estrusione sull'asse Z
twist: Angolo di torsione (in gradi) lungo l'altezza
slices: Numero di fette per la torsione
convexity: Aiuta a renderizzare correttamente le forme concave
scale: Scala la forma in alto (può essere un numero o un vettore [x,y])

Esempio:

linear_extrude(height = 20, twist = 360, slices = 50) {
    circle(r = 10);
}
// Crea una spirale 3D (un cerchio estruso con torsione)

11.2 - rotate_extrude

Ruota un oggetto 2D attorno all'asse Y, creando un oggetto 3D.

Descrizione: Prende una forma 2D e la ruota attorno all'asse Y (o Z con opzione axis), creando un oggetto di rivoluzione.

Opzioni:

angle: Angolo di rotazione (default: 360)
convexity: Aiuta a renderizzare correttamente le forme
axis: Asse di rotazione ("Y" o "Z")
$fn, $fa, $fs: Controllano la qualità

Esempio:

rotate_extrude(angle = 180) {
    translate([10, 0, 0])
        square([5, 5]);
}
// Crea un quarto di anello

12 - Oggetti 3D

12.1 - cube

Crea un cubo o parallelepipedo.

Opzioni:

size: Dimensione singola (cubo) o vettore [x, y, z] (parallelepipedo)
center: Se vero, centra l'oggetto sull'origine

Esempi:

cube(10);                        // Cubo 10x10x10
cube([20, 10, 5]);               // Parallelepipedo
cube(10, center = true);         // Cubo centrato

12.2 - sphere

Crea una sfera.

Opzioni:

r: Raggio della sfera
d: Diametro della sfera
$fn, $fa, $fs: Controllano la qualità

Esempi:

sphere(r = 10);                  // Sfera di raggio 10
sphere(d = 20);                  // Sfera di diametro 20
sphere(r = 10, $fn = 20);        // Icosaedro (sfera approssimata)

12.3 - cylinder

Crea un cilindro.

Opzioni:

h: Altezza
r: Raggio (singolo per cilindro dritto)
r1: Raggio inferiore
r2: Raggio superiore (per tronco di cono)
d: Diametro
d1: Diametro inferiore
d2: Diametro superiore
center: Se vero, centra sull'asse Z
$fn, $fa, $fs: Controllano la qualità

Esempi:

cylinder(h = 10, r = 5);                  // Cilindro
cylinder(h = 10, r1 = 5, r2 = 2);         // Tronco di cono
cylinder(h = 10, r = 5, center = true);   // Cilindro centrato

12.4 - polyhedron

Crea un poliedro 3D definito da punti e facce.

Opzioni:

points: Lista di coordinate [x, y, z]
faces: Lista di poligoni (liste di indici di punti)
convexity: Aiuta a renderizzare correttamente

Esempio:

polyhedron(
    points = [
        [10,0,0],   // 0
        [0,10,0],   // 1
        [-10,0,0],  // 2
        [0,-10,0],  // 3
        [0,0,10]    // 4
    ],
    faces = [
        [0,1,4],    // Faccia 1
        [1,2,4],    // Faccia 2
        [2,3,4],    // Faccia 3
        [3,0,4],    // Faccia 4
        [0,3,2,1]   // Base
    ]
);
// Crea una piramide a base quadrata

13 - Trasformazioni

13.1 - translate

Sposta un oggetto nelle coordinate specificate.

Opzioni:

Vettore [x, y, z] per specificare lo spostamento

Esempio:

translate([10, 0, 0])
    cube(5);
// Cubo spostato di 10 unità sull'asse X

13.2 - rotate

Ruota un oggetto attorno agli assi.

Opzioni:

Vettore [x, y, z] in gradi per specificare la rotazione attorno a ciascun asse

Esempio:

rotate([0, 0, 45])
    cube([10, 2, 2]);
// Barra ruotata di 45 gradi attorno a Z

13.3 - scale

Ridimensiona un oggetto.

Opzioni:

Un numero singolo (scala uniforme) o vettore [x, y, z]

Esempio:

scale([2, 1, 1])
    sphere(5);
// Sfera allungata sull'asse X

13.4 - mirror

Riflette un oggetto specularmente.

Opzioni:

Vettore [x, y, z] per specificare il piano di riflessione

Esempio:

mirror([1, 0, 0])
    cube(5);
// Cubo specchiato sul piano YZ

13.5 - resize

Ridimensiona forzatamente un oggetto alle dimensioni specificate.

Opzioni:

Vettore [x, y, z] per le dimensioni target
auto: Se vero, mantiene le proporzioni

Esempio:

resize([20, 10, 5])
    sphere(10);
// Sfera deformata per adattarsi alla scatola 20x10x5

13.6 - offset

Sposta i bordi di un oggetto 2D verso l'esterno o l'interno.

Opzioni:

r: Raggio di offset
delta: Distanza di offset (per angoli vivi)
chamfer: Se vero, crea smussi invece di arrotondamenti

Esempio:

offset(r = 1)
    square(10);
// Quadrato 10x10 con angoli arrotondati (esterno)

13.7 - offset con chamfer

Crea smussi sugli angoli invece di arrotondamenti.

Opzioni:

delta: Distanza dell'offset
chamfer: Impostato a vero per creare smussi

Esempio:

offset(delta = 1, chamfer = true)
    square(10);
// Quadrato 10x10 con angoli smussati (esterno)

13.8 - projection

Proietta un oggetto 3D su un piano 2D.

Opzioni:

cut: Se vero, fa un taglio, altrimenti proietta come ombra
convexity: Aiuta a renderizzare correttamente

Esempio:

projection(cut = false) {
    cylinder(h = 10, r = 5);
}
// Proiezione 2D del cilindro (cerchio)

14 - Trasformazioni Avanzate

14.1 - hull

Crea lo scafo convesso di un insieme di oggetti (il guscio più piccolo che li contiene tutti). È come avvolgere gli oggetti in un foglio di plastica trasparente.

Esempio:

hull() {
    translate([-10, 0, 0])
        sphere(5);
    translate([10, 0, 0])
        sphere(5);
}
// Crea una forma a capsula che avvolge due sfere

14.2 - minkowski

Esegue l'operazione di Minkowski sum, che "gonfia" un oggetto con un altro. È usata per arrotondare gli spigoli o creare offset 3D.

Esempio:

minkowski() {
    cube([20, 10, 5]);
    sphere(1);
}
// Cubo con angoli arrotondati (raggio 1)

15 - Operazioni Booleane (CSG)

CSG significa Constructive Solid Geometry (Geometria Solida Costruttiva). Permette di combinare oggetti 3D con operazioni logiche.

15.1 - union

Unisce due o più oggetti in uno solo. È l'operazione predefinita quando gli oggetti sono semplicemente uno dopo l'altro.

Esempio:

union() {
    cube([10, 10, 5]);
    translate([5, 5, 0])
        cylinder(h = 10, r = 3);
}
// Cubo con cilindro al centro

15.2 - difference

Sottrae il secondo oggetto dal primo (e così via). L'ordine è importante: il primo oggetto è quello da cui si sottrae.

Esempio:

difference() {
    cube([20, 20, 10]);        // Oggetto principale
    translate([10, 10, 0])
        cylinder(h = 15, r = 5); // Foro passante
}
// Cubo con un foro centrale

15.3 - intersection

Mantiene solo la parte comune tra due o più oggetti.

Esempio:

intersection() {
    sphere(10);
    translate([5, 0, 0])
        cube([15, 15, 15]);
}
// La parte della sfera che si sovrappone al cubo

16 - Cicli

16.1 - for (Struttura base)

Itera su un intervallo di valori, eseguendo il codice per ciascuno.

Esempio:

for (i = [0 : 10]) {
    translate([i * 10, 0, 0])
        cube([5, 5, 5]);
}
// Crea 11 cubi in fila

16.2 - Griglia 3x3

Crea una griglia di oggetti usando due cicli annidati.

Esempio:

for (x = [0 : 2]) {
    for (y = [0 : 2]) {
        translate([x * 15, y * 15, 0])
            cube([10, 10, 10]);
    }
}
// Crea una griglia 3x3 di cubi

16.3 - Cerchio di cilindri

Posiziona oggetti in un cerchio usando funzioni trigonometriche.

Esempio:

for (i = [0 : 11]) {
    angolo = i * 30;
    translate([cos(angolo) * 20, sin(angolo) * 20, 0])
        cylinder(h = 10, r = 3);
}
// Crea 12 cilindri disposti in cerchio

16.4 - intersection_for

Calcola l'intersezione di tutte le istanze iterate. Utile per creare forme simmetriche.

Esempio:

intersection_for(n = [1 : 6]) {
    rotate([0, 0, n * 60]) {
        translate([10, 0, 0]) {
            sphere(r = 15);
        }
    }
}
// Crea l'intersezione di 6 sfere disposte in cerchio
// (risultato: un fiore a 6 petali)

17 - Colori

OpenSCAD supporta l'assegnazione di colori agli oggetti usando il comando color(). I colori più comuni sono:

Colori con nome:

"red" (rosso), "blue" (blu), "green" (verde)
"yellow" (giallo), "orange" (arancione), "purple" (viola)
"pink" (rosa), "brown" (marrone), "gray" / "grey" (grigio)
"black" (nero), "white" (bianco)

17.1 - Colore con nome

color("red") cube(10);

17.2 - Colore RGB

Usa valori da 0 a 1 per rosso, verde e blu:

color([1, 0, 0]) cube(10); // Rosso

17.3 - Colore RGBA

Aggiunge la trasparenza (A = alpha, 0 = trasparente, 1 = opaco):

color([1, 0, 0, 0.5]) cube(10); // Rosso semitrasparente

18 - Modificatori

I modificatori sono caratteri speciali che cambiano il comportamento degli oggetti per facilitare il debugging.

* (Disabilita): L'oggetto viene ignorato completamente.

  *cube(10); // Questo cubo non viene renderizzato

! (Mostra solo): Isola l'oggetto, nascondendo tutti gli altri.

  !cube(10); // Viene mostrato solo questo cubo

#(Evidenzia): L'oggetto viene evidenziato in arancione trasparente per il debugging.

  #cube(10); // Cubo evidenziato

% (Trasparente): L'oggetto viene renderizzato trasparente.

  %cube(10); // Cubo trasparente

Questi modificatori sono estremamente utili durante il debugging di modelli complessi, specialmente con operazioni difference() dove è difficile vedere cosa viene sottratto.

19 - Prendere Decisioni

OpenSCAD supporta strutture condizionali per prendere decisioni in base ai valori delle variabili.

19.1 - if

Esegue il codice solo se la condizione è vera.

x = 10;
if (x > 10) {
    echo("x è maggiore di 10");
}

19.2 - else if

Permette di verificare condizioni multiple.

if (x > 10) {
    echo("x è maggiore di 10");
} else if (x == 10) {
    echo("x è uguale a 10");
}

19.3 - else e controllo tipo

Puoi verificare il tipo di una variabile usando funzioni is_*:

x = "testo";
if (is_num(x)) {
    echo("x è un numero");
} else {
    echo("x non è un numero");
}

Funzioni is_* disponibili:

is_num(x): vero se x è un numero
is_bool(x): vero se x è booleano
is_string(x): vero se x è una stringa
is_list(x): vero se x è una lista/vettore
is_undef(x): vero se x non è definito

20 - Moduli

I moduli sono come "timbrini" o "mattoncini" che puoi riutilizzare. Definiscono un oggetto o un gruppo di oggetti che possono essere richiamati con parametri diversi.

20.0 - Struttura di base

module nome_modulo(parametro1, parametro2) {
    // Corpo del modulo
    // Codice che definisce l'oggetto
}

// Richiamo del modulo
nome_modulo(valore1, valore2);

20.1 - Rounded Box

Crea un cubo con angoli arrotondati.

module rounded_box(x, y, z, raggio) {
    minkowski() {
        cube([x - 2*raggio, y - 2*raggio, z - 2*raggio]);
        sphere(raggio);
    }
}

rounded_box(30, 20, 10, 2);

20.2 - Rounded Cylinder

Crea un cilindro con bordi arrotondati.

module rounded_cylinder(h, r, raggio) {
    minkowski() {
        cylinder(h = h - 2*raggio, r = r - raggio);
        sphere(raggio);
    }
}

rounded_cylinder(20, 10, 2);

21 - Funzioni

Le funzioni in OpenSCAD restituiscono un valore calcolato. A differenza dei moduli che creano oggetti, le funzioni calcolano numeri o valori.

21.1.1 - Funzioni Matematiche (Generiche)

abs(x): Valore assoluto di x
ceil(x): Arrotonda x all'intero superiore
floor(x): Arrotonda x all'intero inferiore
round(x): Arrotonda x all'intero più vicino
sign(x): Restituisce -1 se x < 0, 1 se x > 0, 0 se x = 0
sqrt(x): Radice quadrata di x
min(x, y): Il minore tra x e y
max(x, y): Il maggiore tra x e y

21.1.2 - Funzioni Trigonometriche

sin(angolo): Seno dell'angolo in gradi
cos(angolo): Coseno dell'angolo in gradi
tan(angolo): Tangente dell'angolo in gradi
asin(x): Arcoseno (restituisce gradi)
acos(x): Arcocoseno (restituisce gradi)
atan(x): Arcotangente (restituisce gradi)
atan2(y, x): Arcotangente con quadrante (restituisce gradi)

21.1.3 - Funzioni Aritmetiche di Base

pow(x, y): x elevato a y
exp(x): e elevato a x
ln(x): Logaritmo naturale di x
log(x): Logaritmo in base 10 di x
log2(x): Logaritmo in base 2 di x
PI: Costante π

21.1.4 - Funzioni Esponenziali e Logaritmiche

pow(base, esponente): Potenza
exp(x): e^x
ln(x): Logaritmo naturale
log10(x): Logaritmo in base 10

21.1.5 - Funzioni Vettoriali e Casuali

len(lista): Lunghezza di una lista
rnd(min, max): Numero casuale tra min e max
norm(vettore): Norma (lunghezza) di un vettore
cross(v1, v2): Prodotto vettoriale di due vettori
dist(p1, p2): Distanza tra due punti

21.1.6 - Funzioni di Tipo (is_*)

is_undef(x): Vero se x non è definito
is_num(x): Vero se x è un numero
is_bool(x): Vero se x è booleano
is_string(x): Vero se x è una stringa
is_list(x): Vero se x è una lista/vettore
is_function(x): Vero se x è una funzione

21.2 - Esempio: Cuore Matematico

Questo esempio dimostra come usare funzioni matematiche per creare una forma complessa:

// --- PARAMETRI ---
altezza = 10;        // Spessore dell'estrusione 3D
passo = 5;           // Risoluzione della curva (più è piccolo, più è fluido)
scala = 2;           // Scala la dimensione del cuore

// --- FUNZIONI MATEMATICHE ---
// Equazione parametrica per la X
function heart_x(t) = 16 * pow(sin(t), 3);

// Equazione parametrica per la Y
function heart_y(t) = 13 * cos(t) - 5 * cos(2*t) - 2 * cos(3*t) - cos(4*t);

// --- GENERAZIONE DELL'OGGETTO ---
// Estrusione lineare per creare spessore 3D
linear_extrude(height = altezza, center = true, convexity = 10) {
    // Costruzione del profilo 2D matematico
    scale([scala, scala]) {
        polygon(points = [
            for (t = [0 : passo : 360]) 
                [ heart_x(t), heart_y(t) ]
        ]);
    }
}

22 - Inclusioni di File SCAD

OpenSCAD permette di includere codice da altri file per organizzare progetti più grandi e riutilizzare librerie.

22.1 - use

use importa solo i moduli e le funzioni da un file, ignorando qualsiasi geometria che viene creata direttamente nel file incluso.

use <nomefile.scad>

22.2 - include

include importa tutto il contenuto di un file, inclusa la geometria e le variabili.

include <nomefile.scad>

22.3 - use vs include

`use`	`include`
Importa solo moduli e funzioni	Importa tutto il file
Ignora la geometria globale	Include tutta la geometria
Le variabili non vengono importate	Le variabili vengono importate
Non crea duplicati di geometria	Può creare duplicati di geometria
Ideale per librerie	Ideale per parti di modelli

Esempio:

// Se hai il file "luigiamorfini.scad" con dei moduli
use <luigiamorfini.scad>   // Solo moduli e funzioni
include <luigiamorfini.scad> // Tutto il contenuto

23 - Scheda "Console Log"

La Console Log mostra l'output dei comandi echo() e str() che sono strumenti di debugging essenziali.

23.1 - echo / str

echo() stampa valori nella console, mentre str() concatena stringhe.

23.1.1 - Conversioni di Tipi

OpenSCAD converte automaticamente i numeri in stringhe quando usati in echo().

echo("Il valore è: ", 42); // Output: Il valore è: 42

23.1.2 - Concatenazioni

str() è utile per costruire stringhe complesse.

echo(str("Questa è una stringa ", "concatenata"));

23.1.3 - Valori Multipli

Puoi passare più valori a echo().

a = 5;
b = 10;
echo("Valori:", a, b); // Output: Valori: 5 10

23.1.4 - Operazioni

Puoi fare calcoli direttamente in echo().

echo(5 + 3 * 2); // Output: 11

24 - File SVG

OpenSCAD può importare file SVG (Scalable Vector Graphics) per usarli come profili 2D.

Consigliato il software:

https://www.inkscape.org

24.1 - import

Importa un file SVG come oggetto 2D.

import("nomefile.svg", center = true);

24.1.1 - Layer

Se il file SVG ha più layer, puoi selezionarli.

import("nomefile.svg", layer = "nome_layer");`

24.2 - linear_extrude con SVG

Usa un profilo SVG per creare un oggetto 3D.

Descrizione: Importa un file SVG, lo usa come profilo 2D e lo estrude in 3D.

Esempio:

linear_extrude(height = 10) {
    import("logo.svg", center = true);
}
// Crea un logo 3D estruso da un file SVG

24.3 - rotate_extrude con SVG

Ruota un profilo SVG attorno a un asse.

Descrizione: Importa un profilo SVG e lo ruota attorno all'asse per creare un oggetto di rivoluzione.

Esempio:

rotate_extrude(angle = 360) {
    import("profilo_svg.svg", center = false);
}
// Crea un oggetto di rivoluzione da un profilo SVG

25 - File DXF

I file DXF (Drawing Exchange Format) sono un formato CAD 2D compatibile con molti software.

25.1 - import

Importa un file DXF come oggetto 2D.

Consigliato il software:

https://librecad.org/

import("nomefile.dxf", center = true);

25.1.1 - Layer

Se il file DXF ha più layer, puoi selezionarli.

import("nomefile.dxf", layer = "nome_layer");

25.2 - linear_extrude con DXF

Usa un profilo DXF per creare un oggetto 3D.

Descrizione: Importa un file DXF, lo usa come profilo 2D e lo estrude in 3D. I file DXF sono particolarmente utili per forme tecniche precise.

Esempio:

linear_extrude(height = 10) {
    import("ingranaggio.dxf", center = true);
}
// Crea un ingranaggio 3D da un profilo DXF 2D

25.3 - rotate_extrude con DXF

Ruota un profilo DXF attorno a un asse.

Descrizione: Importa un profilo DXF e lo ruota attorno all'asse per creare un oggetto di rivoluzione.

Esempio:

rotate_extrude(angle = 360) {
    import("profilo.dxf", center = false);
}
// Crea un oggetto di rivoluzione da un profilo DXF

26 - Surface

26.1 - PNG

Importa un'immagine PNG in scala di grigi come superficie 3D. I pixel bianchi diventano alti, quelli neri bassi.

surface("immagine.png", invert = false, center = true);

26.2 - TXT

Importa un file di testo che contiene una matrice di numeri che definisce un'altezza per ogni punto.

File dati.txt:

10 20 30
20 30 40
30 40 50

Codice:

surface(file = "dati.txt", center = true);

Descrizione: surface() crea una superficie 3D basata su una griglia di valori di altezza. Ogni riga del file rappresenta una riga della griglia, e i numeri rappresentano le altezze. È utile per creare terreni, texture o forme organiche.

Esempio con dati.txt:

surface(file = "dati.txt", center = true, convexity = 5);

27 - File STL

27.1 - import

Importa un file STL (Standard Triangle Language), il formato standard per la stampa 3D.

import("modello.stl", convexity = 10);

27.2 - STL - Esportazione

Processo per esportare un modello in formato STL:

Crea il modello: cube(20, center = true);
Premi F5 per l'anteprima
Premi F6 per il render finale
Premi F7 (o File > Esporta > Esporta come STL) per salvare il file

27.3 - Modifica File STL

Puoi importare un file STL e modificarlo con operazioni booleane.

Esempio:

difference() {
    // Importa il modello esistente
    import("box.stl", convexity = 10);
    
    // Sottrae un cilindro per creare un foro
    translate([0, 0, -1])
        cylinder(h = 22, r = 5, center = true);
}
// Modifica il file box.stl aggiungendo un foro

Questo è utile per personalizzare modelli STL esistenti senza doverli ricreare da zero.

28 - Customizer

Il Customizer crea un'interfaccia utente per modificare i parametri del modello senza toccare il codice.

28.1 - Tipi di Controlli

Slider base con valori interi

my_var = 20; // [10:100] 

// Slider da 10 a 100

Slider con passo decimale

my_var = 1.5; // [0.5:0.1:5.0] 

// Slider da 0.5 a 5.0 con passo 0.1

Menu a discesa numerico

my_var = 4; // [2, 4, 6, 8] 

// Menu con valori 2, 4, 6, 8

Menu a discesa di testo

my_var = "smussato"; // [smussato, arrotondato, dritto]` 

//  Menu con opzioni di testo

Menu con etichette descrittive

my_var = 64; // [32:Bassa qualita, 64:Media qualita, 128:Alta qualita]

// Menu con etichette

Schede di Navigazione / Tabs

Usa commenti con /* [] */ per creare gruppi di parametri:

/* [Dimensioni Principali] */
my_var_x = 80;
my_var_y = 40;

/* [Opzioni Coperchio] */
my_var = 1.2;

Variabili Nascoste / Hidden

Usa /* [Hidden] */ per nascondere variabili che non devono apparire nel Customizer:

/* [Hidden] */
versione_modello = "v1.2"; // Mantenuta nel codice solo come info interna

28.2 - Esempio Completo: Cubo Forato

/* [Dimensioni del Cubo] */

// Larghezza del cubo (asse X) in mm
lunghezza_cubo = 40; // [10:1:100]

// Profondità del cubo (asse Y) in mm
larghezza_cubo = 40; // [10:1:100]

// Altezza del cubo (asse Z) in mm
altezza_cubo = 30; // [10:1:100]


/* [Proprietà del Foro] */

// Vuoi includere il foro passante nel cubo?
attiva_foro = true;

// Diametro del foro centrale
diametro_foro = 15; // [2:0.5:50]

// Qualità geometrica del cilindro (numero di facce)
risoluzione_foro = 64; // [16:Bassa, 32:Media, 64:Alta, 128:Massima]


/* [Hidden] */
// === VARIABILI E INFORMAZIONI NASCOSTE ALL'UTENTE ===
versione_modello = "v1.2";

raggio_foro = diametro_foro / 2;
margine_sicurezza = 2;


// --- CODICE 3D DEL MODELLO ---

difference() {
    // Generiamo il cubo principale
    translate([-lunghezza_cubo/2, -larghezza_cubo/2, 0])
        cube([lunghezza_cubo, larghezza_cubo, altezza_cubo]);
    
    // Se attiva_foro è true, sottraiamo il cilindro
    if (attiva_foro == true) {
        translate([0, 0, -margine_sicurezza / 2])
            cylinder(
                h = altezza_cubo + margine_sicurezza, 
                r = raggio_foro, 
                $fn = risoluzione_foro
            );
    }
}

29 - Installare Librerie (BOSL2)

BOSL2 (Belfry OpenSCAD Library v2) è una potente libreria che estende le funzionalità di OpenSCAD con moduli e funzioni avanzate.

Link diretto: https://github.com/BelfrySCAD/BOSL2/archive/refs/heads/master.zip

29.1 - Metodo ZIP

Vai su File > Show Library Folder per aprire la cartella delle librerie
Scarica il file ZIP dall'URL sopra
Estrai il contenuto nella cartella delle librerie
Rinomina la cartella da "BOSL2-master" a "BOSL2"

Struttura risultante: Documenti\OpenSCAD\libraries\BOSL2\

29.2 - Esempio BOSL2: Cubo Forato

Questo esempio usa BOSL2 per creare lo stesso cubo forato dell'esempio precedente, ma con sintassi più pulita:

// Includiamo la libreria standard di BOSL2
include <BOSL2/std.scad>

/* [Dimensioni del Cubo] */

// Larghezza del cubo (asse X) in mm
lunghezza_cubo = 40; // [10:1:100]

// Profondità del cubo (asse Y) in mm
larghezza_cubo = 40; // [10:1:100]

// Altezza del cubo (asse Z) in mm
altezza_cubo = 30; // [10:1:100]


/* [Proprietà del Foro] */

// Vuoi includere il foro passante nel cubo?
attiva_foro = true;

// Diametro del foro centrale
diametro_foro = 15; // [2:0.5:50]


/* [Hidden] */
versione_modello = "v1.2";
risoluzione_foro = 64;


// --- CODICE 3D CON METODO BOSL2 ---

// Il comando diff() intercetta i tag figlio e applica la sottrazione automatica
diff("foro_centrale") 
    // Generiamo il cuboide semplice senza parametri di arrotondamento
    cuboid([lunghezza_cubo, larghezza_cubo, altezza_cubo]) {
        
        // Se l'utente attiva il foro, creiamo il cilindro con il tag di taglio
        if (attiva_foro == true) {
            tag("foro_centrale") 
                cyl(
                    l = altezza_cubo + 1, // +1 garantisce un taglio pulito
                    d = diametro_foro, 
                    $fn = risoluzione_foro
                );
        }
    }

Vantaggi di BOSL2:

Sintassi più pulita e leggibile
Funzioni avanzate per arrotondamenti e smussi
Moduli predefiniti per forme comuni
Sistema di tagging per operazioni booleane più intuitive
Animazioni e funzioni matematiche avanzate

Conclusione

OpenSCAD è uno strumento potente per la modellazione 3D parametrica. La curva di apprendimento iniziale può sembrare ripida, ma la logica basata su codice offre un controllo preciso e riproducibile sui modelli.

Prossimi passi per continuare a imparare:

Sperimenta con gli esempi forniti, modificando i parametri
Crea piccoli progetti come portalampade, ingranaggi o supporti
Esplora la documentazione ufficiale per funzioni più avanzate
Unisciti alla comunità OpenSCAD per condividere e imparare

Ricorda: l'apprendimento migliore avviene facendo. Inizia con progetti semplici e gradualmente aumenta la complessità. Buona modellazione!

Appunti

Inizio

Introduzione

1 - Installazione

2 - Configurazione

2.1 - Vista 3D

2.2 - Editor

2.3 - Funzionalità

2.4 - Stampa 3D

2.5 - Avanzate

2.6 - Assi

2.7 - Tasti

2.8 - Mouse

2.9 - Dialogs

3 - Panoramica

3.1 - Scheda Editor

3.2 - Scheda Console

3.3 - Scheda Errors

3.4 - Scheda Viewport 3D

3.5 - Scheda Customizer

4 - Tastiera e Mouse

4.1 - Tastiera (Scorciatoie Essenziali)

4.2 - Mouse (Modalità Blender)

5 - Operatori

5.1 - Matematici

5.2 - Logici

5.3 - Confronto

5.4 - Operatore Ternario

6 - Commenti

6.1 - Multilinea

6.2 - Singola Riga

7 - Variabili

7.1 - Interi

7.2 - Decimali

7.3 - Stringhe

7.4 - Vettori

8 - Costanti

8.1 - undef

8.2 - PI

9 - Variabili Speciali

9.1 - $fs (Minimum Size)

9.2 - $fa (Minimum Angle)

9.3 - $fn (Number of Fragments)

9.4 - $children

9.5 - $preview

10 - Oggetti 2D

10.1 - circle

10.2 - square

10.3 - polygon (Triangolo)

10.4 - polygon + path (Quadrato con foro)

10.5 - text

11 - Estrusioni

11.1 - linear_extrude

11.2 - rotate_extrude

12 - Oggetti 3D

12.1 - cube

12.2 - sphere

12.3 - cylinder

12.4 - polyhedron

13 - Trasformazioni

13.1 - translate

13.2 - rotate

13.3 - scale

13.4 - mirror

13.5 - resize

13.6 - offset

13.7 - offset con chamfer

13.8 - projection

14 - Trasformazioni Avanzate

14.1 - hull

14.2 - minkowski

15 - Operazioni Booleane (CSG)

15.1 - union

15.2 - difference

15.3 - intersection

16 - Cicli

16.1 - for (Struttura base)

16.2 - Griglia 3x3

16.3 - Cerchio di cilindri

16.4 - intersection_for