Maker & DIY

Akademie

Maker & DIY

Selbermachen und Tüfteln: Dinge entwerfen, bauen und ausprobieren – hier mit 3D-Modellierung in OpenSCAD.

2D-Formen: square, circle, polygon

Begriffe vorab

2D-Objekt: Flache Form in der xy-Ebene, die erst durch Extrusion zum Körper wird.
Polygon: Vieleck aus Punkten und Pfaden.
Pfad (path): Reihenfolge der Punkte, die einen Umriss bilden.
Konvexität: Maximale Zahl von Vorderseiten, die ein Strahl durchdringen kann.
Reguläres Vieleck: Vieleck mit gleichen Seiten, z. B. per circle mit kleinem $fn.

Warum 2D?

Viele Bauteile sind Profile mit Tiefe. Man zeichnet erst die Form in 2D und extrudiert sie dann zum Körper (siehe Extrusionslektion). 2D-Objekte liegen in der xy-Ebene und lassen sich wie 3D-Körper transformieren und mit union, difference und intersection verknüpfen.

square()

square(size, center): size ist eine Zahl (Quadrat) oder [x, y] (Rechteck), Standard [1, 1]. Das Quadrat liegt im ersten Quadranten; center = true zentriert es im Ursprung.

circle()

circle(r) oder circle(d = …) (d ist nach Angabe der Doku nach Version 2014.03 verfügbar). Standard: r = 1. Die Glätte steuern $fn, $fa und $fs. Ellipsen entstehen mit scale() oder resize(), reguläre Vielecke mit circle(r = 1, $fn = N), wobei N die Seitenzahl ist.

polygon()

polygon(points, paths, convexity): points ist eine Liste von [x, y] (Index ab 0), paths legt die Reihenfolge fest. Löcher entstehen, indem man weitere Pfade angibt: Die Doku sagt, sekundäre Formen werden von der primären abgezogen wie bei difference(). Ohne paths werden alle Punkte in Reihenfolge verbunden.

// Profil mit gerundeter und eckiger Hälfte
module profil() {
    union() {
        square([20, 10]);
        translate([20, 5]) circle(d = 10, $fn = 48);
    }
}
linear_extrude(5) profil();

// Dreieck als polygon
translate([0, 30, 0])
linear_extrude(3)
    polygon(points = [[0, 0], [20, 0], [10, 17]]);

// Rahmen: Quadrat mit Loch über zwei Pfade
translate([30, 30, 0])
linear_extrude(3)
    polygon(
        points = [[0,0],[20,0],[20,20],[0,20],  [5,5],[15,5],[15,15],[5,15]],
        paths  = [[0,1,2,3], [4,5,6,7]]
    );

// Sechseck über circle
translate([60, 0, 0])
linear_extrude(3) circle(r = 10, $fn = 6);

Der Rahmen nutzt zwei Pfade: Der erste ist der Außenumriss, der zweite das Loch. Ein reguläres Sechseck entsteht mit $fn = 6 – der Kreis wird dann aus sechs Segmenten angenähert.

Ein Kreis mit $fn = 3, 4, 5, 6 … ist die schnellste Art, ein regelmäßiges Vieleck zu zeichnen.

Zum Selbermachen

Zeichne ein Achteck per circle und ein Stern-Polygon per Punktliste.
Baue einen Rahmen mit rundem Loch (Kreis abziehen).

Quellen

OpenSCAD User Manual – 2D Primitives (en.wikibooks.org/wiki/OpenSCAD_User_Manual/2D_Primitives)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

3D-Primitive: cube, sphere, cylinder, polyhedron

Begriffe vorab

Primitive: Grundkörper, aus denen alles zusammengesetzt wird.
center: Gibt an, ob ein Körper um den Ursprung zentriert wird.
r und d: Radius und Durchmesser (d nur als benannter Parameter).
Fragment: Ein Segment der Kreisannäherung; Anzahl steuern $fn, $fa, $fs.
Manifold: Geschlossene, saubere Oberfläche ohne Lücken – Bedingung für gültige 3D-Modelle.

cube()

Signatur: cube(size, center). size ist eine Zahl (Würfel) oder ein Vektor [x, y, z]; Standard ist [1, 1, 1]. Mit center = false (Standard) liegt der Körper im positiven Oktanten mit einer Ecke im Ursprung, mit center = true sitzt der Mittelpunkt im Ursprung.

sphere()

sphere(r) oder sphere(d = …); Standard ist Radius 1. Der Durchmesser d muss als benannter Parameter angegeben werden. Die Glätte hängt von $fn, $fa und $fs ab (eigene Lektion).

cylinder()

Parameter: h (Höhe, Standard 1), r für beide Enden oder r1 (unten) und r2 (oben), dazu d, d1, d2 als Durchmesser-Varianten und center. Ist r1 ungleich r2, entsteht ein Kegelstumpf; bei r2 = 0 ein Kegel. Standard: cylinder(h = 1, r1 = 1, r2 = 1, center = false).

Wichtige Warnung der Doku: Wer mit cylinder() und difference() Löcher macht, erhält zu kleine Löcher, weil das Polygon innerhalb des Kreises liegt. Dazu mehr in „Auflösung“.

polyhedron()

polyhedron(points, faces, convexity) baut beliebige Körper aus Eckpunkten und Flächen. points ist eine Liste von [x, y, z] (Index ab 0), faces eine Liste von Flächen mit je mindestens drei Punktindizes. Kernregel: Die Punkte jeder Fläche müssen im Uhrzeigersinn angeordnet sein, wenn man von außen auf die Fläche blickt. Zudem muss das Ergebnis geschlossen sein: An jeder Kante treffen genau zwei Flächen aufeinander. Zum Prüfen empfiehlt die Doku, das Polyhedron mit einem Würfel zu vereinigen und zu rendern (F6) – verschwindet es, ist die Reihenfolge falsch. In der Vorschau helfen die „Thrown Together“-Ansicht (F12) und die rosa Darstellung falsch herum liegender Flächen.

// Vier Grundkörper nebeneinander
cube([10, 20, 5]);
translate([20, 0, 0]) cube(8, center = true);
translate([40, 0, 0]) sphere(d = 12);
translate([60, 0, 0]) cylinder(h = 15, r1 = 6, r2 = 2);

// Eine Pyramide als polyhedron (Flächen im Uhrzeigersinn von außen)
translate([0, 40, 0])
polyhedron(
    points = [[0,0,0],[10,0,0],[10,10,0],[0,10,0],[5,5,10]],
    faces  = [[0,1,4],[1,2,4],[2,3,4],[3,0,4],[3,2,1,0]]
);

Die Pyramide hat fünf Punkte (vier Grundpunkte, eine Spitze) und fünf Flächen: vier Dreiecke und die Grundfläche. Die Grundfläche steht als [3,2,1,0] in umgekehrter Reihenfolge, damit sie von außen (also von unten) im Uhrzeigersinn läuft.

Merke dir den Standard „Ecke im Ursprung“ – wer mittig rechnen will, setzt center = true.

Zum Selbermachen

Baue einen Kegel (r2 = 0) und einen Kegelstumpf und vergleiche beide.
Ändere in der Pyramide die Reihenfolge einer Fläche und beobachte die rosa Darstellung in der Vorschau.

Quellen

OpenSCAD User Manual – Primitive Solids (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Primitive_Solids)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Auflösung steuern: $fn, $fa, $fs

Begriffe vorab

$fn: Feste Segmentzahl für Kreise und Kugeln (überschreibt $fa und $fs).
$fa: Mindestwinkel pro Segment in Grad.
$fs: Mindestlänge eines Segments.
Fragment: Gerades Teilstück der Kreisannäherung.
Facette: Kleine ebene Fläche an gekrümmten Körpern.

Kreise sind Vielecke

OpenSCAD zeichnet keine echten Kreise, sondern Vielecke. Wie fein, steuern drei Spezialvariablen mit den Standardwerten $fa = 12 (Grad), $fs = 2 (Einheiten) und $fn = 0. Ist $fn größer als 0, überschreibt es die anderen beiden.

Die Formel

Die Doku gibt die Berechnung als Code an:

int get_line_segments_from_r(double r, double fn, double fs, double fa)
{
  if (r < GRID_FINE) return 3;
  if (fn > 0.0) return (int)(fn >= 3 ? fn : 3);
  return (int)ceil(fmax(fmin(360.0 / fa, r*2*M_PI / fs), 5));
}

Das heißt: Mit $fn gilt exakt dieser Wert (mindestens 3). Ohne $fn nimmt OpenSCAD den kleineren der beiden Werte 360/$fa und Umfang/$fs, mindestens aber 5 Segmente. Beim Standard ergeben sich also höchstens 30 Segmente (360/12).

Empfehlungen der Doku

Werte über 128 werden nicht empfohlen.
Werte unter 50 sind für die Leistung ratsam.
Vielfache von 4 liefern Begrenzungsboxen mit ganzzahligen Achsenmaßen.

Warum Löcher zu klein werden

Das Vieleck liegt innerhalb des idealen Kreises. Ein Loch mit r = 5 hat deshalb an den Seitenmitten einen etwas kleineren Durchmesser. Bei Passungen (Schrauben, Lager) rechnest du das ein: größerer Radius, höheres $fn oder ein Vieleck, das umschließt.

// Gleicher Radius, verschiedene Auflösung
translate([0, 0, 0])  cylinder(h = 5, r = 10);                  // Standard ($fa=12, $fs=2)
translate([30, 0, 0]) cylinder(h = 5, r = 10, $fn = 8);
translate([60, 0, 0]) cylinder(h = 5, r = 10, $fn = 96);

// Globale Voreinstellung für alles danach
$fn = 48;
translate([90, 0, 0]) sphere(r = 10);

// Loch mit Aufmaß: die Seitenmitten werden sonst zu eng
function aufmass(r, n) = r / cos(180 / n);
echo(aufmass(5, 32));     // ~5.0242

Mit $fn = 8 erkennt man das Achteck deutlich. Die Aufmaßfunktion rechnet vom Radius der Seitenmitten auf den Eckradius um: r / cos(180/n).

Setze $fn nicht pauschal hoch: Für die Vorschau reichen kleine Werte, für den Export erhöhst du gezielt (z. B. in einer Variable).

Zum Selbermachen

Vergleiche in der Console die Dauer eines Renders mit $fn = 32 und $fn = 128 für eine Kugel.
Miss den Durchmesser eines Lochs mit $fn = 8 in der Vorschau und vergleiche ihn mit dem Sollwert.

Quellen

