• Home
  • Le script
    • Ajouter une icône
    • Commenter une commande
    • Fenêtre Flottante
    • Liste Scripts Commandes
    • Palette de Scripts
    • Panneaux Etendus
    • Raccourci sur une commande
    • Simplifier un script
    • Polygones vers Nurbs
  • "Script en ligne"
    • Autres >
      • Bascules
      • Browser
      • Camera&TargetPoint to Clipboard
      • Cartouche
      • CTRL C CTRL V
      • CurveLength
      • CurveLengthBeingDrawn
      • Golden
      • MatchObjectName
      • Plan Aux
      • Points
      • Print Screen
      • PurgeLayer
      • SetObjectName
      • Styles >
        • AddStyle
        • EditStyle
        • Assign Styles to solids
        • RandomColor
        • Random Style Solid Color
        • CreateStyleFromObjectName
        • Make gradient Styles
      • TakeSnapshot
    • Déplacer la vue/Objet >
      • MoveTargetToObjectsV2
    • Sélection >
      • SelectStyleV2 V3
      • SelectUnnamedObjectsV2
      • Selection Loop
      • Select by Length
      • Select Biggest / Smallest
      • RandomSelection
      • Naked edges
      • LastObjectsCreated
      • SetSelectedObjectToWireframe V2
      • SetSelectedObjectToWireframe & Lock V2
    • Affichage >
      • Filaire Ombré
      • LightingOptions
      • Pers/Parallèle
      • RandomizeStyleColors
      • ViewStack
    • Cacher >
      • HideSeamEdge
      • HideToHidden
      • Isolate
      • Hide Controls & Grid & Axes
    • Vues >
      • Cycler les vues
      • Dimetric
      • Isometric
      • Perpective
      • Zoom 4 Vues
      • Position Caméra
  • Les Commandes
    • Fonctions >
      • Fonctions Cachées
      • BisectorLine
      • CenterAtOrigin PutOnGround
      • Chanfreins
      • Dégradés
      • Copier
      • DividingPlanes
      • Effacer les Congés
      • Eraser
      • Hachures
      • Intersect2Circles
      • MoveSliceToPoint
      • OffsetMultiStep
      • QuickTrim
      • Randomize
      • ScaleIndividual
      • SelectIntersected
      • Tournette
      • TrimStencil
    • Courbes >
      • CCC
      • Close Curves
      • Conversion Courbe
      • Courbes en Cercles
      • Courbes par Lot
      • DelCorners
      • InsertCircles
      • LineWeb
      • MultiIso
      • MultiIso+
      • Ordre Courbes
      • Pts d'une courbe
      • Reconstruct Curves
      • RotateHistoryAray
      • ShrinkLines
      • UnwrapCurve
      • UVchanger-plane
    • Objets. >
      • Distributions
      • Anneaux
      • Boulons Filetés
      • Portes et Fenêtres
      • RotateObjects
      • Toroïdal Knots
      • Tubes
    • Scripts de Max Smirnov >
      • Scripts de Max Smirnov
      • Calculateur de Volume
      • Customiser l'Ui
      • Cycles pour Moi
      • Ecrous et Boulons
      • Cotations
      • Dispersions
      • Elephant Système Nodal
      • Engrenages
      • Fx Graph
      • Fx Graph 3D
      • Heightmap
      • Simulation Tissu
      • Subdivision
      • Bridge
    • 4 vues 2D
    • AssignName
    • AssignPresetName
    • BlendCap
    • FullScreen
    • Géométries par Bemfarmer
    • Importer des MNT
    • Lignes d'Aide
    • Points XYZ
    • r2d3
    • Sauvegardes Multiples
    • ScaleArray
  • Gif Animés
    • Cadre de Manipulation >
      • Cadre de Manipulation01
      • Cadre de Manipulation 02
      • Cadre de Manipulation 03
      • Cadre de Manipulation 04
      • Cadre de Manipulation 05
    • Orientation >
      • Oriente 01
      • Oriente 02
      • Oriente 03
      • Oriente 04
      • Oriente 05
      • Oriente 06
      • Oriente 07
      • Oriente 08
      • Oriente 09
    • Creux >
      • Creux 01
      • Creux 02
      • Creux 03
    • Offset
    • Accroche à une surface
    • Snap sur alignement
    • Trame droite
    • Trame sur courbe
    • Arcs et cercles tangents
    • Image d'arrière Plan
    • Propriété d'Objets
    • Rotation
    • Tension automatique
  • Utilitaires
    • Nouveautés V5
    • Nouveautés V4
    • V4 Quoi de neuf ?
    • V3 Quoi de neuf?
    • Liste des mises à jour
    • Aile Naca
    • Companion
    • Console
    • CutList
    • DESIGN CONCEPT
    • Engrenages en bois
    • Format OBJ en 3DM >
      • Instant Meshes
      • _importObj
      • obj23dm
    • Kitbash
    • Mannequin
    • MGB (Interface)
    • MergeOBJ
    • Moi et Modo
    • Paint 3D
    • Pont Moi Nvil KeyShot
    • Proflow
    • Raccourcis Pro
    • Rocket 3F
    • SpeedFlow
    • Somsky
    • Vectorisation
    • Vers ZBrush
    • ZSurf
  • Vidéos
    • Mini Vidéos
    • Nouveauté Béta V3 >
      • Enrobage d'objet V3
      • Enrobage d'un Tore V3
      • Twist V3
      • Isocurve V3
      • Découpe Iso V3
      • Extrusion V3
      • Nsided V3
    • Inutilitaires >
      • Inutilitaire 1
      • Inutilitaire 2
      • Inutilitaire 3
      • Inutilitaire 4
    • Menu Oriente >
      • Oriente
      • Ligne-Ligne
      • Vue-Vue
      • Bonus
    • Deux Rails
    • Tubage Booléen
    • Tendre
    • LineWeb (toile d'araignée)
    • Texte + Booléen Intersection
    • Escalier hexagonal
    • Sélecteur
    • Déplacer des objets
    • Pivoter des objets
    • ShiftArray
    • ScriptArray
    • Les Maîtres
  • Tutos
    • Trucs & Astuces >
      • Trucs Astuces
      • Truc Astuces 2
    • 3D Primer >
      • 3D Primer 1
      • 3D Primer 2
      • 3D Primer 3
      • 3D Primer 4
      • 3D Primer 5
    • Les Objets >
      • Anneau Strié
      • Avion
      • Bague
      • Bateau Riva
      • Batteur d'oeufs
      • Boîte
      • Boîtier
      • Bouteille Cognac
      • Bouteille plastique
      • Bouteille de soda
      • Chaise d'école
      • Chaussure
      • Cordon
      • Détergent
      • Haut-parleur
      • Jante
      • Lunettes de Mauro
      • Plaque électrique
      • Pneus
      • Poêle en fonte
      • Pomme Douche
      • Radio
      • Rasoir
      • Voiture
    • Les Surfaces >
      • Surfaces
      • Surfaces 2
      • Surface de Gordon
      • Les objets de Zarkow
    • L'éclairage dans Moi
    • Raccords manuels
    • Les Raccords
    • La SubDivision
    • Le tuto de Mauro
    • Solides
    • Tourbillon
    • Tutos by Liminal
    • Vasarely
    • Fiat Abarth
    • Le Truck de ED
    • La voiture de Ed
    • La Vespa de Mauro
    • Les voitures de MacGreggor
    • La Voiture de Zarkow
  • Divers
    • Free online >
      • BlockBench
      • Cables
      • Effaceurs Arrière-Plan
      • Fractal Lab
      • Gaugan
      • Gravit Designer
      • Kinematic Simulator
      • Light Tracer
      • Image En Large
      • Monster Mash
      • Objets 3D
      • Origami Simulator
      • ONSHAPE >
        • Onshape extrude
      • p5.Js Web Editor
      • Pix2Pix
      • Piskel
      • Sculpt GL
      • Shapr3D
      • SketchUp
      • Snap
      • SPLINE
      • Stable Diffusion
      • Sumo Paint
      • TinkerCad
      • Topotopo
      • Vectary. >
        • Vectary
        • Doc Vectary VF
      • Vectr
      • Vervette
      • Voronator
      • Voxelizer
      • Wombo
      • Womp
    • Manuels >
      • Sauce Tomate (SU) >
        • 1001
        • Artisan: le Manuel
        • BoolTool 2
        • Doh
        • Flex - Series
        • Le Mètre à Ruban
        • LightUp >
          • Sur LightUp >
            • Au sujet de Lightup
            • Avis des Utilisateurs
            • Listes des mises à jours
          • LightUp 1.0 (31 pages)
          • LightUp Player >
            • Le Player
            • Le Web Player
            • Publier sur le Net
          • Tutos LightUp >
            • Eclairage IES
            • Lumière Volumétrique
            • Lumière Néon
            • Profondeur de Champ
            • Suppression des Lignes Cachées
            • Grilles de Lumières Paramétriques
            • Ombres sur Arrière-Plan
            • Réflexion
            • Eclairage Intérieur
          • Ressources
          • Exemples >
            • Interieur
          • LightUp 3.0 (6 pages)
          • LightUp Manuel 3.3 (77 pages)
          • LightUp 4.4 >
            • Eclairer Un Salon 1
            • Eclairer Un Salon 2
            • Eclairer un Salon 3
        • Medeek Construction
        • MSPhysics
        • PBR
        • PomPi
        • Podium >
          • Rendu Photoréaliste
          • Site Podium VF
        • Profil Builder 2
        • Samuel Tallet
        • Simfonia >
          • Déformations
          • Rotations 1
          • Tableur
          • Texte
          • Visibility
          • Discret
          • Table
        • SketchUV
        • SUbD
        • SU vers OpenSpace3D
        • Twilight Render V2
        • Video01 Plug SU >
          • Video01 Plug SU
          • Video02 Plug SU
          • Video03 Plug SU
          • Video04 Plug SU
          • Video05 Plug SU
        • Vertex Tools: le Manuel
        • Viz pour SketchUp
        • Visualizer
      • ArtForm
      • Cv3D Nurbs free
      • Flowscape
      • GAEA
      • GifCam
      • GroBoto : Le Manuel etc
      • Manuel 3DCoat V4 VF
      • Monolith
      • SCULPTRIS
      • SimLab Composer 2016
      • VPaint
      • White Rabbit CAD
    • DesignSpark Mechanical >
      • DesignSpark
      • DesignSpark 1
      • Video DesignSpark
    • PolyCAD >
      • PolyCAD
      • Charger PolyCAD Free
      • Courbes & Surfaces
      • X - Topologie
      • Utilisation d'Images
      • Transformer
      • Générateur de Coques
      • Nuages de Points
      • Sections
      • Intersection/Ajustement
      • IntelliHull
      • Scripter PolyCAD
      • Edition 3D
      • Contraintes
      • Exemple IntelliHull
      • Vidéos PolyCad
      • Aide - Divers PolyCAD
      • Holtrop
      • Format E57
      • Image Editeur
      • Hydro
      • Geometric Analysis
    • Qubicle Conctructor >
      • Qubicle 2.0
      • Qubicle
      • Export OBJ
    • 3DCoat Print free
    • Clavicula
    • FlowScape.
    • Goxel
    • MagicaCSG
    • MagicaVoxel
    • MarkovJunior
    • Meadow
    • Origami Robert Lang
    • pCon-planner
    • Pearltrees
    • Plasticity
    • PolyBrush
    • Shape
    • SolveSpace
    • Tablettes Chocolat
    • TwinMotion
    • TreeIt
    • Verve
    • Vengi
Moment Of Inspiration: Ze Zen Nurbs Modeleur !
Libre adaptation du lexique de...
Goxel un générateur de Voxels Open Source  by Guillaume Chereau qui a la particularité d'avoir un mini-langage intégré pour la génération de ses objets! (n'est pas obligatoire c'est juste une facilité! ;)
Goxel est free en Local, ou sur le Net (limité) en webg en Ligne avec un Navigateur. Plan infini, Calques, Multi Plateformes, nombreux Exports!
Syntaxe de Base
shape main {
  cube[]
}
Photo
shape main est le point d'entrée du programme et cube [] est la commande utilisée pour rendre un cube. Ce programme rend un voxel de 1x1x1 à l'écran. Pour en rendre plus nous pouvons mettre des arguments à l'intérieur des crochets [].

shape main {
  cube[s 9]
}
Photo
ici le 9 indique au programme de faire le cube 9 fois plus grand (s est pour "l'échelle" (scale)). Si nous voulions une échelle différente du cube en x, y et z on aurait pu utiliser le réglage du s avec trois arguments: cube [s 3 4 5]. Comme il est commun à une seule échelle le long d'un axe unique, on peut donc utiliser sx, sy et sz.

shape main {
  cube[s 9]      
  cube[s 9 x 2]
}
Photo
Pour le second cube, nous utilisons deux réglages appliqués l'un après l'autre: s 9 pour l'échelle du cube, suivi par x 2 pour le déplacer à 2 fois sa taille.
Les arguments sont appliqués dans l'ordre, et sont non commutatifs, donc [s 9 x 2] est différent de [x 2 s 9], dans le premier cas, le cube est translaté par 9 voxels, dans le second cas que par 1!



Notez la syntaxe des arguments: toutes valeurs suivant l'argument sont opérationnelles jusqu'à ce que l'opération suivante soit un argument de cette opération.

Création de Formes

// Rendre un cube avec une sphere au sommet.
shape ma_forme {
  cube[]
  sphere[z 0.5]
}

shape main {
  ma_forme[s 20]
}
Photo
Nous rendons une nouvelle forme comme nous l'avons fait pour un cube. Les arguments que nous utilisons dans l'appel sont appliqués avant que la forme soit rendue :ici nous avons rendu la nouvelle forme mise à l'échelle 20 fois. La façon de le comprendre est que l'exécution du code est lié à un contexte. Le contexte définit la position, la taille et la couleur que nous utilisons. Lorsque nous appelons une nouvelle forme, nous reproduisons la valeur du contexte actuel et appliquons les arguments avant de rendre la forme. Il n'affecte pas le reste du rendu de l'appelant.

Formes Récursives
shape ma_forme {
  cylinder[]
  ma_forme [s 0.8 z 1]
}
shape main {
   ma_forme[s 20]
}
Photo
Une forme peut s'appeler pour un rendu récursif!

La
récursion est automatiquement arrêtée lorsque la forme devient trop petite..


Boucles
shape main {
  loop 8 [rz 45] {
  sphere[x 20 s 10]
  }
}
Photo
Nous pouvons utiliser la directive loop pour créer des boucles.

Cela exécutera
le bloc 8 fois, chaque fois avec un contexte de 45 ° de rotation autour de l'axe rz par rapport au précédent.
L'argument n'affecte uniquement que le bloc de la boucle.


Expressions
// Idem l'exemple precedent,
//mais la  sphere a une taille
//aleatoire comprise
//entre 4 & 16.
shape main {
  loop 8 [rz 45] {
    sphere[x 20 s 10+-6]
  }
}
Photo
Nous pouvons utiliser des expressions mathématique pour exprimer les arguments de réglage. Les opérations de base sont +, -, *, /,  et +-

Les opérateurs x +- y retournent une valeur aléatoire prise entre x - y et x + y. Cela peut être utilisé pour ajouter un peu de hasard à vos formes.


Règles de Forme
shape ma_forme
rule 4 {
  sphere[]
}
rule 1 {
  cube[]
}

shape main {
  loop 8 [rz 45] {
    ma_forme[x 20 s 8]
  }
}
Photo
Il est possible de donner plusieurs Implémentations de la même forme, et laisser le programme en choisir une au hasard.
Pour ce faire, nous utilisons les rule (règles) de forme

Dans
cet exemple, ma_forme est la plupart du temps une Sphère, mais parfois un cube.

Le "poids" donne les probabilités relatives d'utiliser une règle donnée, ici 4/5 de chance d'utiliser la première règle, et 1/5 de chance d'utiliser la seconde.


shape main {
[antialiased 1 seed 4]
test[s 16 life 40]
}

shape test
rule 5 {
cube[]
test[s 0.95 z 1]
}
rule 1 {
test[]
test[rz 0+-180 rx 90]
}
Photo
Ceci peut être utilisé pour les effets de branchement:
Donc, nous voyons ici quelque chose de nouveau:
[antialiased 1 seed 4]  applique un certain ajustement au contexte actuel: 1 améliore l'anti-crénelage du rendu avec l'algorithme "marching cube" et une graines de 4 mis comme semence initiale pour la fonction interne aléatoire. Dans cet exemple, nous pourrions avoir ces arguments dans l'appel du test.

L'argument life (vie) : life 40 est là pour arrêter la récursivité après 40 itérations.


Couleurs
Jusqu'à présent, tous les exemples utilisaient la couleur blanche. Voyons comment changer cela.

La couleur peut être modifiée à l'aide des trois réglages: la lumière, la teinte et la saturation, suivant le mode de couleur HSL. La teinte varie de 0 à 360, la saturation et de la lumière de 0 à 1.
La couleur blanche initiale correspond à une valeur de HSL (0, 0, 1).


Il y a trois opérations d'ajustement pour changer la couleur: hue (teinte), sat (saturation) et light (lumière). Chacun peut prendre un ou deux arguments.

   
hue x: ajoute la valeur x à la teinte actuelle. Si la valeur obtient plus de 360 ​​ou est inférieure à 0 un modulo est appliqué pour le remettre dans la gamme (0, 360).

    light
x: x dans l'intervalle [-1 1]. Si x < 0, modifiez la valeur de la lumière x % vers 0. Si x > 0, modifiez la valeur de lumière x % vers 1.

    
sat x: x dans l'intervalle [-1 1]. Si x < 0, modifiez la valeur de saturation x % vers 0. Si x > 0, modifiez la valeur de saturation x % vers1.

   
hue x h modifie la teinte courante vers x % h.

    light
x t modifie la valeur de lumière vers x % t.
 
    
sat x t modifie la valeur de saturation vers x % t.



shape main {
  [antialiased 1 sat 1 light -0.5]
  loop 12 [hue 30 rz 30] {
    sphere [s 4 x 4]
  }
}
Photo
Voici un petit programme d'un rendu de 12 sphères avec des valeurs de teinte différentes:
La première ligne donne au rendu un anti-crénelage de 1 et à la saturation initiale et de la lumière une valeur de 1 et 0,5.

shape main {
  [antialiased 1 sat 1 light -0.5]
  loop $i = 12 [z 8] {
    [sat 1 $i / 12]
    loop 12 [hue 30 rz 30]{
      sphere [x 14 s 6]
    }
  }
}
Photo
Voici un deuxième exemple où nous rendons ainsi toutes les valeurs de saturation de 0 à 1. Dans la section suivante La variable $ va être expliquée.

Les Variables
shape main {
  [hue 180 sat 0.5]
  loop $x = 10 [] {
      cube [x $x light $x / -10]
  }
}
Photo
Nous pouvons ajouter des variables au code. Tous les noms de variables commencent par un $, pour ne pas les confondre avec les arguments d'opérations.

La première façon d'utiliser la variable est par exemple l'expression de la boucle.


// Rendre n cubes
shape my_shape($n) {
  loop $n [z 2] {
      cube[]
  }
}

shape main {
  [light -0.5 sat 0.5]
  my_shape(10) []
  my_shape(8) [x 4 hue 90]
}
Photo
On peut donc utiliser la variable comme argument de formes. Dans le cas où les valeurs ont besoin d'être passées quand nous appelons la forme.
Note : les accents ne seront pas affichés dans les commentaires du code!
// pas d'accents!
Ses formats d'export permettent de basculer vers d'autres programmes 3D!
Photo
Photo

Photo
Programme exemple ci-dessous!
N'introduire dans l'éditeur que la partie anglaise!!!
// The 'main' shape is always the entry point of the program.
shape main {
    // Initial random seed of 2.
    // Remove this line to use different seed each time.
    [seed 2]
    // Improves marching cube rendering.
    [antialiased 1]

    // Render a single white voxel.
    cube []

    // Put an other cube next to it.
    // 'x' applies a translation of 1 along x.
    // Those transformation are only applied
    // to this cube.
    cube [x 1]

    // Now render a bigger grey sphere.
    // light -0.5 move the light value to half
    // the current value of 1 and the target
    sphere [s 10 x 1 light -0.5]

    // We can also render cylinders:
    cylinder [s 10 x -1 light -0.9]

    // This time we use a user defined shape.
    // And we increase the saturation to give it a color.

    my_shape [z 20 light -0.5 sat 0.5]
}

// A user defined shape
shape my_shape {
    // s 8 8 1 scales with different values
    // for each axis.
    // rx A applies a rotation along z of
    // 45 deg.

    // Note that the color is red, because we set the
    // Saturation when we called my_shape.
    cube [s 8 8 1  z 1  rz 45]

    // Loop 16 time, each time increasing the x
    // translation and the hue.
    loop 16 [x 2 hue 10] {
      cube []
    }
    // The loop transformations only affect
    // the loop block, after it we return to
    // the previous context.
    sphere [s 6 z 1]

    // Let's try a recursive shape:
    tree [x -10 s 4]

    // And an other one with a bit or randomness:
    tree2 [x 10 s 4 rz 180 hue 180]

    // A shape with several rules:
    my_other_shape [y 10 rz 90 hue -60 s 3]
}

// Tree render a cylinder and then call itself.
// Since we scale down the shape at each iteration
// at some point it becomes too small, and is
// then automatically stopped.
shape tree {
    cylinder []
    tree [z 1 s 0.99 ry -6]
}

shape tree2 {
    cylinder []
    // 'A +- B' means that we use a random value in the range
    // A - B, A + B.  this make the second spiral a bit
    // messy.
    tree2 [z 1 s 0.99 ry -6+-6]
}

// Here 'my_other_shape' defines several rules. 
//The rule used is picked randomly using the weight.

shape my_other_shape

// Most of the time, just keep growing in z.
rule 15 {
    cube []
    my_other_shape [z 1]
}

// Sometime split into two
rule 1 {
    my_other_shape [rx 45 s 0.9]
    my_other_shape [rx -45 s 0.9]
}

// Some other times render a shpere and stop
rule 0.5 {
    // 'hue 1 70' means that we immediatly
  //set the hue to 70 (yellow).
    sphere [s 3 hue 1 70]
}


// Le "shape main" est le point d'entrée du programme.
shape main {
    // Graine aléatoire donnée à 2.
    // Retirer cette ligne pour utiliser différente graine
    //à chaque fois.
    [seed 2]
    // Rendu du cube avec le mode "marching".
    [antialiased 1]

    // Rendre un cube seul blanc (un Voxel).
    cube []

    // mettre un autre cube à côté de celui-ci.
    // 'x' applique une translation de 1 le long des x.
    //Ces transformations ne sont appliquées qu'à
    // à ce cube

    cube [x 1]

     // Maintenant, une plus grande sphère grise est //créée. light -0,5 déplace la valeur de la lumière à la //moitié de la valeur actuelle de 1 et de la cible.
    sphere [s 10 x 1 light -0.5]

    // Nous pouvons rendre aussi les cylindres:
    cylinder [s 10 x -1 light -0.9]

    // Cette fois, nous utilisons une forme définie
    // par l'utilisateur. Et nous augmentons la saturation pour lui donner une couleur.
    my_shape [z 20 light -0.5 sat 0.5]
}

    // L'utilisateur définit une forme
shape ma_forme {
    // s 8 8 1 valeurs des différentes tailles
    // pour chaque axe.
    // rx applique une rotation le long des z de 45°.
   
   // Notez que la couleur est rouge, parce que nous   
    //définissons la Saturation en appelant ma_forme.
   
cube [s 8 8 1  z 1  rz 45]

    // Boucle 16 fois, en augmentant à chaque fois
    //la translation des x et hue. (teinte) 
    loop 16 [x 2 hue 10] {
      cube []
    }
    // Les transformations de la boucle ne touchent
  // que le bloc de la boucle, après le retour au //contexte précédent.
    sphere [s 6 z 1]

    // Essayons une forme récursive:
    tree [x -10 s 4]

    // Et une autre avec un peu d'aléa :
    tree2 [x 10 s 4 rz 180 hue 180]

    // Une forme avec plusieurs règles:
    mon autre_forme [y 10 rz 90 hue -60 s 3]
}

   // L'arbre fait un cylindre puis s'appelle lui-même.
   // Puisque nous réduisons la forme à chaque   //itération à un moment donné elle devient trop //petite et s'arrête automatiquement.
shape tree {
    cylinder []
    tree [z 1 s 0.99 ry -6]
}

shape tree2 {
    cylinder []
   // 'A + - B' signifie que nous utilisons une valeur aléatoire
   //  dans la gamme A - B, A + B.
  // Cela rend la seconde spirale un peu désordonnée.
    tree2 [z 1 s 0.99 ry -6+-6]
}
  
  // Ici 'mon_autre_forme' définit plusieurs règles.
   // La règle utilisée est choisie au hasard en utilisant le poids.
shape mon_autre_forme

// La plupart du temps, continue de grandir en z.
rule 15 {
    cube []
    mon_autre_forme [z 1]
}

// Quelques fois coupée en deux.
rule 1 {
    mon_autre_forme [rx 45 s 0.9]
    mon_autre_forme [rx -45 s 0.9]
}

// Quelques fois s'arrête et dessine une sphère
rule 0.5 {
    // 'hue 1 70' signifie que hue est directement mis
    // mis à to 70 (jaune).
    sphere [s 3 hue 1 70]
}