OpenSCAD für Anfänger – Teil 3: Grundkörper mit cube(), cylinder() und sphere()

Voraussetzungen

Du brauchst OpenSCAD und die Grundlagen aus Teil 2 des Kurses.

Im vorherigen Teil haben wir gelernt, wie Variablen, Kommentare und einfache Berechnungen in OpenSCAD verwendet werden.

Jetzt beschäftigen wir uns mit den wichtigsten dreidimensionalen Grundkörpern.

Dazu gehören:

cube();
cylinder();
sphere();

Diese drei Grundformen bilden die Grundlage für sehr viele spätere Konstruktionen.

Lernziel: Nach dieser Lektion kannst du Quader, Zylinder und Kugeln erzeugen, ihre Abmessungen parametrisch steuern und die Auflösung runder Geometrien beeinflussen.

Der Quader mit `cube()`

Den Befehl cube() kennen wir bereits aus den vorherigen Lektionen.

Ein einfacher Würfel entsteht mit:

cube(20);

Das Ergebnis ist ein Würfel mit einer Kantenlänge von 20 mm.

Für einen Quader können wir drei Abmessungen angeben:

cube([40, 30, 10]);

Die Werte stehen für:

Wert	Bedeutung
40	X-Richtung
30	Y-Richtung
10	Z-Richtung

Der Quader besitzt damit die Abmessungen:

40 × 30 × 10 mm

Quader parametrisch aufbauen

Wie bereits in Teil 2 gezeigt, lassen sich die Maße in Variablen speichern:

breite = 40;
tiefe = 30;
hoehe = 10;

cube([breite, tiefe, hoehe]);

Der Vorteil:

Die Maße des Modells lassen sich später an einer zentralen Stelle ändern.

Der Parameter `center`

Ein interessanter Parameter von cube() ist center.

Standardmäßig wird der Quader so erzeugt:

cube([40, 30, 10], center=false);

Dabei beginnt der Körper am Ursprung und wächst in positive X-, Y- und Z-Richtung.

Mit:

cube([40, 30, 10], center=true);

wird der Körper um den Ursprung herum zentriert.

Diese Funktion wird später sehr hilfreich, wenn mehrere Körper exakt zueinander ausgerichtet werden sollen.

Der Zylinder mit `cylinder()`

Mit cylinder() erzeugen wir einen Zylinder.

Ein einfaches Beispiel:

cylinder(h=20, d=30);

Die Parameter bedeuten:

Parameter	Bedeutung
`h`	Höhe
`d`	Durchmesser

In diesem Beispiel entsteht also ein Zylinder mit:

20 mm Höhe
30 mm Durchmesser

Radius statt Durchmesser

Alternativ zum Durchmesser kann der Radius verwendet werden:

cylinder(h=20, r=15);

Da ein Radius von 15 mm einem Durchmesser von 30 mm entspricht, erzeugen beide Befehle denselben Körper.

cylinder(h=20, d=30);

und:

cylinder(h=20, r=15);

Für technische Modelle ist der Durchmesser häufig besonders praktisch, da Bohrungen, Wellen und andere Maße in technischen Zeichnungen oft ebenfalls über den Durchmesser beschrieben werden.

Parametrischer Zylinder

Auch der Zylinder lässt sich sehr einfach parametrisch aufbauen:

durchmesser = 30;
hoehe = 20;

cylinder(h=hoehe, d=durchmesser);

Ändern wir später einen dieser Werte, wird automatisch eine neue Variante erzeugt.

OpenSCAD-Code mit Durchmesser 30 und Höhe 20 sowie die Vorschau des parametrischen Zylinders. — Der Zylinder übernimmt Durchmesser und Höhe aus den Variablen im Editor.

Die Kugel mit `sphere()`

Eine Kugel wird mit sphere() erzeugt.

Beispiel:

sphere(d=30);

Das Ergebnis ist eine Kugel mit 30 mm Durchmesser.

Alternativ können wir wieder den Radius verwenden:

sphere(r=15);

Warum runde Formen aus Segmenten bestehen

Ein Computer stellt eine runde Oberfläche nicht als mathematisch unendlich glatte Fläche dar.

Stattdessen besteht die Oberfläche aus vielen kleinen geraden Segmenten.

Das lässt sich sehr gut sichtbar machen:

sphere(d=30, $fn=12);

Mit nur 12 Segmenten wirkt die Kugel deutlich kantig.

Erhöhen wir den Wert:

sphere(d=30, $fn=64);

wird die Oberfläche wesentlich glatter.

Kugel mit deutlich sichtbaren polygonalen Flächen bei einer OpenSCAD-Auflösung von $fn=12. — Mit $fn=12 bleibt die Kugel deutlich kantig.

Kugel mit wesentlich feinerer Oberfläche bei einer OpenSCAD-Auflösung von $fn=64. — Mit $fn=64 wird dieselbe Kugel feiner aufgelöst; einzelne Flächen bleiben in der Darstellung erkennbar.

`$fn` beim Zylinder

Das gleiche Prinzip gilt auch für Zylinder:

cylinder(h=20, d=30, $fn=12);

wirkt deutlich polygonal.

Mit:

cylinder(h=20, d=30, $fn=64);

wird die Mantelfläche wesentlich glatter.

Was bedeutet `$fn`?

$fn gibt vereinfacht gesagt an, wie viele Segmente für eine Rundung verwendet werden.

Ein niedriger Wert bedeutet:

weniger Segmente
gröbere Rundung
schnellere Berechnung

Ein hoher Wert bedeutet:

mehr Segmente
glattere Oberfläche
höherer Rechenaufwand

Für einfache Modelle kann ein Wert wie:

$fn=64

bereits eine sehr gute Darstellung liefern.

Mit der optimalen Qualität und Performance beschäftigen wir uns später im Kurs noch ausführlicher.

Ein erster parametrischer Abstandshalter

Jetzt erstellen wir ein kleines Praxisbeispiel.

Der Abstandshalter soll folgende Maße besitzen:

Parameter	Wert
Außendurchmesser	15 mm
Höhe	20 mm
spätere Bohrung	5 mm

Wir beginnen mit dem äußeren Körper:

aussen_d = 15;
hoehe = 20;

cylinder(
    h=hoehe,
    d=aussen_d,
    $fn=64
);

Bohrung bereits als Parameter vorbereiten

Die eigentliche Bohrung schneiden wir in dieser Lektion noch nicht aus.

Wir können den Parameter aber bereits definieren:

aussen_d = 15;
bohrung_d = 5;
hoehe = 20;

cylinder(
    h=hoehe,
    d=aussen_d,
    $fn=64
);

Später verwenden wir bohrung_d, um den Innenbereich aus dem äußeren Zylinder herauszuschneiden.

So entsteht aus dem einfachen Zylinder ein echter Abstandshalter.

Die wichtigsten Grundkörper im Überblick

Befehl	Grundkörper	Typische Verwendung
`cube()`	Würfel / Quader	Platten, Gehäuse, Halter
`cylinder()`	Zylinder	Abstandshalter, Wellen, Bohrungsgeometrien
`sphere()`	Kugel	Rundungen, Gelenke, dekorative Formen

Sehr viele komplexere OpenSCAD-Modelle entstehen später dadurch, dass genau solche einfachen Grundkörper kombiniert, verschoben, gedreht oder voneinander abgezogen werden.

Mitmach-Aufgabe

Erstelle drei parametrische Grundkörper.

Aufgabe 1 – Quader

Parameter	Wert
Breite	60 mm
Tiefe	40 mm
Höhe	8 mm

Aufgabe 2 – Zylinder

Parameter	Wert
Durchmesser	25 mm
Höhe	30 mm

Aufgabe 3 – Kugel

Parameter	Wert
Durchmesser	35 mm

Verwende jeweils sinnvolle Variablennamen.

Musterlösung

Eine mögliche Lösung könnte so aussehen:

// -------------------------
// Quader
// -------------------------

breite = 60;
tiefe = 40;
hoehe_quader = 8;

cube([breite, tiefe, hoehe_quader]);


// -------------------------
// Zylinder
// -------------------------

zylinder_d = 25;
zylinder_h = 30;

cylinder(
    h=zylinder_h,
    d=zylinder_d,
    $fn=64
);


// -------------------------
// Kugel
// -------------------------

kugel_d = 35;

sphere(
    d=kugel_d,
    $fn=64
);

Hinweis: Da alle drei Körper am gleichen Ursprung erzeugt werden, können sie sich in dieser Darstellung zunächst überlagern. Das ist völlig normal.

Im nächsten Teil lernen wir, wie wir die Körper gezielt im Raum positionieren.

Was haben wir gelernt?

Nach dieser Lektion kennst du die drei wichtigsten 3D-Grundkörper von OpenSCAD:

cube();
cylinder();
sphere();

Du weißt außerdem:

wie ein Quader über X, Y und Z definiert wird
wie center=true funktioniert
wie Zylinder über Höhe und Durchmesser aufgebaut werden
dass Radius und Durchmesser alternativ verwendet werden können
wie Kugeln erzeugt werden
dass runde Geometrien aus Segmenten bestehen
wie $fn die Auflösung beeinflusst
wie auch diese Grundkörper parametrisch aufgebaut werden können

Damit haben wir die wichtigsten geometrischen Bausteine für unsere nächsten Konstruktionen vorbereitet.

Im nächsten Teil

Im vierten Teil geht es darum, diese Grundkörper gezielt im Raum anzuordnen.

Dazu lernen wir:

translate();
rotate();

Mit translate() können wir Objekte verschieben.

Mit rotate() können wir sie drehen.

Damit können wir erstmals mehrere Grundkörper sinnvoll kombinieren und beispielsweise eine einfache Halterung aufbauen.

Passendes Cheatsheet

Im Cheatsheet „Grundbefehle und Syntax“ findest du die Befehle dieser Lektion kompakt zum Nachschlagen. Du kannst das Cheatsheet auch direkt als PDF herunterladen.