OpenSCAD User Manual – Other Language Features (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Other_Language_Features)
OpenSCAD User Manual – Primitive Solids (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Primitive_Solids)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Bewährte Rezepte: Muster, Verrundungen, Hüllenketten

Begriffe vorab

Rezept: Kompakte, wiederverwendbare Lösung für ein typisches Problem.
Hüllenkette: Mehrere hull()-Aufrufe zwischen aufeinanderfolgenden Objekten.
Fillet: Rundung einer Innenkante.
Lineares Muster: Wiederholung eines Objekts entlang einer Linie.
Bounding Box: Umschließender Quader eines Objekts.

Rezept 1: Lineare und rechteckige Muster

Für Bohrungsreihen und Lüftungsschlitze genügt eine for-Schleife mit einer Formel für die Position. Mehrere Schleifenvariablen (for (x = …, y = …)) erzeugen Raster.

// Lüftungsgitter: Platte mit Schlitzen
difference() {
    cube([50, 30, 3]);
    for (i = [0 : 7])
        translate([5 + i * 5, 5, -1]) cube([2, 20, 5]);
}

Rezept 2: Weiche Übergänge mit Hüllenketten

Die Doku beschreibt das Muster aus „Tips and Tricks“: Mit for (i = [1 : n]) erzeugst du hull()-Segmente zwischen aufeinanderfolgenden, verschobenen Objekten. Ergebnis sind glatte Bahnen und Rohre entlang beliebiger Punktfolgen.

// Rohr entlang einer Punktfolge: hull() zwischen aufeinanderfolgenden Kugeln
pfad = [[0,0,0], [20,0,10], [40,15,10], [60,15,30]];
for (i = [1 : len(pfad) - 1])
    hull() {
        translate(pfad[i - 1]) sphere(r = 3, $fn = 16);
        translate(pfad[i])     sphere(r = 3, $fn = 16);
    }

Rezept 3: Verrundungen

In 2D rundest du mit offset (Round und Fillet, siehe Lektion „Hüllen, Minkowski-Summe und Rundungen“). In 3D rundest du außen mit minkowski() und einer Kugel: minkowski() { children(); sphere(r); }. Innenrundungen entstehen entsprechend durch Abziehen eines vergrößerten Körpers.

Rezept 4: Mit Listen konstruieren

Punktlisten für polygon erzeugst du mit List Comprehensions, Bauteillisten mit Funktionen wie map-ähnlichen Ausdrücken: [ for (x = eingabe) f(x) ], Filter mit [ for (x = eingabe) if (bedingung(x)) x ]. Fehlende Funktionsargumente werden zu undef – Standardwerte schützen davor.

// Gestufter Turm aus einer Liste von Radien
radien = [14, 12, 10, 8, 6, 4];
module turm(liste, stufe = 6) {
    for (i = [0 : len(liste) - 1])
        translate([0, 0, i * stufe]) cylinder(h = stufe, r = liste[i], $fn = 48);
}
turm(radien);

// Nur Radien über 8 behalten
grosse = [ for (r = radien) if (r > 8) r ];
echo(grosse);

Rezept 5: Tap-Muster für echo

Ein praktisches Muster aus der Doku: Eine Funktion gibt einen Wert per echo aus und liefert ihn unverändert zurück. So kannst du Zwischenwerte mitten in einer Berechnung sichtbar machen, ohne die Berechnung umzubauen.

function tap(x, name = "wert") = let (u = echo(name, x)) x;

abstand = tap(norm([3, 4]), "abstand");   // gibt 5 aus und liefert 5
cylinder(h = abstand, r = 2, $fn = 24);

Das Muster eignet sich für Ketten: a = tap(f(tap(g(x)))) zeigt dir beide Zwischenstände.

Sammle eigene Rezepte als kleine Module in einer Bibliotheksdatei – jedes gelöste Problem spart dir beim nächsten Projekt Zeit.

Zum Selbermachen

Baue das Lüftungsgitter so um, dass Anzahl und Abstand der Schlitze Parameter sind.
Erzeuge eine Spirale aus Hüllenkette und Winkelfunktionen.

Quellen

OpenSCAD User Manual – Tips and Tricks (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Tips_and_Tricks)
OpenSCAD User Manual – List Comprehensions (en.wikibooks.org/wiki/OpenSCAD_User_Manual/List_Comprehensions)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Boolesche Operationen: union, difference, intersection

Begriffe vorab

CSG: Constructive Solid Geometry: Körper entstehen durch Verknüpfung einfacher Körper.
union: Vereinigung aller Kinder.
difference: Das erste Kind minus alle weiteren.
intersection: Nur der gemeinsame Bereich aller Kinder.
Epsilon: Winzige Überlappung (z. B. 0,01), die Flächen-Zusammenfall verhindert.

Die drei Operationen

union() bildet die Summe aller Kinder (logisches Oder). Die Vereinigung ist implizit, wenn man sie nicht hinschreibt – aber zwingend nötig, zum Beispiel in difference(), um mehrere erste Kinder zu einem zu gruppieren.
difference() zieht das zweite und alle weiteren Kinder vom ersten ab („und nicht“).
intersection() behält nur den Bereich, den alle Kinder gemeinsam haben.

Die wichtigste Regel: keine deckungsgleichen Flächen

Die Doku sagt es klar: Bei Vereinigungen dürfen die äußeren, zu verschmelzenden Flächen nicht deckungsgleich sein. Die Lösung ist eine kleine Überlappung (Epsilon, typisch 0,01). Ohne sie entstehen flackernde Flächen in der Vorschau (Z-Fighting) und im Export unsaubere, nicht geschlossene Oberflächen. Beim Abziehen gilt dasselbe: Der abziehende Körper soll deutlich über die Fläche hinausragen, aus der er etwas herausnimmt.

// Platte mit durchgehendem Loch und Senkung
difference() {
    cube([40, 40, 10]);

    // Loch: 1 mm länger in beide Richtungen (Epsilon-Prinzip)
    translate([20, 20, -1])
        cylinder(h = 12, r = 5, $fn = 64);

    // Senkung von oben
    translate([20, 20, 6])
        cylinder(h = 5, r1 = 5, r2 = 9, $fn = 64);
}

// Schnitt: Kugel mit Würfel
translate([60, 0, 0])
intersection() {
    sphere(r = 14, $fn = 48);
    cube(20, center = true);
}

render()

render(convexity) erzwingt die vollständige Berechnung eines Teilbaums, auch in der Vorschau. Die Doku warnt, dass das die Vorschau sehr langsam machen kann. Der Parameter convexity gibt an, wie viele Flächen ein Strahl höchstens durchdringt – 10 funktioniert laut Doku in den meisten Fällen.

Denkweise

Zerlege jedes Bauteil in „Material hinzufügen“ (union) und „Material wegnehmen“ (difference). Die Reihenfolge bei difference ist wichtig: Das erste Kind ist immer das, wovon abgezogen wird.

Faustregel: Schneidkörper immer länger machen als das Bauteil und um mindestens 0,01 überlappen lassen.

Zum Selbermachen

Bohre vier Löcher in eine Platte und prüfe in F5, dass an den Lochrändern nichts flackert.
Vereinige zwei Würfel, die sich genau an einer Fläche berühren, und dann mit 0,01 Überlappung – vergleiche das Ergebnis.

Quellen

OpenSCAD User Manual – CSG Modelling (en.wikibooks.org/wiki/OpenSCAD_User_Manual/CSG_Modelling)
OpenSCAD User Manual – FAQ (en.wikibooks.org/wiki/OpenSCAD_User_Manual/FAQ)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Der Customizer: Parameter ohne Code ändern

Begriffe vorab

Customizer: Oberfläche, mit der sich Parameter ohne Codeänderung einstellen lassen.
Parametergruppe: Tab, der Parameter bündelt, per /* [Name] */ definiert.
Parameterset: Gespeicherter Satz von Werten in einer JSON-Datei.
Slider: Schieberegler für Zahlen mit Bereich.
Dropdown: Auswahlliste mit festgelegten Werten.

Wozu?

Der Customizer ist eine grafische Oberfläche, mit der sich Modellparameter einstellen lassen, ohne den Code zu bearbeiten – ideal, wenn du ein Modell an andere weitergibst. Er erfordert laut Doku Version 2019.05 oder neuer und wird über das Menü „Window“ ein- oder ausgeblendet.

Welche Variablen erscheinen?

