Retour à l'introduction.

# Les scripts

L'automate
Le Langage
Détail des commandes complexes
Exemples
Le Langage d'évaluation

### L'automate

Zetta6 implémente un automate permettant de reproduire certaines tâches par le biais de scripts.
C'est par exemple le cas avec le script de démonstration fourni avec le logiciel.

Plus concrètement, l'automate lit un script et exécute linéairement chacune des diverses commandes (dessin sur le plan 2D, ouvrir un plan, création des vues, génération du solide, changement des paramètres de génération, etc...)

### Le langage

Les scripts sont nommés avec une extension “.z6s”, ils sont de type texte et peuvent avoir autant des sauts à la ligne de type Unix (\n) ou Ms Windows (\r\n).
Chaque instruction est rendue distincte par un saut à la ligne ou avec le caractère “;”, les commandes et les paramètres sont séparés par un espace.

Il y a deux types d'instructions, les variables d'environnement (placées en début de fichier et commençant par le caractère “:”) et les commandes. Il est également possible d'ajouter des commentaires (ignorés par l'automate), pour cela la ligne doit commencer par le caractère “#”

A noter que les commandes dédiés au tracé d'entités 2D commencent toutes par un point (“.”).

Les commandes peuvent être placées dans des blocs d'instruction par le biais de la commande bloc suivi des instructions placées entre parenthèses (voir les exemples avec la calculatrice).

#### Liste des variables d'environnement

- “:lang FR/EN” Langue du script et de la synthèse vocale. Doit être suivi de FR (Français) ou EN (Anglais) suivant la langue souhaitée. Si rien n'est spécifié, FR est la valeur par défaut.
- “:lang_ver 100" Version du langage.
- “:anim 1/0” Si “1” est donné en argument, le script s'exécutera en mode animation.
- “:id 0” Version du fichier (à titre indicatif).
- “:inc fichier.z6s” Inclure un fichier de script. Ce dernier doit être placé relativement au répertoire du script exécuté ou du répertoire d'installation de Zetta6.

Avertissement : Le mode animation peut être utile pour rendre interactif certains scripts, mais ralentit considérablement la vitesse d'exécution.

#### Liste des commandes (Script type Français)

