Chapitre 1 -- Généralités[modifier | modifier le wikicode]

Introduction[modifier | modifier le wikicode]

OpenSCAD est un programme de conception paramétrique 2D/3D, basé sur un langage de programmation fonctionnel utilisé pour créer des modèles (^en) prévisualiser à l'écran, et générer un maillage 3D qui permet au modèle d'être exporter dans une variété de formats de fichier 2D/3D.

Un script en langage OpenSCAD est utilisé pour créer des modèles 2D ou 3D. Ce script est une liste de déclaration d'actions et d'opérateurs.

 object();
 variable = value;
 operator()   action();
 operator() { action();    action(); }
 operator()   operator() { action(); action(); }
 operator() { operator()   action();
              operator() { action(); action(); } }

Objets

Les objets sont les blocs de construction des modèles, créer avec des primitives 2D et 3D. Les objets se terminent par un point-virgule ;.

Actions

Les déclarations d'actions regroupent la création d'objets utilisant des primitives et l'assignation de valeurs à des variables. Les déclarations d'actions se terminent aussi par un point-virgule ;.

Opérateurs

Les opérateurs, ou les transformations, modifient l'emplacement, la couleurs ou d'autres propriétés des objets. Les opérateurs utilisent des accolades {...} quand leur portée couvre plus d'une action. Plus d'un opérateur peut être utilisés pour la même action ou le même groupe d'action. Les opérateurs multiples sont traités de droite à gauche, c'est-à-dire que l'opérateur le plus proche de l'action est appliqué en premier. Les opérateurs ne sont pas terminés par des points-virgules, mais les actions individuelles qu'ils contiennent le sont bien.

Exemples :

 cube(5);
 x = 4+y;
 rotate(40) square(5,10);
 translate([10,5]) { circle(5); square(4); }
 rotate(60) color("red") { circle(5); square(4); }
 color("blue") { translate([5,3,0]) sphere(5); rotate([45,0,45]) { cylinder(10); cube([5,6,7]); } }

Les commentaires[modifier | modifier le wikicode]

Les commentaires sont un moyen de laisser des notes dans le script, ou le code, (soit pour vous-même soit pour les autres programmeurs) décrivant comment le code fonctionne, ou ce qu'il fait. Les commentaires ne sont pas évaluer par le compilateur, et ne devraient pas être utilisé pour décrire du code évident.

OpenSCAD utilise la même syntaxe pour les commentaires qu'en C/C++.

 // Ceci est un commentaire
 
 maVariable = 10; // Le reste de la ligne est un commentaire
 
 /*
    Les commentaires mutli-lignes
    peuvent s'étendre sur plusieurs lignes.
 */

Les valeurs et les types de données[modifier | modifier le wikicode]

Une valeur dans OpenSCAD est soit un nombre (comme 42), soit un booléen (comme true), soit une chaîne de caractères (comme "foo"), soit un intervalle (comme [0:1:10]), soit un vecteur (comme [1,2,3]), ou soit une valeur indéfinie (undef). Les valeurs peuvent être stockées dans des variables, transmises comme arguments à des fonctions, et retournés comme des résultats de fonctions.

[OpenSCAD est un langage typé dynamiquement avec un ensemble fixe de types de données. Il n'y a pas de types prédéfinis ou définis par l'utilisateur. Les fonctions ne sont pas des valeurs. En réalité, les variables et les fonctions utilisent des espaces de nomes séparés.]

Les nombres[modifier | modifier le wikicode]

Les nombres sont le type de valeur le plus important dans OpenSCAD, et ils sont écrits dans la notation décimal classique comme dans d'autres langages. Exemple : -1, 42, 0.5, 2.99792458e+8. [OpenSCAD ne supporte pas les notations hexadécimales ou octales pour les nombres.]

En plus des nombres décimaux, les noms suivants pour des nombres spéciaux sont définis :

PI

Le langage OpenSCAD ne possède qu'une seule sorte de nombre, qui un nombre à virgule flottante de 64 bits IEEE. [OpenSCAD ne différencie pas les nombres entiers et à virgule flottante comme deux types différents, ni ne supporte les nombre complexes. Puisque OpenSCAD utilise le standart IEEE de virgule flottante, il y a quelques écarts par rapport au comportement des nombres en mathématique :

Nous utilisons des virgules flottantes binaires. Un nombre fractionnaire n'est pas représenté à moins que le dénominateur ne soit une puissance de 2. Par exemple, 0.2 (2/10) n'a pas de représentations interne exacte, mais 0.25 (1/4) et 0.125 (1/8) sont représentés précisément.
Le plus grand nombre représentable est un peu près 1e308. Si un résultat numérique est trop grand, alors le résultat peut être 'infinity' (représenté par "inf" par ECHO).
Le plus petit nombre représentable est un peu près -1e308. Si un résultat numérique est trop petit, alors le résultat peut être '-infinity' (représenté par "-inf" par ECHO).
Si un résultat numérique est invalide, alors le résultat peut être 'Not A Number' (représenté par "nan" par ECHO).
Si un résultat numérique non-nul est trop de zéro pour être représenté, alors le résultat sera -0 si le résultat est négatif, ou sinon le résultat sera 0. Le zéro (0) et le zéro négatif (-0) sont traités comme deux nombres distincts par certaines opérations mathématiques et sont représentés différemment par ECHO, bien qu'ils soient également comparables.

Noter que "inf", "-inf" et "nan" ne sont pas définis comme des constantes numériques par OpenSCAD, même si vous pouvez calculer des nombres qui sont affichés de cette façon par ECHO. Vous pouvez définir des variables avec ces valeurs comme ceci :

inf = 1e200 * 1e200;
nan = 0 / 0;
echo(inf,nan);