Sie stehen in der Hauptdatei (nicht per include/use eingebunden).
Sie haben einen einfachen Literalwert: Zeichenkette, Zahl, Wahrheitswert oder Zahlenliste (bis zu 4 Elemente).
Sie stehen vor dem ersten { im Skript.
Sie liegen nicht im Bereich [Hidden].

Ausdrücke wie 12 + 0.5 oder str("a", "b") werden nicht unterstützt.

Steuerelemente per Kommentar

Direkt hinter der Variablen steht ein Kommentar, der das Steuerelement festlegt (linksbündig, ohne führende Leerzeichen):

Dropdown (Zahlen): n = 2; // [0, 1, 2, 3]
Dropdown (Text): s = "foo"; // [foo, bar, baz]
Dropdown mit Beschriftung: g = 10; // [10:S, 20:M, 30:L]
Slider mit Maximum: x = 34; // [50]
Slider mit Bereich: x = 34; // [10:100]
Slider mit Schritt: x = 2; // [0:5:100]
Checkbox: Wahrheitswert; Textfeld: Zeichenkette; Spinbox: Zahl, bei Dezimalschritt // .5.
Vektor mit 2 bis 4 Elementen: v = [12,34,46]; // [1:2:50].

Gruppen und Parametersets

Gruppen entstehen mit /* [Gruppenname] */. Spezielle Namen: [Global] (auf jedem Tab sichtbar) und [Hidden] (nie angezeigt). Parametersets speichert der Customizer als JSON-Datei, auf der Kommandozeile lädst du sie mit -p datei.json -P Name.

/* [Abmessungen] */
// Breite in mm
breite = 40;          // [20:5:100]
tiefe  = 30;          // [20:5:80]
hoehe  = 15;          // [5:1:40]

/* [Optionen] */
mit_loch = true;
farbe = "steelblue";  // [steelblue, tomato, seagreen]
rundung = 2;          // [0:0.5:5]

/* [Hidden] */
$fn = 32;

color(farbe)
difference() {
    cube([breite, tiefe, hoehe]);
    if (mit_loch)
        translate([breite / 2, tiefe / 2, -1]) cylinder(h = hoehe + 2, r = 5);
}

Beim Öffnen im Customizer erscheinen zwei Tabs (Abmessungen und Optionen) mit Schiebereglern, Checkbox und Auswahlliste. $fn bleibt unsichtbar.

Hinweise der Doku: Mehrzeilige Textfelder und direkte Zahleneingabefelder werden nicht unterstützt; versteckte Parameter werden in JSON gespeichert, aber nicht daraus geladen.

Lege die wichtigsten Maße als Customizer-Variablen an den Dateianfang – so wird dein Modell auch für andere benutzbar.

Zum Selbermachen

Mache dein letztes Projekt Customizer-fähig und gruppiere die Parameter.
Speichere zwei Parametersets (klein/groß) und lade sie nacheinander.

Quellen

OpenSCAD User Manual – Customizer (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Customizer)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Fehlersuche: Modifier-Zeichen, Z-Fighting und saubere Geometrie

Begriffe vorab

Modifier-Zeichen: Zeichen vor einem Objekt, das seine Behandlung ändert: * ! # %.
Z-Fighting: Flackern, wenn zwei Flächen exakt aufeinanderliegen.
Non-manifold: Geometrie mit Löchern oder Kanten, an denen nicht genau zwei Flächen zusammentreffen.
Konvexität: Hinweis für die Vorschau, wie komplex ein Objekt ist.
echo: Ausgabe von Werten in die Console zur Fehlersuche.

Die vier Modifier-Zeichen

Vor jedes Objekt oder jeden Teilbaum kannst du ein Zeichen setzen:

Zeichen	Name	Wirkung
`*`	Disable	Teilbaum wird ganz ignoriert – wie auskommentiert, ohne Klammern zählen zu müssen.
`!`	Root	Nur dieser Teilbaum wird gezeigt; alles andere wird ignoriert. Transformationen außerhalb des Teilbaums gelten nicht.
`#`	Debug	Teilbaum wird normal verwendet und zusätzlich unverändert in transparentem Rosa gezeigt. Nur in der Vorschau, nicht im Export.
`%`	Background	Teilbaum erscheint transparent grau, wird aber nicht in CSG-Operationen verwendet. Nur in der Vorschau, nicht im Export.

Die Doku warnt: Steht % am ersten Objekt von difference(), wird es ignoriert – das hat oft unerwartete Folgen.

difference() {
    cube([30, 30, 10]);
    #translate([15, 15, -1]) cylinder(h = 12, r = 6, $fn = 48);  // zeigt, WAS abgezogen wird
}
%translate([40, 0, 0]) cube(10);                                  // nur als Hintergrund-Maß
translate([60, 0, 0]) *sphere(r = 8);                             // deaktiviert

Z-Fighting und deckungsgleiche Flächen

Das FAQ rät: Bei Flächen, die abgezogen werden, immer eine klare Überlappung vorsehen – mit einem kleinen Epsilon wie cube_size + 0.01. Sonst flackern Flächen in der Vorschau.

Löcher, die nicht stimmen

Erscheint ein Loch falsch, erhöhe convexity (meist genügt 10), das gibt die maximale Zahl der Vorder- (oder Rück-)seiten an, die ein Strahl durchdringt.

Nicht-manifold

Importierte STL-Dateien, die sich nicht mit F6 rendern lassen, haben meist fehlerhafte Geometrie. Das FAQ empfiehlt MeshLab oder Blender zur Reparatur: Das Modell muss manifold sein. Achte auf Nullflächen (kollineare Dreieckspunkte).

Ausgabe zur Fehlersuche

echo() gibt Werte in der Console aus, assert() bricht bei verletzten Annahmen ab. Ein bewährtes Muster aus „Tips and Tricks“ ist ein echo-Wrapper, der den Wert ausgibt und zurückliefert.

Ein # vor dem abziehenden Körper zeigt dir sofort, wo er wirklich sitzt – das spart viele Rechnungen.

Zum Selbermachen

Setze # vor alle abziehenden Körper deines letzten Projekts und prüfe, ob sie überall herausragen.
Provoziere Z-Fighting mit zwei bündigen Würfeln und löse es mit 0,01 Überlappung.

Quellen

OpenSCAD User Manual – Modifier Characters (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Modifier_Characters)
OpenSCAD User Manual – FAQ (en.wikibooks.org/wiki/OpenSCAD_User_Manual/FAQ)
OpenSCAD User Manual – Tips and Tricks (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Tips_and_Tricks)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Hüllen, Minkowski-Summe und Rundungen

Begriffe vorab

hull: Konvexe Hülle: kleinste konvexe Form, die alle Kinder umschließt.
minkowski: Minkowski-Summe: Eine Form wird an der Oberfläche einer anderen entlanggeführt.
offset: Verbreitert oder verkleinert eine 2D-Form.
fill: Entfernt Löcher aus 2D-Formen.
Fillet: Rundung einer Innenkante.

hull()

hull() berechnet die konvexe Hülle seiner Kinder – wie ein Gummiband, das um alle Teile gespannt wird. Die Doku nennt eine Besonderheit: Die Hülle von 2D-Objekten nutzt deren Projektionen (Schatten) auf die xy-Ebene und liefert ein Ergebnis in dieser Ebene. Effizienztipp: Wenn möglich, erst 2D-Formen hüllen und dann extrudieren, statt 3D-Körper zu hüllen. Ein klassisches Rezept sind abgerundete Quader: vier Zylinder in den Ecken, darum hull().

minkowski()

minkowski() bildet die Minkowski-Summe der Kinder; für die Addition wird der Ursprung des zweiten Objekts verwendet. Praktisch: Eine Kugel mit Radius r an einem Körper entlangzuführen, rundet alle Außenkanten und -ecken ab (das Rezept minkowski() { children(); sphere(r); } steht auf der Seite „Tips and Tricks“). Die Doku warnt: Bei hohen $fn-Werten können Rechenzeit und Speicher stark wachsen, weil jedes Kind mit allen Teilen der anderen kombiniert wird. Zusammengesetzte Eingaben kann OpenSCAD getrennt behandeln – fasse sie vorher mit union() zusammen.

offset() (2D)

offset(r = …) verbreitert eine 2D-Form mit gerundeten Ecken, offset(delta = …) mit spitzen Ecken; mit chamfer = true werden Ecken bei delta abgeschrägt. Negative Werte verkleinern. Zwei Kombinationen aus der Doku: Fillet (Innenecken runden): offset(r = -3) offset(delta = +3); Round (Außenecken runden): offset(r = +3) offset(delta = -3).

fill()

fill() entfernt Löcher aus Polygonen, ohne den Umriss zu ändern. Bei konvexen Polygonen entspricht das Ergebnis hull().

// 1) Abgerundete Platte per hull() aus vier Zylindern
module runde_platte(b, t, h, r) {
    hull()
        for (x = [r, b - r], y = [r, t - r])
            translate([x, y, 0]) cylinder(h = h, r = r, $fn = 48);
}
runde_platte(40, 25, 4, 5);

// 2) Rundungen per offset(): Rechteck mit gerundeten Außenecken, dann extrudiert
translate([0, 40, 0])
linear_extrude(4)
    offset(r = 4, $fn = 48) offset(delta = -4) square([40, 25]);

// 3) Abgerundeter Würfel per minkowski()
translate([60, 0, 0])
minkowski() {
    cube([14, 14, 14]);
    sphere(r = 3, $fn = 24);
}

Das hull() bekommt mehrere Zylinder aus einer for-Schleife; die Schleife erzeugt die vier Eckpositionen, hull() verbindet sie zu einer Platte mit runden Ecken.

Rundungen sind keine Eigenschaft einzelner Kanten, sondern entstehen durch Operationen auf der ganzen Form – plane sie früh ein.

Zum Selbermachen

Baue eine Platte mit vier gerundeten Ecken per hull() und danach per offset() – vergleiche die Anzahl der Zeilen.
Probiere minkowski() mit unterschiedlichen $fn-Werten und beobachte die Rechenzeit.

Quellen

OpenSCAD User Manual – Transformations (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Transformations)
OpenSCAD User Manual – Tips and Tricks (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Tips_and_Tricks)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Import und Export: Dateiformate

Begriffe vorab

import(): Lädt externe Geometrie in das Modell.
STL: Weit verbreitetes Format für 3D-Druck.
3MF: Containerformat für 3D-Druck-Modelle.
DXF / SVG: Zweidimensionale Formate.
surface(): Erzeugt aus Text- oder PNG-Daten ein Höhenfeld.

import()

import("datei.stl", convexity = 3); lädt externe Geometrie. file ist der Pfad (relativ zur importierenden Datei; unter Windows Schrägstriche oder doppelte Backslashes nutzen). convexity ist die maximale Zahl der Vorder- oder Rückseiten, die ein Strahl durchdringt (meist 10). layer wählt bei DXF und SVG eine Ebene. Weitere Parameter (center, id, $fn/$fa/$fs) nennt die Doku nur für Entwicklungs-Snapshots.

Importierbare Formate laut Doku

3D: STL (ASCII und binär), OFF, OBJ, AMF (veraltet), 3MF.
2D: DXF, PDF, SVG.
Daten: JSON (Snapshot).
Höhenfeld: PNG über surface().

import_stl() und import_dxf() gelten als veraltet; verwende import().

surface()

surface(file, center, invert, convexity) erzeugt aus einer Text- oder PNG-Datei ein Höhenfeld – die Helligkeit oder der Zahlenwert bestimmt die Höhe.

Export

Welche Formate zur Wahl stehen, hängt davon ab, ob das Ergebnis 2D oder 3D ist. Laut Export-Seite:

3D: STL (ASCII), OFF, AMF (ab 2015.03), 3MF (ab 2019.05).
2D: DXF, SVG (ab 2015.03), PDF in A4 (ab 2021.01).
Bild: PNG (ab 2019.05).
CSG: eine vereinfachte Darstellung des Skripts.

Die Kommandozeile nennt zusätzlich die Varianten asciistl und binstl für STL. Exportiert wird das gerenderte Modell: erst F6, dann Export (Menü „Design“ bzw. Export-Befehle).

Praxis

Für 3D-Druck sind STL oder 3MF üblich; prüfe, was dein Slicer erwartet.
Soll ein Profil in ein anderes Programm (z. B. Laserschneider), nutze DXF oder SVG.
Importierte STL-Dateien müssen manifold sein, sonst scheitert das Rendern (siehe Lektion zur Fehlersuche).

// Ein kleines Teil, das sich als STL exportieren lässt.
// Export im Programm: F6 (Rendern), dann Datei exportieren.
// Auf der Kommandozeile: openscad -o teil.stl dieses_skript.scad
difference() {
    cube([30, 20, 8]);
    translate([15, 10, -1]) cylinder(h = 10, d = 6, $fn = 48);
}

Das Beispiel enthält absichtlich keine Importzeile, damit es ohne externe Dateien läuft. In einem echten Projekt stünde dort etwa import("gehaeuse.stl");.

Importiere nur Modelle, die du selbst auf Manifold-Eigenschaft geprüft hast – sonst verlierst du Zeit beim Rendern.

Zum Selbermachen

Exportiere ein einfaches Teil als STL und als 3MF und vergleiche die Dateigrößen.
Exportiere ein 2D-Profil als SVG und öffne es in einem Vektorprogramm.

Quellen

OpenSCAD User Manual – Importing Geometry (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Importing_Geometry)
OpenSCAD User Manual – Export (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Export)
OpenSCAD User Manual – Using OpenSCAD in a command line environment (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Using_OpenSCAD_in_a_command_line_environment)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

include, use und Bibliotheken

Begriffe vorab

include: Fügt den Inhalt einer Datei so ein, als stünde er im aktuellen Skript.
use: Importiert nur Module und Funktionen einer Datei.
Bibliothek: Sammlung wiederverwendbarer Module und Funktionen.
OPENSCADPATH: Umgebungsvariable mit zusätzlichen Bibliotheksordnern.
MCAD: Bibliothek, die mit OpenSCAD mitgeliefert wird.

include und use

Beide Anweisungen binden andere .scad-Dateien ein und nutzen spitze Klammern: include <datei.scad> und use <datei.scad>. Der Unterschied ist wichtig:

include verarbeitet die gesamte Datei, als stünde ihr Text im aktuellen Skript. Alles wird ausgeführt: Zuweisungen, Module und auch Geometrie auf oberster Ebene. Beide Dateien sehen die Variablen der jeweils anderen. Wird eine in der eingebundenen Datei gesetzte Variable im Hauptskript erneut zugewiesen, unterbleibt die sonst übliche Warnung – so können Bibliotheken Standardwerte liefern, die das Hauptskript überschreibt.
use importiert nur Module und Funktionen. Befehle auf oberster Ebene (also Geometrie) werden nicht ausgeführt. Globale Variablen der beiden Dateien bleiben füreinander unsichtbar.

Verschachtelte include– und use-Anweisungen innerhalb der eingebundenen Dateien werden ausgeführt; verschachteltes use wirkt laut Doku aber nur begrenzt auf die Hauptdatei. Platzhalter (*) für mehrere Dateien sind nicht möglich. Verwende Schrägstriche (/) als Pfadtrenner – sie funktionieren auch unter Windows.

Wo OpenSCAD sucht

Mit unvollständigen Pfaden sucht OpenSCAD in dieser Reihenfolge: (1) im Ordner der aufrufenden Datei, (2) in Pfaden aus OPENSCADPATH, (3) in den eingebauten Bibliotheksordnern, (4) im Bibliotheksordner der Installation. Die Standard-Bibliotheksordner sind:

Windows: My Documents\OpenSCAD\libraries
macOS: $HOME/Documents/OpenSCAD/libraries
Linux: $HOME/.local/share/OpenSCAD/libraries

Der Ordner lässt sich über „File → Show Library Folder…“ öffnen (ab 2014.03). OPENSCADPATH trennt mehrere Pfade unter Windows mit Semikolon, unter Linux/macOS mit Doppelpunkt; nach einer Änderung muss OpenSCAD neu starten.

Bekannte Bibliotheken

Mitgeliefert wird MCAD mit gängigen Formen (abgerundete Boxen, regelmäßige Vielecke, Polyeder), Zahnrad-Generatoren, Motorhalterungen, Befestigungsteilen und mathematischen Hilfen. Als beliebte Drittbibliotheken nennt das User Manual BOSL (Belfry OpenScad Library), BOLTS (Normteile) und DotSCAD sowie Spezialbibliotheken für Gewinde, Verrundungen und Lasercut-Teile; eine vollständige Liste führt das OpenSCAD-GitHub-Wiki.

// Dieses Skript zeigt das Prinzip mit lokalen Modulen,
// die in einer eigenen Datei "teile.scad" liegen würden:
//
//   include <teile.scad>;   // führt ALLES aus (auch Geometrie)
//   use     <teile.scad>;   // nur Module und Funktionen
//
// Hier simulieren wir die Datei durch Definitionen im selben Skript.
module schraube(l = 12, d = 3) {
    cylinder(h = l, d = d, $fn = 24);
    translate([0, 0, l]) cylinder(h = d * 0.6, d = d * 2, $fn = 24);
}
module platte(b = 30, t = 20, h = 4) { cube([b, t, h]); }

platte();
translate([15, 10, 4]) schraube();

Beide Module stehen hier im selben Skript, damit das Beispiel allein lauffähig bleibt. Lägen sie in teile.scad, würde use <teile.scad> genügen, um sie zu nutzen – ohne dass die Datei selbst etwas zeichnet.

Wähle use für reine Baustein-Bibliotheken und include nur, wenn du Variablen oder Konfigurationen teilen willst.

Zum Selbermachen

Lege eine Datei mit zwei Modulen an und binde sie einmal per use und einmal per include ein – vergleiche, was gezeichnet wird.
Öffne den Bibliotheksordner deines Systems und lege dort eine Bibliothek an.

Quellen

OpenSCAD User Manual – Include Statement (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Include_Statement)
OpenSCAD User Manual – Libraries (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Libraries)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Kontrollfluss: for, if, let und Co.

Begriffe vorab

for: Erzeugt für jeden Wert eines Bereichs oder Vektors einen Zweig im Objektbaum.
intersection_for: Wie for, aber mit Schnittmenge statt Vereinigung.
if / else: Bedingte Ausführung eines Blocks.
Ternärer Operator: Ausdruck der Form bedingung ? a : b.
let: Legt Variablen für einen Teilbaum oder Ausdruck fest.

for() baut einen Baum

Die Doku betont: OpenSCAD ist keine iterative Sprache. for() schleift nicht im programmiersprachlichen Sinn, sondern erzeugt einen Baum von Objekten, einen Zweig pro Wert. Jeder Durchlauf hat seinen eigenen Scope; Variablen lassen sich über Durchläufe hinweg nicht verändern.

Formen

Bereich: for (a = [3 : 0.5 : 5]) liefert 3, 3.5, 4, 4.5, 5 (Standardschritt 1).
Vektor: for (a = [3, 4, 1, 5]) geht jedes Element durch.
Verschachtelt in Kurzform: for (x = r1, y = r2, z = r3).

Die Variante für Objekte (for (v = object)) nennt die Doku nur für Entwicklungs-Snapshots.

intersection_for()

Arbeitet wie for(), bildet aber die Schnittmenge aller Durchläufe statt der Vereinigung.

if / else

if (test) a oder if (test) a else b, auch verkettet mit else if. Die erste wahre Bedingung gewinnt, weitere Tests entfallen. Variablen, die du innerhalb eines Blocks zuweist, gelten nur in diesem Scope.

Ternärer Operator

wert = test ? wahr : falsch; liefert einen Wert und eignet sich für Funktionen und Rekursion.

let()

let setzt Variablen nacheinander innerhalb eines Teilbaums – spätere dürfen auf frühere zugreifen. Es ersetzt das veraltete assign().

echo() und assert()

echo() schreibt in die Console und rundet auf fünf signifikante Stellen. assert(bedingung, meldung) prüft Annahmen und stoppt bei Verletzung.

// Zahnrad-artiger Kranz aus Zylindern per for und let
for (i = [0 : 11])
    let (winkel = i * 30, abstand = 20)
        rotate([0, 0, winkel])
            translate([abstand, 0, 0])
                if (i % 2 == 0)
                    cylinder(h = 6, r = 3, $fn = 24);
                else
                    cylinder(h = 4, r = 2, $fn = 24);

// Zwei Schleifenvariablen: Raster aus Säulen
translate([50, 0, 0])
    for (x = [0 : 3], y = [0 : 2])
        translate([x * 8, y * 8, 0]) cube([5, 5, 2 + x + y]);

// Schnitt über intersection_for
translate([100, 0, 0])
    intersection_for (a = [0, 60, 120])
        rotate([0, 0, a]) cube([20, 8, 8], center = true);

Im ersten Beispiel entscheidet i % 2, ob ein hoher oder niedriger Zylinder entsteht. Im zweiten erzeugt eine Schleife mit zwei Variablen ein 4 × 3-Raster. Das dritte bildet den Durchschnitt dreier gedrehter Balken.

Wenn du „Zähler hochsetzen“ denkst, brauchst du in OpenSCAD stattdessen eine Formel in Abhängigkeit vom Schleifenwert.

Zum Selbermachen

Baue eine Wendeltreppe: für jede Stufe i drehst du um i·15° und hebst um i·3.
Nutze assert, um zu prüfen, dass eine Wandstärke positiv ist.

Quellen

OpenSCAD User Manual – Conditional and Iterator Functions (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Conditional_and_Iterator_Functions)
OpenSCAD User Manual – Other Language Features (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Other_Language_Features)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Listen, List Comprehensions und Zeichenketten

Begriffe vorab

List Comprehension: Ausdruck, der eine Liste aus einer Schleife erzeugt.
each: Entpackt eine Liste in die umgebende Liste.
search(): Sucht Werte in Listen oder Zeichenketten.
Typtest: Funktion, die den Typ eines Wertes prüft, z. B. is_list.
str(): Wandelt Argumente in Text um und verkettet sie.

List Comprehensions

Mit [ for (i = bereich) ausdruck ] erzeugst du Listen. Erweiterungen:

Filter: [ for (x = liste) if (bedingung) x ].
if/else innerhalb der Liste (laut Doku ab 2019.05).
let für Zwischenwerte.
each (ab 2019.05) entpackt eine Liste, z. B. zum Flachklopfen.
C-artiges for for (init; bedingung; schritt) für rekursive Berechnungen (ab 2019.05).

Kerngedanke: Du beschreibst die Liste, statt sie schrittweise zu füllen. Das passt zur unveränderlichen Natur von OpenSCAD-Variablen. Typisch: Punktlisten für polygon mit Winkelfunktionen.

Zeichenketten

str(…) wandelt alle Argumente in Text um und verkettet sie.
chr(…) (ab 2015.03) wandelt Unicode-Codepunkte in Zeichen (chr(65) = „A“).
ord("a") (ab 2019.05) liefert den Codepunkt (97).
len("Hello world") liefert 11 – auch für Listen.
search() findet Werte in Listen und Text.

Typtests (ab 2019.05)

is_undef, is_bool, is_num, is_string, is_list und – ab 2021.01 – is_function. Besonderheiten: is_undef(a) prüft ohne Warnung bei unbekannter Variable; is_num gilt auch für Unendlich, aber nicht für nan.

// Ellipse aus einer List Comprehension
punkte = [ for (a = [0 : 10 : 359]) [ 20 * cos(a), 10 * sin(a) ] ];
linear_extrude(4) polygon(punkte);

// Filter und Transformation
zahlen = [1, 2, 3, 4, 5, 6];
gerade = [ for (z = zahlen) if (z % 2 == 0) z * z ];
echo(gerade);                                    // [4, 16, 36]

// Flachklopfen mit each
flach = [ each [1, 2], each [3, 4] ];
echo(flach);                                     // [1, 2, 3, 4]

// Text und Typen
beschriftung = str("Maß: ", 12, " mm");
echo(beschriftung, len(beschriftung), is_string(beschriftung), is_list(zahlen));
echo(chr(65), ord("a"));

Die erste Liste erzeugt 36 Punkte einer Ellipse mit Halbachsen 20 und 10 und gibt sie an polygon. Die zweite filtert gerade Zahlen und quadriert sie.

Statt eine Liste in einer Schleife „aufzufüllen“, beschreibst du sie mit einer List Comprehension.

Zum Selbermachen

Erzeuge die Eckpunkte eines Sterns mit abwechselnd zwei Radien.
Filtere aus einer Liste von Maßen alle über 10 und gib sie aus.

Quellen

OpenSCAD User Manual – List Comprehensions (en.wikibooks.org/wiki/OpenSCAD_User_Manual/List_Comprehensions)
OpenSCAD User Manual – String Functions (en.wikibooks.org/wiki/OpenSCAD_User_Manual/String_Functions)
OpenSCAD User Manual – Type Test Functions (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Type_Test_Functions)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Literatur und Lesepfad: die OpenSCAD-Dokumentation

Begriffe vorab

Tutorial: Schrittweise Einführung in mehreren Kapiteln.
User Manual: Ausführliches Handbuch zur Bedienung und Sprache.
Language Reference: Teil des Handbuchs, der die Sprache im Detail beschreibt.
Cheat Sheet: Kompakte Übersicht aller Befehle auf einer Seite.
Library: Wiederverwendbare Sammlung von Modulen und Funktionen.

Die Landkarte der offiziellen Doku

Die Seite openscad.org/documentation.html verweist auf vier Hauptbereiche und weitere Quellen:

OpenSCAD Tutorial (Wikibooks): neun Kapitel von den Grundlagen bis zu fortgeschrittener Geometrie.
OpenSCAD User Manual (Wikibooks): Oberfläche, Einrichtung, Praxis und die vollständige Sprachreferenz.
Cheat Sheet (openscad.org/cheatsheet): Kurzreferenz für Syntax, Module und Funktionen; bezieht sich auf Version 2021.01.
Bücher, Videos, Artikel in eigenen Unterseiten, Bibliotheken auf libraries.html.

Aufbau des User Manuals

Das Handbuch gliedert sich in zwei Teile. Der erste umfasst Einführung, erste Schritte, Oberfläche, Eingabegeräte, Customizer, Import, Export, Beispielprojekte, Pfade, externe Editoren, Integration mit anderen Anwendungen, Kommandozeile, Kompilieren aus Quellen, FAQ, Bibliotheken, Tipps und Tricks sowie das Befehlsglossar. Der zweite Teil ist die Sprachreferenz: die Sprache selbst, 3D-Objekte, 2D-Objekte, Transformationen, boolesche Kombinationen, weitere Funktionen und Operatoren (Bedingungen und Schleifen, Mathematik, Zeichenketten, Typtests, List Comprehensions, weitere Sprachmerkmale), benutzerdefinierte Funktionen und Module, Debugging-Hilfen sowie externe Bibliotheken und Codedateien.

Wo findest du was?

Frage	Seite im User Manual
Welche Form brauche ich?	Primitive Solids, 2D Primitives
Wie verschiebe oder drehe ich?	Transformations
Wie ziehe ich etwas ab?	CSG Modelling
Wie programmiere ich Wiederholungen?	Conditional and Iterator Functions, List Comprehensions
Wie baue ich eigene Bausteine?	User-Defined Functions and Modules
Wie finde ich Fehler?	Modifier Characters, FAQ
Wie exportiere ich?	Export, Using OpenSCAD in a command line environment

Ein Lesepfad für Einsteiger

Erste Schritte und Oberfläche; ein eigenes Würfel-und-Kugel-Modell bauen.
Primitive Solids, Transformationen, CSG Modelling.
2D Primitives und Extrusion.
Variablen, Schleifen, Module (Sprachreferenz).
FAQ und Modifier Characters zur Fehlersuche.
Cheat Sheet als tägliches Nachschlagewerk.
Customizer und Kommandozeile für Weitergabe und Automatisierung.

Hinweis zu Versionen

Die Doku markiert Funktionen, die nur in Entwicklungs-Snapshots vorhanden sind. Das Cheat Sheet führt „2021.01“; das User Manual vermerkt zu manchen Funktionen die Version, ab der sie verfügbar sind (zum Beispiel 2015.03, 2019.05, 2021.01). Prüfe in deiner Installation mit --version oder version(), was du hast.

Lies zuerst die Sprachreferenz-Seite zu dem Befehl, den du brauchst – meist steht dort schon ein Beispiel, das du anpassen kannst.

Zum Selbermachen

Öffne das Cheat Sheet und markiere alle Befehle, die du in dieser Themenwelt gesehen hast.
Suche im User Manual einen Befehl, der hier nicht behandelt wurde, und teste ihn.

Quellen

OpenSCAD – Dokumentation (openscad.org/documentation.html)
OpenSCAD User Manual – Startseite (en.wikibooks.org/wiki/OpenSCAD_User_Manual)
OpenSCAD Tutorial (en.wikibooks.org/wiki/OpenSCAD_Tutorial)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet)
OpenSCAD – Bibliotheken (openscad.org/libraries.html)

