OpenSCAD

https://www.openscad.org/

Il est disponible en paquet dans Debian, etc.

https://www.openscad.org/documentation.html

https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_Language

Langage de programmation assez simple, avec pas mal de primitives existantes.

On finit les lignes par un point virgule. Les commentaires sont comme en C (/ et /* *). L'indentation est libre.

Les fonctions prennent des paramètres, parfois optionnels, qu'on peut nommer ou pas.

On peut préfixer plein de commandes par des transformations (translation, rotation, scaling, etc), voir plus loin.

https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_Language#Primitive_Solids

Créer une sphère de rayon 50mm :

sphere(r=50);

Par défaut, la sphère est moche. On va augmenter la résolution avec le paramètre optionnel $fn (en gros le nombre de faces sur un périmètre). Plus on augmente $fn, plus ce sera joli mais plus le rendu sera lourd. Inutile de mettre trop si on imprime avec du fil de 0.4mm. https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_Language#Special_variables_2

La sphère est centrée à l'origine, on peut aussi la déplacer :

translate([0,0,50])
  sphere(r=50, $fn=20);

On rajoute un cylindre qui sert de pied à la sphère. On veut que ce cylindre soit plus large à la base (20mm de rayon) qu'en haut (18mm) :

cylinder(h=5, r1=20, r2=18, center=false);

Il n'y a pas besoin de dire qu'on veut "ajouter" ces 2 objets, c'est le comportement par défaut (voir union() plus loin).

https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_Language#difference

On va faire un bol à partir de notre sphère.

Pour enlever la moitié supérieure, on crée un cube qui contient cette partie :.

translate([0,0,100])
  cube(size=110, center=true);

Puis on le soustrait à la sphère :

difference() {
  translate([0,0,50])
    sphere(r=50, $fn=20);
  translate([0,0,100])
    cube(size=110, center=true);
}

Pour enlever l'intérieur, on va créer une sphère centrée au même endroit mais plus petite :

translate([0,0,50])
  sphere(r=45, $fn=20);

On peut la soustraire au résultat de l'opération précédente:

difference() {
  difference() {
    translate([0,0,50])
      sphere(r=50, $fn=20);
    translate([0,0,100])
      cube(size=110, center=true);
  }
  translate([0,0,50])
   sphere(r=45, $fn=20);
}

ou directement soustraire les deux mais attention à la syntaxe des blocs :

difference() {
  translate([0,0,50])
    sphere(r=50, $fn=20);
  {
    translate([0,0,100])
      cube(size=110, center=true);
    translate([0,0,50])
      sphere(r=45, $fn=20);
  }
}

Attention, on ne peut pas soustraire 2 objets à 2 autres avec cette syntaxe : difference() {{A B}{C D}} est interpreté comme difference() {A {B C D}} Voir les modules plus loin pour éviter ça, ou utiliser un union explicite : difference() { union() {A B} union() {C D} }.

https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_Language#Chapter_7_--_User-Defined_Functions_and_Modules

On peut créer des modules pour construire des objets, calculer des choses, ou un opérateur.

Il peuvent éventuellement prendre des paramètres :

module mafonction(x, ...) {
};

Les modules permettent notamment de grouper des objets pour factoriser le code. Exemple pour éviter les problèmes de syntaxe des blocs dans les différences :

module corps() {
  translate([0,0,50])
    sphere(r=50, $fn=20);
  cylinder(h=5, r1=20, r2=18, center=false);
};

module a_soustraire() {
  translate([0,0,100])
    cube(size=110, center=true);
  translate([0,0,50])
    sphere(r=45, $fn=20);
};

difference() {
  corps();
  a_soustraire();    
};

Quand on manipule les différences, on veut parfois afficher la partie soustraire pour la vérifier. Ici, il suffit de rappeler ce module à la fin du code pour l'ajouter au modèle :

a_soustraire();

Surtout les modules permettent de réutiliser des objets. Par exemple pour créer 2 bols à des endroits différents:

module bol(x,y) {
  translate([x,y,0])
    difference() {
      corps();
      a_soustraire();    
    };
};

bol(50,100);
bol(100,100);

https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_Language#Chapter_4_--_Transform

Ajouter des prefixes devant les objets permet de les transformer :

translate([50,50,0])
  rotate([10,0,115])
  scale([1.5,1,0.5])
  bol(0,0);

Oh une coupelle !!!

Les transformations sont appliquées de la droite vers la gauche, comme une composée de fonctions. Donc ici, d'abord on agrandit, puis on tourne, puis on déplace. C'est l'ordre le plus simple à utiliser en général.

Si on inverse, ça ne donne pas le même résultat, notamment parce que les rotations et scaling sont appliqués par rapport aux origines de l'espace:

scale([1.5,1,0.5])
  rotate([10,0,115])
  translate([50,50,0])
  bol(0,0);

On peut également créer des opérateurs pour de nouvelles transformations. Par exemple, à partir de l'opérateur mirror() pour appliquer une symétrie, on peut créer une duplication symétrique par rapport à l'axe Z:

module mirror_copy_z() {
    children();
    mirror([0,0,1]) children();
};

mirror_copy_z() bol(0,0);

Oh un diabolo !!!

https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_Language#Variables

On peut définir des variables globales ou locales aux fonctions :

rayon = 50;
epaisseur = 5;

difference() {
  marge = 10; /* pour etre que la sphere est inclue dans le cube */
  translate([0,0,rayon])
    sphere(r=rayon, $fn=20);
  {
    translate([0,0,2*rayon])
      cube(size=2*rayon+marge, center=true);
    translate([0,0,rayon])
      sphere(r=rayon-epaisseur, $fn=20);
  }
}

L'extrusion consiste à définir un objet 2D comme base d'un objet 3D.

Eviter les angles trop saillants, ca peut être difficile à imprimer, notamment si la pièce repose dessus.

La doc est très complète : https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_Language