- arret : Arrêt définitif du script. Sera considéré comme le signalement d'une erreur.
- quitte : Arrêt du bloc d'exécution en cours. Si l'appel est fait dans le fil d'exécution principal, le script sera arrêté (n'est pas traité comme une erreur, mais comme un arrêt volontaire).
- message "texte" : Demande l'affichage d'un message (peut prendre plusieurs arguments).
- note "texte" : Demande l'affichage d'un message discret.
- dicte "texte" : Demande la lecture du texte en argument par la synthèse vocale. Si l'utilisateur a désactivé cette dernière, le texte sera affiché tel que via la commande “message”.
- question "x x x x" : Demande une information à l'utilisateur et l'assigne dans une variable de l'évaluateur. Prend une suite d'arguments, voir plus bas.
- confirmation "texte" : Affiche un message (personnalisé) de confirmation à l'utilisateur. Si ce dernier accepte, le script se poursuit, sinon il est arrêté.
- reinit : Commande de ré-initialisation, supprime tous les modèles 3D, tous les cadres de la vue 2D ainsi que les origines.
- reinit2D : Commande de ré-initialisation 2D uniquement, supprime tous les cadres de la vue 2D ainsi que les origines.
- ouvrir_plan "chemin/fichier.dxf" : Ouvre un plan (relativement à l'emplacement du script).
- fermer_plan : Ferme le plan 2D en cours.
- onglet2D : Passe sur la vue 2D.
- cadrage2D : Cadrage de la vue 2D pour afficher l'ensemble de la scène.
- onglet3D x : Passe sur une vue 3D (doit être suivi d'un entier définissant la vue 3D, la première étant identifiée 1).
- vue x x x x x x : Défini un cadre de vue 2D. Prend une suite d'arguments, voir plus bas.
- origine x x x : Défini une origine 2D. Prend une suite d'arguments, voir plus bas.
- gen3D : Demande la génération 3D. L'exécution sera bloquée jusqu'à la génération du solide.
- gen3Db : Génère un modèle 3D en bloquant l'exécution du script tant que l'utilisateur ne repasse pas sur la vue 2D.
- gen3Dnb : Génère un modèle 3D sans blocage.
- fermer3D : Ferme la dernière vue 3D.
- delai : Délai avant exécution de la commande suivante (en ms).
- charge_config : Chargement de la configuration utilisateur concernant la génération des solide (indispensable avant de les modifier).
- param x x : Changement d'un paramètre lié à la génération 3D (interne au script), chacun des paramètres peut être changé à n'importe quel moment de l'exécution du script, mais ils n'auront d'effet que pour les solides générés suivants dans le script. Prend plusieurs arguments, voir plus bas.
- force_config : Force l'écriture des paramètres dans la configuration utilisateur. Sera soumis à l'approbation de l'utilisateur.
- anime3D : Lance l'animation de la scène sur la vue 3D actuelle. Ignoré si l'on est sur la vue 2D.

#### Liste des commandes de tracé d'entités 2D (Script type Français)

- .groupe : Création d'un nouveau groupe, toutes les entités ajoutés après la commande seront incluses dans ce groupe.
- .couleur : Assignation d'une couleur, toutes les entités ajoutés après la commande l'utiliseront.
- .ligne : Ajout d'une ligne (4 arguments : x1, y1, x2, y2).
- .ligne_rel : Ajout d'une ligne dont le second point est relatif au premier (4 arguments : x1, y1, x2, y2).
- .cercle : Ajout d'un cercle (3 arguments : centre_x, centre_y, rayon).
- .ellipse : Ajout d'une ellipse (5 arguments : centre_x, centre_y, rayon_longueur, rayon_largeur, rotation).
- .courbe : Ajout d'une courbe générique (7 arguments : centre_x, centre_y, rayon_longueur, rayon_largeur, angle1, angle2, rotation).
- .rect : Ajout d'un rectangle (4 arguments : origine_x, origine_y, taille_x, taille_y).
- .texte : Ajout d'un texte (5 arguments : "texte", origine_x, origine_y, hauteur_texte, rotation).
- .point : Ajout d'un point (2 arguments : x, y).

#### Les commandes suivantes sont dédiées à la manipulation de la calculatrice (pour plus d'informations voir la section sur le langage d'évaluation).

- calc "expression" : Exécute une expression dans la calculatrice.
- boucle "expression" "bloc_boucle" : Exécute l'expression dans la calculatrice. Tant qu'elle reste valide, le bloc donné en argument sera exécuté par répétition.
- si "expression" "bloc_1" "bloc_2" : Exécute l'expression dans la calculatrice. Si elle est valide, le premier bloc donné en argument sera exécuté, sinon le second (optionnel) le sera.

### Détail des commandes complexes

Demande d'une information à l'utilisateur : question type nom_variable texte valeur_defaut
Le type peut être bool (vaut 0 ou 1, true ou false, oui ou non), int (valeur entière) ou float (nombre réél).
Le nom de la variable est au choix du programmeur. Si la variable n'existait pas déjà, elle sera allouée, sinon elle sera réassignée.
Le texte est le texte d'information adressé à l'utilisateur lors de l'affichage de la boite de dialogue.
La valeur par défaut permet de pré-remplir le formulaire de la boite de dialogue avec une valeur au choix du programmeur.

Définition d'une vue : vue type type_coordonnées x1 y1 x2 y2
Le type peut être face (vue de face), cote (vue de côté), haut (vue de dessus) ou mult (vue multiple, les cadres de vues seront recherchés automatiquement).
Le type de coordonnées peut être abs ou rel. Cela défini le type des coordonnées du second point des coordonnées, suivant si l'on souhaite le spécifier en coordonnées absolues (depuis le point 0) ou relatives (suivant le premier point, qui lui sera toujours en coordonnées absolues)
Suivent les coordonnées des deux points formant la diagonale du rectangle de la vue.

Définition d'une origine : origine type x y
Le type peut être face (vue de face), cote (vue de côté) ou haut (vue de dessus).
Suivent les coordonnées du point d'origine, respectivement en X et en Y.

Changement d'un paramètre : param type valeur

- param tolerance 0.1 : Change la valeur de tolérance aux imprécisions à la valeur 0.1
- param echelle_uniforme 0 : Change la valeur de la diagonale uniforme (0 pour désactivé).
- param arrondi 4 : Change la valeur d'Epsilon (ici à 4 chiffres après la virgule)
- param divisions_courbes 24 : Change le nombre de divisions pour les courbes à 24
- param projections 14 : Configuration des projections des vues par un argument entier qui est la combinaison binaire des vues (nul=0, face=2, côté=4, haut=8; Par exemple 2+4+8 = 14, donc 14 pour afficher toutes les projections).
- param informations 0 : Paramètres d'informations 3D affichées par un argument entier qui est la combinaison binaire des paramètres définis dans l'espace de nom Perspective3D::INFOS3D dans l'API.
- param taille_texte3d 25 : Change la taille du texte 3D affiché en % de la dimension du solide.
- param filaire 0 : Impose l'état de génération filaire uniquement (suivi de 1 pour activer ou 0 pour désactiver).
- param multithreading 0 : Impose l'état du multithreading (suivi de 1 pour activer ou 0 pour désactiver). Note: Ce paramètre n'a d'effet que si le logiciel est activé par une clé de licence.
- param params3D 83 : Paramètres de génération 3D. Doit être suivi de la combinaison binaire des paramètres définis dans l'espace de nom Perspective3D::PARAMS_GEN3D de l'API. La valeur de ce paramètre peut être obtenu facilement après la génération d'un solide en affichant les propriétés 3D.
- param taille_max_surfaces 256 : Taille maximum des surfaces en nombre de sommets (ici 256).
- param norme_vues 1 : Type de projection des vues (suivi de 1 pour la norme ISO, 2 pour la convention Nord-Américaine).
- param id_ral 9010 : Identifiant du RAL pour la couleur du solide (ici 9010).

### Exemple

Le fichier de démonstration est en soit un exemple, d'ailleurs l'exemple ci-dessous s'en inspire, si ce n'est que chaque commande est commentée.

# Assignation de la langue Française pour le langage du script (a noter que cela définit la sélection de la langue du script, mais également pour la synthèse vocale)
:lang FR
# Ouvre le plan "exemples.dxf", il doit être dans le même dossier que le script.
ouvrir_plan "exemples.dxf"
# Réinitialisation des cadres et vues et des origines éventuellement dessinées par l'utilisateur.
reinit
# Chargement de la configuration utilisateur.
charge_config
# Changement de la couleur RAL du solide (ici en noir), ce changement de paramètre n'est effectif que pour ce script et ne touche pas la configuration utilisateur.
param id_ral 9005
# On s'assure d'être sur l'onglet 2D.
onglet2D
# Création des cadres de vues (un seul cadre en mode automatique).
vue mult abs 270 34 420 170
# Lance la génération 3D.
gen3D

### Le Langage d'évaluation

Une extension du langage de script permet d'effectuer des calculs directement dans le script. Il faut utiliser la commande “calc” suivie d'une expression à évaluer.
Les opérations doivent être mises entre parenthèse, ces dernières pouvant être imbriquées.
Par exemple:

calc "pointx = 5" Déclare une variable nommée pointx à la valeur 5
calc "pointx = (pointx+37)" pointx vaudra 42.
Des opérations distinctes peuvent être mises sur la même ligne en les plaçant dans des blocs de guillemets différents ou en les séparant par le caractère ';'.
Par exemple les deux expressions ci-dessous sont sémantiquement identiques:

calc "pointx=42" "pointy=75"
calc "pointx=42 ; pointy=75"
Une fois les opérations effectuées, les variables sont utilisables dans le script comme des valeurs numériques, par exemple en reprenant les valeurs précédentes:

# Place une origine au point 42 ; 75
origine pointx pointy
Des fonctions sont également définies pour effectuer des opérations usuelles comme le calcul d'une racine carré:

calc "phi = ( (1 + (sqrt 5)) / 2 )"
Contrairement aux opérateurs qui exigent d'avoir deux opérandes (une de chaque côté), les fonctions peut avoir un nombre variable d'opérande suivant le cas, ces opérandes étant placés à la suite de l'appel de fonction.
En plus des variables standards, il est possible d'utiliser des tableaux via les caractères “[” et “]” lors de l'affectation.

calc "tableau = [0 1 2 3]"
calc "t0 = tableau[0]"
calc "t3 = tableau[3]"
Ici la variable t0 vaudra le premier indice du tableau (donc 0) et t3 le dernier élément (donc 3).
Il est également possible de permuter deux variable via l'opérateur “:”.
Cette opération peut s'appliquer à des variable déjà affectée ou aux éléments d'un tableau.

calc "tableau = [ 0 1 ]"
calc "tableau[0] : tableau[1]"
Ainsi, tableau[0] vaudra 1 et tableau[1] vaudra 0.

#### Liste des opérations avec leur priorité opératoire:

- Manipulation des variables (pas de priorité, utilisé hors calcul):
- = : Affectation
- : : Permutation

- Priorité forte:
- * : Multiplication
- / : Division
- % : Modulo (calcul du reste d'une division)
- ^ : Puissance

- Priorité moyenne:
- + : Addition
- - : Soustraction

- Priorité faible (opérateurs booléens et de comparaison):
- == : Egalité
- != : Non égalité
- > : Supérieur à
- < : Inférieur à
- >= : Supérieur ou égal à
- <= : Inférieur ou égal à
- & : Et logique
- | : Ou logique

- Liste des fonctions mathématiques:
- sqrt : Racine carré, 1 argument
- pow : Puissance, 2 arguments
- min : Sélection de la plus petite valeur, 2 arguments
- max : Sélection de la plus grande valeur, 2 arguments
- hypot : Distance euclidienne 2D, équivalent à (sqrt ((a*a) + (b*b))), deux arguments
- sin : Sinus (radians), 1 argument
- cos : Cosinus (radians), 1 argument
- tan : Tangente (radians), 1 argument
- asin : Arc sinus (radians), 1 argument
- acos : Arc cosinus (radians), 1 argument
- atan : Arc tangente (radians), 1 argument
- exp : Exponentiation, equivalent à (pow e valeur), 1 argument
- ln : Logarithme népérien (base e), 1 argument
- log10 : Logarithme commun (base 10), 1 argument
- deg_rad : Conversion degrés vers radians, 1 argument
- rad_deg : Conversion radians vers degrés, 1 argument
- abs : Valeur absolue, 1 argument
- diff : Différence absolue, 2 arguments
- srand : Initialise la graine pour la génération de nombre aléatoire, 1 argument
- rand : Renvoi un nombre pseudo-aléatoire, aucun argument
- clamp : Borne un nombre, 3 arguments (valeur min max)
- round : Arrondi d'un nombre réél à l'entier le plus proche
- round0 : Arrondi d'un nombre réél à l'entier inférieur
- round1 : Arrondi d'un nombre réél à l'entier supérieur

- Liste des constantes (utilisable comme des variables si ce n'est qu'elles sont prédéfinies):
- true : 1 (booléen)
- false : 0 (booléen)
- x : 0 (index de tableau)
- y : 1 (index de tableau)
- z : 2 (index de tableau)
- w : 3 (index de tableau)
- pi : 3.141592653589793 (réel)
- phi : 1.618033988749895 (réel)
- e : 2.718281828459045 (réel)

A titre d'exemple, voici un programme qui exécute des trois premières itérations de l'algorithme de Gauss-Legendre pour calculer le nombre π :

:lang FR
:lang_ver 100
:anim 0
calc "iter_pi=0"
calc "a = 1.0 ; b = (1/(sqrt 2)) ; t = (1/4.0) ; p = 1.0"
bloc calc_pi
{
calc "as = ((a + b) / 2) ; bs = (sqrt(a*b)) ; ts = (t - p * ((a-as)^2)) ; ps = 2 * p"
calc "pi_c = ( ((as + bs) ^ 2) / (4 * ts) )"
calc "a = as; b = bs; t = ts; p = ps"
calc "iter_pi = iter_pi + 1"
}
boucle "iter_pi < 3" calc_pi
message "Valeur de pi après" iter_pi "itérations :" pi_c
Affichera “Valeur de pi après 3 itérations : 3.14159265359” (tous les nombres rééls sont arrondis à 12 chiffres après la virgule pour l'affichage)

Notez que pour demander l'affichage du message, on aurait pu retirer les guillemets et mettre une ligne tel que:

message Valeur de pi après iter_pi itérations : pi_c
Si c'est un peu plus lisible au niveau du code, c'est aussi beaucoup plus inefficace, en particulier avec une phrase longue car l'interpréteur devra tester si chaque mot est une variable à évaluer, tandis que l'affichage est direct avec des chaînes entre guillemets,

Un autre exemple, qui cette fois ci génère et trace une sinusoïde :

:lang FR; :lang_ver 100; :anim 0
onglet2D
fermer_plan
charge_config
question int nombre_segments "Nombre de segments ?" 80
calc "echelle_trace=50"
calc "iter_sin=0 ; inc_sin=0.2"
calc "p1 = [ 0 0 ] ; p2 = [ 0 0 ]"
bloc trace_segment_sinusoide
{
.ligne p1[x] p1[y] p2[x] p2[y]
}
bloc b_sinusoide
{
calc "p2[x] = p1[x] ; p2[y]=p1[y]"
calc "p1[x] = (p1[x] + ((inc_sin*0.5) * echelle_trace))"
calc "p1[y] = ((sin iter_sin) * echelle_trace)"
si "iter_sin != 0" trace_segment_sinusoide
calc "iter_sin = iter_sin + inc_sin"
}
bloc gen_extrusion
{
param tolerance 0.1
calc "marge_cadre = 20"
calc "c_min = [ (0-marge_cadre) ((0-echelle_trace) - marge_cadre) ]"
calc "c_max = [ (p1[x] + marge_cadre) (echelle_trace + marge_cadre) ]"
vue extrusion abs c_min[x] c_min[y] c_max[x] c_max[y]
gen3D echelle_trace
}
.couleur 1 1 1
boucle "iter_sin < (inc_sin*nombre_segments)" b_sinusoide
cadrage2D
question bool genere_3d "Extruder la sinusoïde ?" oui
exec "gen_extrusion"
Sur ce type de script (exécutant une boucle relativement longue), l'activation du mode animation peut sensiblement dégrader les performances.
Retour à l'introduction.