Module und Funktionen: eigene Bausteine

Begriffe vorab

Modul: Wiederverwendbarer Baustein, der Geometrie erzeugt.
Funktion: Berechnet und liefert einen Wert, erzeugt aber keine Geometrie.
children(): Die Kind-Objekte, die einem Modul übergeben werden.
Standardwert: Wert, der gilt, wenn kein Argument übergeben wird.
Rekursion: Eine Funktion oder ein Modul ruft sich selbst auf.

Funktionen und Module

Die Doku trennt klar: Funktionen liefern Werte, Module führen Aktionen aus, geben aber keine Werte zurück. Es gibt keinen Mechanismus, mit dem ein Modul einen Wert nach außen reicht. Namen dürfen nur a–z, A–Z, 0–9 und Unterstrich enthalten und unterscheiden Groß- und Kleinschreibung.

Funktionen

function name(parameter) = ausdruck; – ein Ausdruck, kein Block. Parameter dürfen Standardwerte haben: function f(x = 3) = 2*x + 1;. Innerhalb von Funktionen setzt let Hilfsvariablen. Funktionsliterale (f = function (x) x * x;) sind ab Version 2021.01 möglich und erfassen Variablen lexikalisch (Closures).

Module

module name(parameter) { … }. Fast jede Anweisung darf im Modul stehen, auch Definitionen weiterer Module und Funktionen (dann nur lokal sichtbar). Variablen im Modul gelten nur innerhalb des jeweiligen Aufrufs.