Notez que "nan" est la seule valeur OpenSCAD qui n'est égale à aucune autre valeur, pas même elle-même. Bien que vous pouvez vérifier si une variable x a la valeur indéfinie en utilisant x == undef, vous ne pouvez pas utiliser x == 0/0 pour vérifier si x est 'Not A Number'. À la place, vous devez utiliser x != x pour vérifier si x est "nan".

Les valeurs booléennes[modifier | modifier le wikicode]

Les booléens sont des valeurs de vérité. Il y a deux valeurs booléennes, nommées true et false. Un booléen est passé comme argument à la déclaration conditionnelle if (...), à l'opérateur conditionnel ternaire ... ? ... : ... et aux opérateurs logiques ! (not/non), && (and/et), et || (or/ou). Dans tous ces contextes, vous pouvez passez n'importe quelles quantités. La plupart des valeurs sont converties en true dans un contexte booléen, les valeurs converties en false sont :

false,
0 et -0,
"",
[],
et undef.

Notez que les expressions "false" (la chaîne de caractères), [0] (un vecteur numérique), [ [] ] (un vecteur contenant un vecteur vide), [false] (un vecteur contenant la valeur booléenne fausse) et 0/0 (Not A Number) valent toutes vraies.

Les chaînes de caractères[modifier | modifier le wikicode]

Une chaîne de caractères est une séquence de zéro ou plusieurs caractères Unicode. Les chaînes de caractères sont utilisées pour spécifier les noms de fichiers lors de l'importation d'un de ces derniers, et pour afficher du texte pour débugger à l'aide de echo(). Les chaînes de caractères peuvent aussi être utilisées avec la nouvelle primitive text() ajoutée dans la version 2015.03. Une chaîne de caractères littérale est écrite comme une séquence de caractères isolée entre des doubles guillemets ", comme ceci : "" (une chaîne de caractères vide) ou "Ceci est une chaîne de caractères".

Pour ajouter des doubles guillemets " dans une chaîne de caractères littérale, utilisez \". Pour ajouter une barre oblique inversée \ (antislash) dans une chaîne de caractères littérale, utilisez \\. Les séquences d'échappement suivantes commençant par des \ peuvent être utilisés à l'intérieur de chaînes de caractères littérale :

\" → ",
\\ → \,
\t → une tabulation (quatre espaces),
\n → un retour à la ligne,
\r → un retour chariot,
\u03a9 → Ω.

Voyez la fonction text() pour de plus amples informations sur les caractères Unicode.

Note : Ce comportement est nouveau depuis la version 2011.04. Vous pouvez mettre à jour des fichiers plus vieux en utilisant la commande sed suivante : sed 's/\\/\\\\/g' non-escaped.scad > escaped.scad.

Exemple :

 echo("Le rapide renard brun \tsaute \"au-dessus\" du chien paresseux.\rLe rapide renard brun.\nLe chien \\paresseux\\.");

Résultat :

 ECHO: "Le rapide renard brun     saute "au-dessus" du chien paresseux.
 Le rapide renard brun.
 Le chien \paresseux\."

Ancien résultat :

 ECHO: "Le rapide renard brun     saute "au-dessus" du chien paresseux.
 Le rapide renard brun.\n  Le chien \paresseux\."

Les intervalles[modifier | modifier le wikicode]

Les intervalles sont utilisées dans les [[| boucles for()]] et dans [[| children()]]. Il existe deux variantes :

 [<début>:<fin>]
 [<début>:<pas>:<fin>]

Malgré le fait qu'ils soient entourés de crochets, ce ne sont pas des vecteurs. Ils utilisent le deux-points ':' plutôt que des points-virgules.

 r1 = [0:10];
 r2 = [0.5:2.5:20];
 echo(r1); // ECHO: [0: 1: 10]
 echo(r2); // ECHO: [0.5: 2.5: 20]

Vous devriez éviter les valeurs de pas qui ne peuvent pas être représentées exactement par un nombre binaire à virgule flottante. Les entiers sont ok, tout comme les valeurs fractionnaires dont le dénominateur est une puissance de deux. Par exemple, 0,25 (1/4) et 0,125 (1/8) sont sûrs, mais 0,2 (1/5) devrait être éviter. Le problème avec ces valeurs de pas est que votre intervalle pourrait avoir trop ou trop peu d'éléments, dû à une arithmétique inexacte;

La valeur par défaut est un 1. Un intervalle de forme [<début>:<fin>] avec un <début> plus grand que le <fin> générera un avertissement et est équivalent à [<fin>:1:<début>]. Un intervalle de forme [<début>:1:<fin>] avec un <début> plus grand que le <fin> ne générera pas d'avertissement et est équivalent à un []. Le <pas>dans un intervalle peut être négatif (pour les versions après 2014).

La valeur indéfinie[modifier | modifier le wikicode]

La valeur indéfinie est une valeur spéciale écrite undef. C'est la valeur initial d'une variable à laquelle une valeur n'a pas été assignée, et elle est souvent renvoyée comme résultat par des fonctions ou des opérateurs qui ont reçus des arguments incorrects. En résumé, undef peut être utilisé comme valeur nulle, équivalente à null ou NULL dans d'autres langages de programmations.

Toutes les expressions arithmétiques contenant un undef sont évaluées comme undef. Dans les expressions logiques, undef est équivalent à false (la valeur fausse).

Notez que les opérations mathématiques peuvent aussi renvoyer un nan ('not a number', pas un nombre) pour indiquer un argument illégal. Par exemple, 0/false vaut undef, mais 0/0 vaut nan. Les opérateurs relationnels comme '<' et '>' renvoie false s'ils reçoivent des arguments illégaux. Bien que undef soit une valeur reconnue par le langage, nan ne l'est pas.