Les paramètres dans les onglets Tortue et Valeurs sont destinés aux utilisateurs aguerris ayant une expérience en programmation (ces onglets contiennent un système-L entier). Toutefois, ceux d'entre vous qui ont peu voire aucune connaissance en programmation ne doivent pas s'affoler. Vous trouverez ci-après plusieurs exemples différents.

Assurez-vous d'avoir réglé le Mode sur Tortue.

Brève introduction aux systèmes-L

Dans les pages suivantes, les systèmes L(indenmayer) sont briévement expliqués. Des livres supplémentaires ou des ressources en ligne sont disponibles. Elles offrent une explication en profondeur de ces systèmes (le document pdf "The Algorithmic Beauty of Plants" de Przemyslaw Prusinkiewicz et Astrid Lindenmayer est basé sur l'utilisation de CINEMA 4D et peut être téléchargé sur http://algorithmicbotany.org/papers#abop).

Les systèmes-L sont généralement utilisés pour simuler l'évolution d'une plante et des effets similaires. Combinés avec MoGraph, ils peuvent être utilisés pour créer des simulations de croissance spectaculaires en plaçant un objet MoSpline dans un objet Extrusion contrôlée (les Splines peuvent être rendues directement à l'aide de Sketch and Toon ou HAIR).

Introduire un système L exécute une série de commandes qui définissent comment et où les nouvelles branches devraient pousser. Il s'agit d'un système auto-productif qui peut placer des branches existantes sur des nouvelles.

Les principes de base sont assez simples et sont fondés sur un système appelé "Système Tortue". Une tortue (virtuelle) est envoyée sur un chemin via des commandes simples. Cette trajectoire est représentée par une Spline.

Les 3 commandes les plus importantes sont:

• Un simple F, qui signifie "Avancer d'une étape (F pour Forwards)". Pour une MoSpline, ça veut dire "Prolonger la Spline d'une unité (dans la direction Z de l'objet)"
• +: Faire pivoter à droite
• -: Faire pivoter à gauche

Si vous saisissez la séquence F++F++F dans le champ Initiale, il passe à : "Avancer d'une étape"; tournez deux fois sur la droite; "Avancer à nouveau d'une étape"; tournez deux fois sur la droite; "Avancer à nouveau d'une étape".

La longueur de chaque étape et la largeur de l'angle de rotation peuvent être définies dans l'onglet Valeurs via les valeurs Mouvement par défaut et Angle par Défaut. Mais vous pouvez aussi, comme indiqué plus haut, les placer entre parenthèses. Si l'Angle par Défaut est réglé sur 60°, voici le triangle qui résulterait pour notre exemple:

Cela vous permet de créer des formes ressemblant à des branches. Une fonction très intéressante des systèmes-L est son système de remplacement intégré avec lequel des branches individuelles peuvent être remplacées par d'autres. Cela peut aussi être répété de façon indéfinie, ce qui vous permet de créeer une ramification très complexe avec des codes de commande très simples. Si cela peut sembler déroutant, l'exemple suivant peut répandre plus de lumière sur ce qui est impliqué:

Jusqu'à présent, vous n'avez entré que des codes de commande d'une ligne qui n'étaient exécutés qu'une seule fois. Entrez maintenant le code de commande suivant dans les champs respectifs:

Champ Initiale: F++F++F

Champ Règles: F = F-F++F-F

Comme vous pouvez le voir, la ligne de code Règles contient une attribution (à laquelle on fait par la suite référence comme Règle) dans laquelle on attribue plusieurs symboles à "F" qui en retour seront insérés (manuellement) dans la ligne de code Initiale.

Si elle est écrite dans son intégralité, voici ce que lirait la commande ligne de code (remplacer le F dans la ligne de code Initiale par le code qui suit le "F" dans la ligne de code Règles):

F-F++F-F++F-F++F-F++F-F++F-F

Ceci représente la deuxième forme à partir de la gauche dans l'image ci-dessous. Etant donné que chaque F dans le code Initiale est remplacé par la Règle, chaque ligne droite sera remplacée par la ligne la plus complexe.

Et ce processus de remplacement peut être répété indéfiniment (enfin, pas vraiment puisque votre ordinateur abandonnera probablement après que la complexité exponentielle des Splines commence à augmenter...). La fréquence de répétition de ce processus est définie par la valeur Croissance, qui remplace chaque F par le code Règles. Et les fractales fonctionnent de la même façon.

Bien sûr, les paramètres substituables peuvent aussi être utilisés afin que chaque F n'ait pas à être utilisé. Après tout, cela serait irréalistes pour des formations croissantes - la croissance en longueur n'a pas toujours lieu à la fin des branches, etc.

Pour cela, vous pouvez utiliser des paramètres substituables (des lettres qui ne représentent aucune commande tortue) tels que A, B, C, D, (mais pas "F" car c'est la "commande avancer d'une unité" par défaut).`

Tapez les codes suivants dans les champs respectifs:

Initiale: FA

Règles: A=+F-FA

Etant donné que la Règle se termine avec un A, si une une valeur Croissance est croissante, la formation grandira indéfiniment (la Valeur par Défaut est réglée sur 90°).

Le code que nous avons utilisé jusqu'à présent était constitué d'une seule ligne de code ininterrompue. Toutefois, les systèmes L deviennent intéressants lorsque de véritables branches sont créées, c'est-à-dire des lignes nouvelles qui dévient des lignes existantes. Vous pouvez faire cela à l'aide de crochets ([ ]). La séquence de commande à l'intérieur d'un crochet est perçue comme une branche séparée (et crée une nouvelle Tortue). Après que la branche a été créée, la tortue retournera à son point de départ qui se trouve avant le crochet et poursuivra avec la séquence de commande suivant les crochets.

Tapez le code suivant dans le champ Initiale:

F[+F][-F[-F]F]F[+F][-F]

Si vous saisissez maintenant F dans le champ Initiale et le code ci-dessus (F=F[+F][-F[-F]F]F[+F][-F] ) dans le champ Règles, chaque F sera remplacé par les branches à gauche de l'image. Augmenter la valeur Croissance permettra à la branche de continuer à croître car chaque ligne droite sera perpétuellement remplacée par une nouvelle branche. Si vous regardez de près, vous verrez que le motif de la branche de gauche est répété sur l'arbre de droite (en verre).

C'est une méthode simple pour créer des ramifications complexes ressemblant à des plantes:

Jusqu'à maintenant, nous avons tout créé sur un plan plat. Etant donné qu'une ramification n'a pas lieu uniquement sur un seul plan mais aussi dans toutes les directions, il existe aussi des symboles de commande qui rendent aussi cela possible.

Les voici (une valeur degré peut être ajoutée entre crochets après les symboles de commande)::

& ou ^: tourne autour de l'axe transversal de la tortue

\ ou / : tourne autour de l'axe longitudinal de la tortue

Tapez le code suivant dans le champ Initiale: F&F\ (90)^F+F:

Le résultat est la spline représentée au-dessus. La tortue avance (F), tourne à l'angle-droit autour de son axe transversal (&, Angle par défaut est réglé sur 90°), avance à nouveau (F), tourne de 90° autour de son axe longitudinal (\ (90)), ensuite de 90° autour de son axe transversal (^), avance encore (F), tourne à droite (+) et avance encore (F).

Si vous utilisez cette méthode pour créer des formations avec des branches dans l'espace, vous pouvez créer de véritables buissons et de véritables arbres.

Données utilisateur

Vous pouvez utiliser les Données utilisateur comme des variables dans une séquence de symboles. Dans l'image ci-dessus, un paramètre Angle a été ajouté aux Données utilisateur et a ensuite été substitué entre parenthèses pour ^ (la tortue tourne autour l'axe transversal) dans le champ Initiale.

Il ne faut pas inclure de caractères spéciaux ni d'espaces dans les noms des variables. Les tirets bas sont reconnus (par exemple "deuxième_longueur") tout comme les majuscules.

Formules

Les formules, incluant des variables définies (par exemple F(_growth*2), peuvent être utilisées à la place de chiffres normaux. Voici ce qui est disponible:

_total	Le nombre total de commandes dans la chaîne actuelle (Cf. ci-dessous)
_index	L’indice de la commande actuelle dans la chaîne (Cf. ci-dessous(
_growth	Le niveau de croissance actuel
_level	Le niveau de commande actuel (le cas échéant, Cf. ci-dessous)
_x, _y, _z	La position actuelle de la Tortue dans l’espace.
_arg1, _arg2, _arg3, _arg4	Les première, deuxième, troisième et quatrième valeurs d'argument (par ex. à partir de F(1,2,3,4))
_age	L’âge de la commande actuelle (représente _le niveau - _de croissance) à partir de 0.0.
_length	La longueur actuelle de l'arc entre les origines de la Tortue et de MoSpline.
_move	La longueur d'échelle par défaut actuelle.
_tropism	Le Tropisme actuel.
_scale	L’échelle par défaut actuelle.
_rotate	L’angle par défaut actuel.
_rnd, random	Un chiffre aléatoire entre -1,0 et +1,0

Exemple "Total/Index"

Imaginons que vous avez la chaîne F(_index)F(_index), qui se compose de deux commandes. La chaîne a la même fonction que F(1)F(2) (une unité en avant puis deux unités en avant). Par exemple, étant donné que "_total" est le nombre total de commandes, une spirale peut être créée avec la commande suivante:

Initiale: FA

Règle: A=+(20*_index/_total)FA

Exemple "_RND"

La commande suivante :

Initiale: A

Règle: A=+(_rnd*90)FA

La commande ,_rnd*90’ assure un angle aléatoire entre -90 et +90 à chaque nouvelle phase de croissance, c’est-à-dire qu’une ligne "bancale”, composée de rotations aléatoires, se formera.

Exemple "_level"

Imaginons que vous avez la commande suivante :

Initiale: A

Règle: A=FA

Vous obtiendrez les valeurs niveau suivantes (affichées ici entre parenthèses à des fins d'exemple - elles ne seront pas affichées en réalité):

Croissance = 0 : A(0)

Croissance = 1 : F(1)A(1)

Croissance = 2 : F(1)F(2)A(2)

Croissance = 3 : F(1)F(2)F(3)A(3)

Maintenant que vous savez comment on fait la numérotation "_index", regardez la commande suivante:

Initiale: FA

Règle: A=+F(_level*10)A

...crée la spirale suivante avec un Angle par défaut réglé sur 90°:

Exemple "_arg"

De la même façon que vous pouvez définir F(a,b,c)=F(a*2,b*2,c*2) pour régler les paramètres pour les commandes de la Tortue (dans cet exemple F), vous pouvez aussi utiliser la commande "_arg". Elles n'ont pas à être évaluées au début. F=F (_arg1*2,_arg2*2,_arg3*2) fait la même chose que la commande ci-dessus.

Variations de syntaxe avancées

La syntaxe suivante est aussi possible :

Initiale: F(2)F(1,2)F(2,3)

Règle : F(a,b) = F(a*2,b*2)

Tous les F seront remplacés et que "a" ou "b" apparaissent dans la règle existante F, les arguments seront gérés comme ceci:

F(2*2,1*2)F(1*2,2*2)F(2*2,3*2) ce qui est égal logiquement à F(4,2)F(2,4)F(4,6).

Il est aussi possible de créer la règle suivante:

F(a,b):(a>10)=F(a,b)+F(a/2)

La Règle ne s'appliquera, par exemple, que si la valeur du premier argument est supérieure à 10.

Dans l'exemple suivant, les deux variations de syntaxe ci-dessus ont été combinées et produisent un effet intéressant:

Exemple "fruits"

Dans l'exemple ci-dessus, plusieurs branches poussent simultanément. Lorsqu'une branche a fini de pousser, une sphère sera placée à l'extrémité de la branche (la commande J est nécessaire, voir exemple: Objet-cloneur).

Notez que "B(6)" est défini dans la première Règle et que "B(h-1)" réduit l'argument de 1 dans Règle 2 jusqu'à ce que "h=0" règle finalement la sphère dans Rule 3.

Regardez la console pour voir toute la chaîne (mais cliquez d'abord sur le bouton Chaîne résultante vers console).

Vous pouvez trouver davantage de détails concernant les formules dans les pièces jointes.

Initiale

Entrez l'initiale ici. Il s'agit la plupart du temps d'une commande comportant une seule lettre (voir Règles) ou d'un paramètre substituable auquel le contenu est ajouté dans le champ Règle. Dans les pages suivantes, vous trouverez de nombreux exemples de ce à quoi peuvent ressembler les chaînes.

Ignorer contexte

Vous pouvez définir ici une série de symboles (commandes) qui seront ignorés par les règles contexte. Exemple:

Vous avez la constellation suivante:

Initiale: A+B+C+D+E+F

Règles: A<B=C

Règles

F(a,b,c)	Déplace la Tortue vers l'avant et trace éventuellement des lignes sur sa longueur (a), pour l'échelle (b) et/ou la subdivision. (c).
f(a)	Déplace la Tortue vers l'avant et AUCUNE ligne ne sera tracée (c'est-à-dire qu'un segment Spline sera terminé) « a » est la valeur de longueur optionnelle.
H(a,b,c)	Déplace la Tortue vers l'avant et trace éventuellement une ligne deux fois plus courte que sa longueur (a), son échelle (b) et/ou sa subdivision. (c)
h(a)	Déplace la Tortue vers l'avant et AUCUNE ligne ne sera tracée (c'est-à-dire qu'un segment Spline sera terminé) « a » est la valeur de mi-longueur optionnelle.
M(x,y,z)	Déplace et trace une ligne. La Tortue se déplacera à l'intérieur des coordonnées locales (x,y,z) mais ne pivotera pas elle-même.
m(x,y,z)	La Tortue avance mais ne trace pas de ligne. La Tortue se déplace à l'intérieur des coordonnées locales (x,y,z) mais n'effectue pas elle-même de rotation..
G(a)	La Tortue avance mais ne trace pas de ligne et ne termine pas un segment Spline. « a » est la valeur de longueur optionnelle.
R	Réinitialise la Tortue au point de départ du segment, réinitialise la rotation et trace une ligne (dans une Tortue MoSpline, un segment est toujours contenu dans [ ]).
r	Réinitialise la Tortue au point de départ du segment, réinitialise la rotation et ne trace pas de ligne (dans une Tortue MoSpline, un segment est toujours contenu dans [ ]).
P(x,y,z)	Place la Tortue à ces coordonnées et trace une ligne.
p(x,y,z)	Place la Tortue à ces coordonnées et ne trace pas de ligne.
-(a)	Tourne la Tortue dans le sens inverse des aiguilles d'une montre autour de l'axe vertical. « a » est la valeur d'angle optionnelle.
+(a)	Tourne la Tortue dans le sens des aiguilles d'une montre autour de l'axe vertical. « a » est la valeur d'angle optionnelle.
&(a)	Rotation de la Tortue vers l'avant autour de l'axe transversal. « a » est la valeur d'angle optionnelle.
^(a)	Rotation de la Tortue vers l’arrière autour de l'axe transversal. « a » est la valeur d'angle optionnelle.
/(a)	Fait pivoter la Tortue dans le sens des aiguilles d'une montre autour de l'axe central. « a » est la valeur d'angle optionnelle.
\(a)	Fait pivoter la Tortue dans le sens inverse des aiguilles d'une montre autour de l'axe central. « a » est la valeur d'angle optionnelle.
[	Nouvelle branche = nouvelle Tortue
]	Fin de la branche
{	Début du polygone (Cf. exemple ci-dessous : « Création d’un polygone »)
}	Fin du polygone
.	(Point) Ajoute un point de polygone - entre accolades pour les polygones : par ex. = { . -f . +f . +f . +f }
|	Permet de faire pivoter la Tortue de 180 degrés autour de l'axe vertical.
*	Permet de faire pivoter la Tortue de 180 degrés autour de l'axe central.
%	Coupe la branche à ce niveau : tout sera ignoré jusqu'à la fin du crochet de fermeture : ] voir exemple « Couper la branche ».
"(a)	Multiplie la longueur par la valeur optionnelle « a » à chaque génération (Cf. exemple ci-dessous) : Multiplier/Diviser).
!(a)	Multiplie l’échelle par la valeur optionnelle « a » à chaque génération (Diamètre MoSpline lorsqu'il est utilisé en conjonction avec l'objet Extrusion contrôlée).
;(a)	Multiplie l’angle par la valeur optionnelle « a » à chaque génération.
_(a)	Divise la longueur par la valeur optionnelle « a » à chaque génération.
?(a)	Divise l’échelle par la valeur optionnelle « a » à chaque génération (Diamètre MoSpline lorsqu'il est utilisé en conjonction avec l'objet Extrusion contrôlée).
@(a)	Divise l’angle par la valeur optionnelle « a » à chaque génération.
T(a)	Ajoute Tropisme (par exemple FTFTF), ce qui signifie que chaque segment Spline se courbera légèrement dans la direction de l'axe Y global. Tous les modificateurs de particules présents seront évalués.
$(x,y,z)	Affiche la fin d'un vecteur ascendant et oriente la Tortue en conséquence. Définit un vecteur dans le sens duquel la Tortue doit faire face.
I(a,r,g,b)	(La première chaîne de caractères commence par un « i » majuscule)
J(a,r,g,b)	 
K(a,r,g,b)	 
L(a,r,g,b)	Pour les « I, J, K et L » ci-dessus, tous les clones générés par un objet Cloneur, quel que soit leur nombre, peuvent être disposés le long de la Spline Tortue. « r,v,b » représente la couleur du clone. « a » est l'indice (c'est-à-dire le nombre qui représente l'ordre dans lequel un objet est disposé sous un Cloneur. voir « Indice » ci-dessous). I, J, K, L représentent les Groupes respectifs dans le paramètre Mode de l'objet Cloneur, « Groupe 1 », " Groupe 2 ", " Groupe 3 ", " Groupe 4 ". Un exemple est donné ci-dessous dans la rubrique « Exemple : Objet Cloneur ».

Exemple "création de polygones"

Regardez la seconde ligne du champ Règle:

L=[{.-f.+f.+f.++++f.+f.+f.+f}]

Entre les guillemets (qui définissent un polygone), un nombre spécifique de points de polygone est défini (chacun commençant par ".") entre lesquels un polygone est créé. La tortue sera initialisée à son point d'avant la création de la feuille après que chaque feuille a été créée parce qu'il y a des guillemets dans les crochets.

On attribuera à toute la feuille un "L" et la Règle dans la ligne ci-dessus créera une feuille complète partout où il existe un "L".

Notez que la MoSpline peut produire soit une Spline soit un polygone. Si vous souhaitez produire les deux simultanément, utilisez la Spline destination.

Exemple "multiplier/diviser"

Si vous utilisez une séquence de symboles qui se remplace automatiquement dans le champ Règles (par exemple A=F+BA), vous pouvez utiliser un multiplicateur ou un diviseur (", !, ;, _, ?, @) pour augmenter ou diminuer de chaque nouveau générateur.

Exemple "couper une branche"

Si vous regardez cette Règle, vous verrez que les paramètres substituables A, B, C et D ont été ajoutés à l'initiale. Pour plusieurs valeurs Croissance, les règles définissent maintenant le remplacement de chaque paramètre substituable par une valeur %, ce qui signifie que les symboles suivants seront coupés sur ce point sur (et par) chaque branche.

Exemple "objet Cloneur"

Notez comment J et K sont utilisées dans la Règle (ils pourraient être remplacés par (1,1,1,1) et (1,1,1,1), et si l'argument des parenthèses étaient omis, chacun utiliserait la valeur standard qui fait référence aux clones de l'objet cloneur.

Le mode doit être réglé en conséquence pour les deux objets cloneurs:

I(1,1,1,1) reflète Groupe 1

J(1,1,1,1) reflète Groupe 2

K(1,1,1,1) reflète Groupe 3

L(1,1,1,1) reflète Groupe 4

Notez que cette règle

Initiale: FA

Règles: A=FX

X=J(1,1,1,1)

doit fonctionner mais les clones ne grandissent pas d'un coup mais sont simplement affichés de façon abrupte.

Exemple "index"

Les objets enfant d'un objet cloneur sont numérotés en séquence (en partant de "0"). Si, par exemple, vous définissez A=FJ(2,1,1,1)A (vous pouvez laisser tomber les valeurs RGB), l'objet cloneur n'utilisera que l'objet avec l'index "2" (à gauche de la sphère). Si vous utilisez A=J(rnd(2))A sur le côté droit, un clone sera placé par randomisation en accord avec un nombre entre "0" et "2"qui est aussi choisi par randomisation.

Exemple "croissance aléatoire"

Cette règle, combinée avec des valeurs Données utilisateurs diverses pour Limit1 et Limit2 (à deux, ces valeurs doivent être égales à 100%) peuvent être utilisées pour créer des "plantes" différentes mais très similaires (Système L Stochastique). Les conditions (rnd(1)<) ou (rnd(1)>) déterminent de façon aléatoire laquelle des 3 règles sera appliquée (chacune avec une nouvelle sélection aléatoire pour chaque nouveau Générateur, c'est-à-dire un paramètre de Croissance plus grand).

Exemple "règles contextuelles"

Les règles peuvent aussi être écrite de la forme suivante:

Initiale: ABC

Règle: A<B=C

Résultat (si Croissance > 1): ACC

Donc que se passera-t-il ? Cela dépend de la séquence à l'intérieur de la chaîne résultante. La règle "A<B=C" recherche des exemples dans la chaîne où un "B" suit directement un "A" et remplace le "B" par un "C".

Si, d'un autre côté, vous entrez "A>B=C", le "A" à gauche d'un "B" sera remplacé par un "C" (le résultat serait "CBC").

Pour la règle "AB=C", on ne peut pas déterminer quel symbole sera remplacé par "C". Dans ce cas, les deux seront remplacés par "C" (le résultat sera "CCC").

Résultat

Affiche les erreurs de syntaxe.

Chaîne résultante vers console

Cliquer sur ce bouton affichera la séquence de symboles qui prend effet à ce moment, en prenant en compte toutes les Règles et le paramètre Croissance, dans la Console. Une telle séquence peut, par exemple, ressembler à cela (c'est la séquence de symbole de l'exemple fruits avec la Croissance réglée sur 4):