children()

Ein Modul kann Kind-Objekte übernehmen und sie transformieren – so entstehen eigene „Operatoren“. children() meint alle Kinder, children(index) ein einzelnes, children([start:schritt:ende]) einen Bereich und children([v1, v2]) mehrere. $children enthält die Anzahl der Kinder. Zusammen in einen Block gefasste Objekte zählen als ein Kind.

Rekursion

Mit Endrekursion kann OpenSCAD die Rekursion intern in eine Schleife umwandeln: Das erlaubt bis zu etwa 1.000.000 Aufrufe, normale Rekursion nur einige Tausend. Module haben diese Optimierung nicht. Bei verzweigender Rekursion warnt die Doku: Die Rekursionstiefe unter 7 halten, weil Zahl der Primitive und Vorschauzeit exponentiell wachsen.

// Funktion mit Standardwert und let
function flaeche(b, h = 10) = let (a = b * h) a;
echo(flaeche(4), flaeche(4, 3));            // 40 und 12

// Funktionsliteral (ab 2021.01) und Endrekursion
quadrat = function (x) x * x;
function summe(n, s = 0) = n == 0 ? s : summe(n - 1, s + n);
echo(quadrat(5), summe(100));               // 25 und 5050

// Modul mit Standardwerten
module saeule(h = 10, r = 3) {
    cylinder(h = h, r = r, $fn = 32);
    translate([0, 0, h]) sphere(r = r + 1, $fn = 32);
}

// Eigener Operator mit children(): Objekt n-mal im Kreis anordnen
module im_kreis(n, radius) {
    for (i = [0 : n - 1])
        rotate([0, 0, i * 360 / n])
            translate([radius, 0, 0]) children();
}

im_kreis(6, 25) saeule(h = 8, r = 2);
saeule();

Das Modul im_kreis weiß nichts über das, was es verteilt: Es bekommt ein Kind-Objekt und wiederholt es. So entsteht aus drei Zeilen ein wiederverwendbarer Baustein.

Modularisiere früh: Jedes Bauteil, das du zweimal brauchst, gehört in ein Modul mit Parametern.

Zum Selbermachen

Schreibe ein Modul „loch_platte(b, t, h, lochdurchmesser)“.
Baue einen Operator „spiegel_paar“, der sein Kind einmal normal und einmal gespiegelt zeichnet.

Quellen

OpenSCAD User Manual – User-Defined Functions and Modules (en.wikibooks.org/wiki/OpenSCAD_User_Manual/User-Defined_Functions_and_Modules)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

OpenSCAD auf der Kommandozeile

Begriffe vorab

CLI: Command Line Interface, Bedienung per Text im Terminal.
-o: Option für die Ausgabedatei; die Endung bestimmt das Format.
-D: Setzt eine Variable vor der Ausführung.
Parameterset: JSON-Datei mit Werten aus dem Customizer.
Makefile: Build-Datei, die Exporte automatisiert.

Grundform

Das Modell lässt sich ohne Oberfläche exportieren – ideal für Automatisierung und Serien:

openscad -o ausgabe.stl eingabe.scad

Die Dateiendung der Ausgabe bestimmt das Format: stl, off, amf, 3mf, csg, dxf, svg, png oder pdf. Mit --export-format lässt sich das überschreiben; für STL gibt es asciistl und binstl.

Wichtige Optionen

-D name=wert definiert Variablen vorab. Zeichenketten brauchen Anführungszeichen, die du vor der Shell schützen musst: -D 'qualitaet="produktion"'.
-p datei.json und -P Name laden Customizer-Parametersets.
–imgsize breite,hoehe, –camera, –projection, –autocenter, –viewall, –colorscheme steuern PNG-Ausgaben.
–render oder –preview wählt den Modus beim Bildexport.
-d datei.deps erzeugt Makefile-Abhängigkeiten, -m make ruft ein Build-System für fehlende Dateien auf.
-q unterdrückt Ausgaben außer Fehlern, –version zeigt die Version, -h die Hilfe.

Plattformhinweise

Auf macOS liegt das Programm unter /Applications/OpenSCAD.app/Contents/MacOS/OpenSCAD. Unter Windows empfiehlt die Doku den Wrapper openscad.com für die Kommandozeile.

Serien mit einer Schleife

Mit -D baust du Varianten eines Modells, ohne die Datei zu ändern:

for h in 10 20 30; do
  openscad -o "saeule_$h.stl" -D "hoehe=$h" saeule.scad
done

Das Skript saeule.scad braucht dafür nur eine Variable hoehe, die per -D überschrieben wird. Beim Überschreiben per -D unterbleibt die sonst übliche Warnung über doppelte Zuweisung.

// saeule.scad – Variable "hoehe" lässt sich per -D überschreiben
hoehe = 20;
cylinder(h = hoehe, r = 5, $fn = 48);
echo(version = version());

Aufruf: openscad -o saeule.stl -D hoehe=35 saeule.scad. Die Variable aus der Kommandozeile hat Vorrang vor der Zuweisung im Skript.

Alles, was du im Programm klickst, lässt sich auch skripten – nutze die Kommandozeile für Serienexporte und Automatisierung.

Zum Selbermachen

Exportiere ein Modell per Kommandozeile als STL und PNG.
Erzeuge drei Varianten mit -D und einer Shell-Schleife.

Quellen

OpenSCAD User Manual – Using OpenSCAD in a command line environment (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Using_OpenSCAD_in_a_command_line_environment)
OpenSCAD User Manual – General (en.wikibooks.org/wiki/OpenSCAD_User_Manual/General)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Operatoren und mathematische Funktionen

Begriffe vorab

Operator: Zeichen für eine Rechen- oder Vergleichsoperation.
Modulo: Rest einer Division (%).
Skalarprodukt: Ergebnis der Multiplikation zweier Vektoren.
Grad: Winkeleinheit, die OpenSCAD in trigonometrischen Funktionen nutzt.
Norm: Länge eines Vektors.

Rechenoperatoren

+ - * / % ^: Addition, Subtraktion, Multiplikation, Division, Modulo und Potenz. Der Potenzoperator ^ erfordert laut Doku Version 2021.01 oder neuer. Das Minuszeichen funktioniert auch als Vorzeichen. Modulo ist praktisch für Muster: Eine Zahl modulo 2 ist 0 bei geraden und 1 bei ungeraden Zahlen. Bitoperationen (| & << >> ~) nennt die Doku nur für Entwicklungs-Snapshots.

Vergleich und Logik

< <= == != >= > sowie && || !. Nicht-Boolesche Werte werden vor der Auswertung in Boolesche umgewandelt. Einzelheiten laut Doku: Zeichenketten werden alphabetisch verglichen, true > false, Vektoren sind nur bei vollständiger Gleichheit gleich, verschiedene Typen sind ungleich ([1] != 1), undef ist nur sich selbst gleich, und nan ist nichts gleich.

Vektoren und Matrizen

Vektor mit Zahl: jedes Element wird multipliziert oder geteilt.
Vektor mit Vektor: Addition und Subtraktion elementweise.
Zwei einfache Vektoren multipliziert ergeben das Skalarprodukt.
Matrizenmultiplikation folgt der linearen Algebra und ist nicht kommutativ.

Mathematische Funktionen

Winkelfunktionen in Grad: sin, cos, tan, asin, acos, atan; atan2(y, x) liefert Winkel im Bereich −180 < Winkel ≤ 180.
Grundfunktionen: abs, sign, sqrt, pow, exp, floor, ceil, round (rundet „weg von null“: round(5.5) ergibt 6, round(-5.5) ergibt −6), ln (natürlich), log (Basis 10).
Mehrere Werte: min und max mit mehreren Argumenten oder einem Vektor, norm (Euklidische Länge), len (Anzahl der Elemente), cross (Kreuzprodukt), concat (Vektoren aneinanderhängen).
Weitere: lookup (Tabelle mit linearer Interpolation), rands (Zufallszahlen).

// Punkte auf einem Kreis mit Winkelfunktionen (Winkel in Grad!)
r = 20;
for (i = [0 : 7]) {
    w = i * 45;
    translate([r * cos(w), r * sin(w), 0]) sphere(r = 2, $fn = 16);
}

// Abstand zweier Punkte mit norm() und Hilfsausgabe
a = [0, 0, 0];
b = [3, 4, 12];
echo(laenge = norm(b - a));            // 13
echo(gerundet = round(5.5), runter = floor(-2.5), rest = 17 % 5);

// Linie zwischen a und b als dünner Zylinder (Länge per norm)
// Ausrichtung per Winkel aus atan2
translate(a)
rotate([0, 0, atan2(b.y - a.y, b.x - a.x)])
rotate([0, 90 - asin(b.z / norm(b - a)), 0])
    cylinder(h = norm(b - a), r = 0.5, $fn = 12);

Die Kreispunkte entstehen mit cos und sin – beide erwarten Grad, nicht Bogenmaß. Das Beispiel ergibt echo-Ausgaben mit 13, 6, −3 und 2.

Alle Winkel in OpenSCAD sind Grad. Wer Bogenmaß-Formeln übernimmt, muss umrechnen.

Zum Selbermachen

Verteile zwölf Kugeln gleichmäßig auf einem Kreis.
Berechne mit norm() die Diagonale eines Quaders und gib sie per echo aus.

Quellen

OpenSCAD User Manual – Mathematical Operators (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Mathematical_Operators)
OpenSCAD User Manual – Mathematical Functions (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Mathematical_Functions)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Praxisprojekt: parametrische Box mit Deckel

Begriffe vorab

Wandstärke: Dicke der Außenwände.
Toleranz: Spiel zwischen Teilen, damit sie passen.
Parametrisch: Alle Maße hängen von wenigen Variablen ab.
Modul: Wiederverwendbarer Baustein.
Aufmaß: Zugabe, damit Passungen nach dem Druck funktionieren.

Ziel

Dieses Projekt führt die bisherigen Lektionen zusammen: Variablen, Module, boolesche Operationen, hull für Rundungen, for für Muster und Customizer-Kommentare. Es entsteht eine rechteckige Box mit Deckel, deren Maße sich über wenige Variablen ändern lassen. Der Entwurf ist ein eigenes Beispiel, keine Vorlage aus der Doku.

Vorgehen in Schritten

Parameter festlegen: Innenmaße, Wandstärke, Eckenradius, Toleranz.
Grundform bauen: ein Modul für einen abgerundeten Quader (hull über vier Zylinder).
Box = Außen minus Innen: difference() mit einem Innenkörper, der oben herausragt.
Deckel: eine Platte mit einer umlaufenden Lippe, die mit Toleranz in die Box passt.
Anordnen: beide Teile nebeneinander legen, damit sie sich drucken lassen.

/* [Maße] */
innen_b = 60;      // Innenbreite (mm)
innen_t = 40;      // Innentiefe (mm)
innen_h = 25;      // Innenhöhe (mm)
wand    = 2;       // [1:0.5:4]
radius  = 4;       // [0:1:10]
spiel   = 0.3;     // Toleranz zwischen Deckel und Box

/* [Hidden] */
$fn = 48;
eps = 0.01;

// Abgerundeter Quader (Ecken in der xy-Ebene)
module rundquader(b, t, h, r) {
    hull()
        for (x = [r, b - r], y = [r, t - r])
            translate([x, y, 0]) cylinder(h = h, r = r);
}

module box() {
    ab = innen_b + 2 * wand;
    at = innen_t + 2 * wand;
    difference() {
        rundquader(ab, at, innen_h + wand, radius + wand);
        translate([wand, wand, wand])
            rundquader(innen_b, innen_t, innen_h + 1, max(radius, 0.1));
    }
}

module deckel() {
    ab = innen_b + 2 * wand;
    at = innen_t + 2 * wand;
    // Platte
    rundquader(ab, at, wand, radius + wand);
    // Lippe, die mit Spiel in die Box passt
    translate([wand + spiel, wand + spiel, wand - eps])
        difference() {
            rundquader(innen_b - 2 * spiel, innen_t - 2 * spiel, 4, max(radius - spiel, 0.1));
            translate([wand, wand, -1])
                rundquader(innen_b - 2 * spiel - 2 * wand, innen_t - 2 * spiel - 2 * wand, 6, 0.1);
        }
}

box();
translate([0, innen_t + 2 * wand + 10, 0]) deckel();

Was du daraus lernst

Ableitungen statt Zahlen: Außenmaße ergeben sich aus Innenmaßen plus Wandstärke. Ändert sich ein Parameter, folgt der Rest.
Epsilon: Der Innenraum ragt über die Oberkante hinaus (innen_h + 1), die Lippe überlappt die Platte um eps.
Toleranz: Das Spiel von 0,3 mm ist ein Beispielwert; er hängt vom Drucker ab und muss ausprobiert werden.
Module: rundquader wird dreimal wiederverwendet.

Beginne jedes Projekt mit den Parametern: Wer erst baut und später parametrisiert, schreibt vieles doppelt.

Zum Selbermachen

Füge dem Deckel eine Griffmulde (abgezogene Kugel) hinzu.
Ergänze vier Schraubenlöcher in den Ecken per for-Schleife.

Quellen

OpenSCAD User Manual – Primitive Solids (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Primitive_Solids)
OpenSCAD User Manual – CSG Modelling (en.wikibooks.org/wiki/OpenSCAD_User_Manual/CSG_Modelling)
OpenSCAD User Manual – Customizer (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Customizer)
OpenSCAD User Manual – Tips and Tricks (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Tips_and_Tricks)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Sprachgrundlagen: Syntax, Variablen, Datentypen

Begriffe vorab

Anweisung: Eine Zeile, die mit einem Semikolon endet.
Variable: Benannter Wert, der beim Übersetzen des Skripts festgelegt wird.
Vektor: Geordnete Liste von Werten in eckigen Klammern.
Range: Wertebereich in der Form [start:ende] oder [start:schritt:ende].
Scope: Gültigkeitsbereich von Variablen, durch geschweifte Klammern begrenzt.

Kommentare und Anweisungen

Kommentare folgen der C++-Schreibweise: // bis Zeilenende und /* mehrzeilig */. Anweisungen enden mit einem Semikolon; Namen unterscheiden Groß- und Kleinschreibung.

Variablen sind keine Variablen

Der überraschendste Punkt: Variablen sind Bindungen zur Übersetzungszeit, keine veränderlichen Speicherplätze. Die Doku sagt: Wird eine Variable mehrfach zugewiesen, gilt nur der zuletzt zugewiesene Wert, und zwar an allen Stellen. Innerhalb desselben Scopes erzeugt das eine Warnung. Zur Laufzeit lässt sich nichts ändern – alle Variablen verhalten sich wie Konstanten. Das FAQ erklärt: OpenSCAD ist eine deklarative, funktionale Sprache; eine Anweisung wird einmal mit den Anfangsbedingungen übersetzt.

Datentypen

Zahlen: 64-Bit-Fließkomma, dezimal oder mit PI. Hexadezimale Konstanten nennt die Doku nur für Entwicklungs-Snapshots.
Wahrheitswerte: true und false. In Bedingungen gelten als „falsch“: false, 0, -0, "", [] und undef.
Zeichenketten: in doppelten Anführungszeichen, mit Escapes wie \", \\, \n, \t.
Ranges: [0:5] oder [0:0.5:5]. Mit Doppelpunkten, nicht Kommas – ein Range ist kein Vektor.
Vektoren: [1, 2, 3], auch verschachtelt; Zugriff über Index ab 0, die ersten drei Elemente zusätzlich als .x, .y, .z.
undef: Startzustand einer Variable oder Ergebnis ungültiger Aufrufe.

Scope

Geschweifte Klammern öffnen einen neuen Scope. Innen zugewiesene Variablen sind außerhalb unsichtbar. Jeder Durchlauf einer for-Schleife bekommt einen eigenen Scope. Seit Version 2015.03 sind Zuweisungen überall erlaubt, nicht nur oberhalb der Module.

breite = 30;          // Variable
hoehe  = breite / 2;  // aus anderer Variable berechnet
masse  = [breite, 20, hoehe];

echo(masse);          // Ausgabe in der Console
echo(masse.x, masse[2]);

cube(masse);

echo schreibt in die Console: [30, 20, 15] und danach 30, 15. Die Reihenfolge der Zuweisungen im Text ist hier egal, weil alles beim Übersetzen aufgelöst wird – aber lies die Regel „letzte Zuweisung gewinnt“ genau, bevor du Werte im Skript überschreibst.

Denke „Konstante mit späterem Wert“, nicht „Variable, die sich ändert“. Wer eine Schleifenvariable hochzählen will, braucht Rekursion oder List Comprehensions.

Zum Selbermachen

Weise einer Variable zwei verschiedene Werte zu und lies die Warnung in der Console.
Lege einen Vektor mit drei Zahlen an und gib .x, .y, .z per echo aus.

Quellen

OpenSCAD User Manual – General (en.wikibooks.org/wiki/OpenSCAD_User_Manual/General)
OpenSCAD User Manual – FAQ (en.wikibooks.org/wiki/OpenSCAD_User_Manual/FAQ)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Text im Modell: text() und Schriften

Begriffe vorab

text(): Erzeugt 2D-Text aus einer Zeichenkette.
Baseline: Grundlinie, an der Buchstaben stehen.
halign / valign: Horizontale und vertikale Ausrichtung.
Schriftname: Name mit optionalem Stil, z. B. „Liberation Sans:style=Bold“.
Extrusion: Gibt dem 2D-Text eine Höhe.

text() erzeugt 2D

text() liefert 2D-Geometrie. Für gedruckte Beschriftung wird er wie jede 2D-Form extrudiert: linear_extrude(4) text("Text");.

Parameter

text: die Zeichenkette.
size: Höhe, Standard 10. In westlicher Schrift sind Großbuchstaben ungefähr so hoch (die tatsächliche Höhe hängt von der Schrift ab).
font: logischer Schriftname, Standard „Liberation Sans“. Stil mit Doppelpunkt: "Liberation Sans:style=Bold Italic".
halign: "left" (Standard), "center", "right".
valign: "top", "center", "baseline" (Standard), "bottom".
spacing: Zeichenabstand, Standard 1.
direction: "ltr" (Standard), "rtl", "ttb", "btt".
language, script: Lokalisierung.
$fn, $fs, $fa: Kurvenunterteilung.

Ausrichtung

Mit valign = "baseline" sitzen verschiedene Texte wie auf liniertem Papier auf derselben Grundlinie; die anderen Optionen richten sich nach der Begrenzungsbox. Horizontal bezieht sich die Ausrichtung auf die linke, mittlere oder rechte Kante des Textes.

Schriften und Portabilität

Mitgeliefert und deshalb empfehlenswert für portable Modelle sind Liberation Mono, Liberation Sans und Liberation Serif. Welche Schriften dein System kennt, zeigt die Schriftenliste im Menü „Window“. Wer ein Modell weitergibt, sollte mitgelieferte Schriften verwenden, sonst sieht es auf anderen Rechnern anders aus.

// Namensschild: Platte mit erhabener Beschriftung
cube([60, 20, 3]);
translate([30, 10, 3])
    linear_extrude(2)
        text("OpenSCAD", size = 8, halign = "center", valign = "center",
             font = "Liberation Sans:style=Bold");

Die Platte ist 60 × 20 × 3, der Text sitzt mittig auf der Oberseite und ragt 2 Einheiten heraus. halign und valign auf „center“ machen die Positionierung leicht: Der Mittelpunkt des Textes liegt genau am verschobenen Punkt.

Die Doku merkt an, dass size auf einer historisch ungenauen Berechnung beruht: Die tatsächliche Höhe von Großbuchstaben kann je nach Schrift etwas kleiner ausfallen. Miss nach, wenn es auf Millimeter ankommt.

Zentriere Beschriftungen mit halign und valign auf „center“, statt Positionen auszuprobieren.

Zum Selbermachen

Beschrifte eine Platte mit deinem Namen und probiere drei Schriftstile.
Prüfe die tatsächliche Höhe eines Großbuchstabens mit der Messfunktion der Vorschau.

Quellen

OpenSCAD User Manual – Text (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Text)
OpenSCAD User Manual – 2D to 3D Extrusion (en.wikibooks.org/wiki/OpenSCAD_User_Manual/2D_to_3D_Extrusion)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Transformationen: translate, rotate, scale, mirror, color

Begriffe vorab

Transformation: Operation, die ihre Kind-Objekte verschiebt, dreht, skaliert oder färbt.
Kind-Objekt: Objekt, das direkt nach der Transformation folgt.
Rechte-Hand-Regel: Daumen entlang der positiven Achse, die Finger zeigen die Drehrichtung.
Affine Matrix: Matrix, die Verschiebung, Skalierung und Scherung vereint.
Alpha: Deckkraft einer Farbe von 0 bis 1.

Wirkung und Reihenfolge

Eine Transformation steht vor den Objekten, auf die sie wirkt. Mehrere Transformationen werden laut Doku von rechts nach links angewendet: Die der Geometrie nächste wirkt zuerst. Deshalb liefert translate(...) rotate(...) cube(...) etwas anderes als rotate(...) translate(...) cube(...).

translate und rotate

translate(v = [x, y, z]) verschiebt entlang eines Vektors. rotate([ax, ay, az]) dreht um die Achsen in Grad. Die Doku legt fest: Werden mehrere Achsen angegeben, dreht OpenSCAD erst um x, dann um y, dann um z. Zusätzlich gibt es rotate(a = Winkel, v = [x, y, z]) für eine beliebige Achse, und in 2D genügt rotate(45) – das dreht um die Z-Achse. Es gilt die Rechte-Hand-Regel.

scale, resize, mirror

scale([sx, sy, sz]) multipliziert die vorhandenen Maße mit Faktoren.
resize(newsize = [x, y, z]) setzt die Zielmaße. Eine 0 lässt die Dimension unverändert, auto = true skaliert Nullmaße proportional mit. Achtung: resize ist eine CGAL-Operation und rechnet auch in der Vorschau mit voller Geometrie.
mirror(v) spiegelt an einer Ebene durch den Ursprung mit Normalenvektor v. Es verdoppelt nichts, sondern spiegelt das Objekt.

multmatrix

multmatrix(m) wendet eine 4×3- oder 4×4-Matrix an (Skalierung, Scherung, Verschiebung in einer Matrix). Die vierte Zeile wird auf [0,0,0,1] gesetzt und darf fehlen.

color

Formen: color([r, g, b, a]) mit Werten von 0.0 bis 1.0, color([r, g, b], alpha = 1.0), color("#hexwert") (Formate #rgb, #rgba, #rrggbb, #rrggbbaa) und color("name", alpha) mit SVG-Farbnamen (Groß-/Kleinschreibung egal), dazu "transparent". Die Doku rät, transparente Formen nach den undurchsichtigen zu zeichnen, damit diese hindurch sichtbar bleiben.

// Reihenfolge zählt: rechts nach links
color("tomato")    cube(10);
color("steelblue") translate([20, 0, 0]) rotate([0, 0, 45]) cube(10);
color("seagreen")  rotate([0, 0, 45]) translate([20, 0, 0]) cube(10);

// Spiegeln und Skalieren
color("gold") translate([0, 40, 0]) {
    cube([10, 5, 5]);
    mirror([1, 0, 0]) cube([10, 5, 5]);
}
color("#8a2be2", 0.5) translate([30, 40, 0]) scale([1, 2, 0.5]) sphere(r = 8);

Das blaue Quadrat wird erst gedreht und dann verschoben (die Drehung wirkt zuerst um den Ursprung und dann um die Würfelecke), das grüne umgekehrt: erst verschieben, dann um den Ursprung drehen – es landet an einer ganz anderen Stelle.

Wenn ein Objekt „an der falschen Stelle“ landet, ist meist die Reihenfolge von translate und rotate vertauscht.

Zum Selbermachen

Vertausche translate und rotate im Beispiel und beschreibe, was sich ändert.
Färbe ein Objekt halbtransparent und lege ein undurchsichtiges dahinter.

Quellen

OpenSCAD User Manual – Transformations (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Transformations)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Was ist OpenSCAD? Arbeitsweise und Oberfläche

Begriffe vorab

OpenSCAD: Programm, das 3D-Körper aus Skripten (Text) erzeugt statt per Mausmodellierung.
Skript: Textdatei mit der Endung .scad, die das Modell beschreibt.
Vorschau (Preview): Schnelle Darstellung des Modells beim Bearbeiten (F5).
Rendern: Vollständige Berechnung der Geometrie für den Export (F6).
Console: Ausgabebereich für Meldungen, Warnungen und echo()-Ausgaben.

Das Grundprinzip

In OpenSCAD beschreibst du ein Modell als Text: Du nennst Körper (Würfel, Zylinder, Kugel), verschiebst und drehst sie und kombinierst sie durch Vereinigen, Abziehen oder Schneiden. Das Ergebnis berechnet das Programm aus dem Skript. Ändert sich eine Zahl, entsteht beim nächsten Durchlauf ein neues Modell – das macht parametrische Konstruktionen einfach. Die Doku-Landkarte auf openscad.org gliedert sich in Tutorial, User Manual, Sprachreferenz und Cheat Sheet (siehe Literaturlektion).

Die Oberfläche

Laut User Manual gibt es drei Standardbereiche: den Model Viewing Pane (3D-Ansicht), den Console Output Pane (Statusmeldungen) und die Text Editor Tabs. Weitere Bereiche wie Customizer, Schriftenliste und Viewport-Steuerung blendest du über das Menü „Window“ ein. Der Editor bietet Syntaxhervorhebung, Suchen und Ersetzen, Codevorlagen und das interaktive Ändern von Zahlen mit den Pfeiltasten oder dem Mausrad.

Vorschau und Rendern

Die Vorschau aktualisierst du mit Design → Preview (F5), das vollständig berechnete Modell erhältst du mit Design → Render (F6). Die Vorschau ist für schnelles Feedback gedacht, das Rendern erzeugt die endgültige Geometrie, die du exportierst. Das ist die wichtigste Gewohnheit: in der Vorschau arbeiten, vor dem Export rendern und prüfen.

Ansicht bewegen

Drehen: linke Maustaste ziehen.
Verschieben: rechte Maustaste ziehen.
Zoomen: Mausrad oder Shift plus mittlere/rechte Maustaste ziehen.
Drehpunkt setzen: Doppelklick auf die Geometrie.
Hilfen: Achsen ein-/ausblenden mit Strg+2, Fadenkreuz mit Strg+3 (Angaben aus dem User Manual).

Einheiten und Versionen

Das FAQ nennt Millimeter als Standardeinheit. Zu den Versionen: Die Downloadseite bietet Stabilversionen für macOS, Windows, Linux (inkl. AppImage), BSD sowie Snap Store und Flathub und daneben Entwicklungs-Snapshots („nightly“) mit neuen Funktionen, darunter einer experimentellen Manifold-Geometrie-Engine. Das Cheat Sheet bezieht sich auf Version 2021.01. In dieser Themenwelt steht bei Funktionen ausdrücklich dabei, wenn die Doku sie nur für Entwicklungs-Snapshots oder erst ab einer bestimmten Version nennt.

Ein erstes Modell

// Ein Würfel mit einer Kugel obendrauf
cube(20);
translate([10, 10, 20])
    sphere(r = 8);

Der Würfel hat die Kantenlänge 20 und steht mit einer Ecke im Ursprung. Die Kugel wird um 10, 10 und 20 Einheiten verschoben und sitzt dadurch mittig auf der Oberseite. Die Transformation steht vor dem Objekt, auf das sie wirkt.

Arbeite in der Vorschau, aber rendere (F6) vor jedem Export – nur das gerenderte Modell zeigt, was wirklich entsteht.

Zum Selbermachen

Gib das erste Modell ein, drücke F5 und drehe die Ansicht mit der Maus.
Ändere die Zahl 20 beim Würfel und beobachte, wie das Modell mitwandert.

Quellen

OpenSCAD User Manual – The OpenSCAD User Interface (en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_User_Interface)
OpenSCAD User Manual – FAQ (en.wikibooks.org/wiki/OpenSCAD_User_Manual/FAQ)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)
OpenSCAD – Downloads (openscad.org/downloads.html)
OpenSCAD – Dokumentation (openscad.org/documentation.html)

Zwischen 2D und 3D: Extrusion und Projektion

Begriffe vorab

linear_extrude: Zieht eine 2D-Form entlang der Z-Achse zu einem Körper.
rotate_extrude: Dreht eine 2D-Form um die Z-Achse zu einem Rotationskörper.
twist: Verdrehung während der Extrusion in Grad.
slices: Zwischenschritte entlang der Extrusion.
projection: Wandelt einen 3D-Körper in eine 2D-Form um.

linear_extrude()

Parameter: height (positiv), center (zentriert um Z = 0), twist (Verdrehung in Grad), scale (Skalierung über die Höhe, Zahl oder Vektor), slices (Zwischenebenen), convexity (Renderhinweis) und $fn. Wichtig: Die Doku verlangt benannte Parameter wegen einer Abwärtskompatibilität. Bei einem Vektor als scale können die Seitenwände unebene Flächen bekommen; empfohlen wird twist = 0 mit passender slices-Zahl.

rotate_extrude()

Parameter: angle (Standard 360, Rechte-Hand-Regel), convexity und die Auflösungsvariablen. Die Doku nennt außerdem start (Startwinkel), aber nur für Entwicklungs-Snapshots. Zwingende Regel: Die 2D-Form muss vollständig auf einer Seite der Y-Achse liegen (empfohlen: rechts, also x ≥ 0). Berührt sie die Achse, muss das eine Linie sein, kein Punkt. Schrauben oder Gewinde sind damit nicht zuverlässig herstellbar.

// Verdrehter Stab
linear_extrude(height = 30, twist = 90, slices = 40, convexity = 5)
    translate([4, 0]) square([8, 3], center = true);

// Rotationskörper: Vase aus einem Halbprofil
translate([40, 0, 0])
rotate_extrude($fn = 64)
    polygon([[0,0],[10,0],[12,15],[8,30],[9,32],[0,32]]);

// Ring mit 270 Grad
translate([80, 0, 0])
rotate_extrude(angle = 270, $fn = 48)
    translate([8, 0]) circle(r = 3, $fn = 24);

Die Vase ist ein Halbprofil, das nur auf der rechten Seite der Y-Achse liegt. Beim Ring wird ein kleiner Kreis um 8 Einheiten nach rechts verschoben (x ≥ 0) und dann um 270° gedreht.

projection()

projection(cut = false) erzeugt aus einem 3D-Körper eine 2D-Zeichnung in der xy-Ebene bei z = 0. Mit cut = true werden nur Punkte bei z = 0 betrachtet – ein Schnitt, der eine Scheibe liefert. Mit cut = false (Standard) werden auch Punkte darüber und darunter einbezogen – ein echter Schattenwurf. Für Seitenansichten dreht man das Modell vorher und verschiebt es aus der Ebene. Das Ergebnis lässt sich als DXF exportieren.

// Schnitt (cut = true) und Silhouette (cut = false) einer Kugel
module koerper() { translate([0, 0, 4]) sphere(r = 10, $fn = 48); }

projection(cut = true)  koerper();                        // Kreis mit Radius ~9,2
translate([30, 0, 0]) projection(cut = false) koerper();  // Kreis mit Radius 10

Im Beispiel liegt der Kugelmittelpunkt über der Ebene z = 0: Der Schnitt ist kleiner als die volle Silhouette. Das Ergebnis ist 2D: Exportiere es als SVG oder DXF, nicht als STL (ein reines 2D-Ergebnis lässt sich nicht als STL ausgeben).

Rotationskörper brauchen immer ein halbes Profil – denke von der Drehachse nach außen.

Zum Selbermachen

Zeichne das Profil einer Schachfigur und drehe es per rotate_extrude.
Wandle ein beliebiges 3D-Modell per projection(cut = true) in einen Schnitt um.

Quellen

OpenSCAD User Manual – 2D to 3D Extrusion (en.wikibooks.org/wiki/OpenSCAD_User_Manual/2D_to_3D_Extrusion)
OpenSCAD User Manual – 3D to 2D Projection (en.wikibooks.org/wiki/OpenSCAD_User_Manual/3D_to_2D_Projection)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Maker & DIY

Maker & DIY

2D-Formen: square, circle, polygon

Begriffe vorab

Warum 2D?

square()

circle()

polygon()

Zum Selbermachen

Verwandte Themen

Quellen

3D-Primitive: cube, sphere, cylinder, polyhedron

Begriffe vorab

cube()

sphere()

cylinder()

polyhedron()

Zum Selbermachen

Verwandte Themen

Quellen

Auflösung steuern: $fn, $fa, $fs

Begriffe vorab

Kreise sind Vielecke

Die Formel

Empfehlungen der Doku

Warum Löcher zu klein werden

Zum Selbermachen

Verwandte Themen

Quellen

Bewährte Rezepte: Muster, Verrundungen, Hüllenketten

Begriffe vorab

Rezept 1: Lineare und rechteckige Muster

Rezept 2: Weiche Übergänge mit Hüllenketten

Rezept 3: Verrundungen

Rezept 4: Mit Listen konstruieren

Rezept 5: Tap-Muster für echo

Zum Selbermachen

Verwandte Themen

Quellen

Boolesche Operationen: union, difference, intersection

Begriffe vorab

Die drei Operationen

Die wichtigste Regel: keine deckungsgleichen Flächen

render()

Denkweise

Zum Selbermachen

Verwandte Themen

Quellen

Der Customizer: Parameter ohne Code ändern

Begriffe vorab

Wozu?

Welche Variablen erscheinen?

Steuerelemente per Kommentar

Gruppen und Parametersets

Zum Selbermachen

Verwandte Themen

Quellen

Fehlersuche: Modifier-Zeichen, Z-Fighting und saubere Geometrie

Begriffe vorab

Die vier Modifier-Zeichen

Z-Fighting und deckungsgleiche Flächen

Löcher, die nicht stimmen

Nicht-manifold

Ausgabe zur Fehlersuche

Zum Selbermachen

Verwandte Themen

Quellen

Hüllen, Minkowski-Summe und Rundungen

Begriffe vorab

hull()

minkowski()

offset() (2D)

fill()

Zum Selbermachen

Verwandte Themen

Quellen

Import und Export: Dateiformate

Begriffe vorab

import()

Importierbare Formate laut Doku