DP Tool Club 17/CD_ASCQ_17_101194.iso/dos/fr/luxart20/version2.doc

Text File | 1994-09-28 | 33KB | 969 lines

╔════════════════════════════════════════╗
║   Les nouvelles fonctions de la v2.0   ║   (Freeware)
╚════════════════════════════════════════╝

Ray-tracer
°°°°°°°°°°
· Nouvelles primitives :
        - Surface de révolution
        - Quadrique
        - Boîte
        - Trigonolithe
        - Terrain fractal
        - Tresse       ┐
        - Pseudotore   ├  dites
        - Hélice       ├  "complexes"
        - Lissajous    ┘
· Nouveaux échantillons de texture
        - Roche
        - Minéral
        - Tâche
        - Hybride
· Nouvelles fonctions de surface
        - Sculpture
        - Plisser
        - Bump-mapping à partir de fichiers graphiques .LUX, .TGA et .GIF.
· La fonction "plaquer_image" (Image-mapping) reconnaît désormais les fichiers
  .TGA et .GIF en plus des .LUX.
· Nouveaux paramètres d'Environnement
        - Stochastique
        - Enveloppe

Bureau
°°°°°°
· Nouveau format TIF.

Divers
°°°°°°
· Possibilité de spécifier le format d'image en ligne de commande (taper
  LUXART ?).
· Possibilité d'utiliser une variable d'environnement SET LUXART = %chemins%
· GifPeg v4.1.


La variable d'environnement de LUXART :
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

La nouvelle v2.0 est en mesure d'utiliser une variable d'environnement LUXART
à déclarer sous DOS par la directive SET. Elle vous permet d'indiquer au
programme d'autres chemins de répertoires à scruter (séparés par un ";" comme
dans le PATH de l'autoexec.bat) en plus des siens.

Exemple :
SET LUXART=C:\DPTOOLS;D:\LUXART\TEST;D:\RTRACE\IMAGES;


╔════════════════╗
║   LE LANGAGE   ║
╚════════════════╝

Rappel :
°°°°°°
┌------------┬-----------------┬----------------┬----------------┐
| Paramètres |    Définition   |     Exemple    |     Valeurs    |
├------------┼-----------------┼----------------┼----------------┤
|   x y z    | Vecteur         | 5  -47  62.11  | Toutes         |
|   r v b    | Couleur         | 0.0  0.58  1.0 | Entre 0 et 1   |
|   ent      | Entier          | 320, -54, 0... | Toutes non déc.|
|   déc      | Décimal         | -24.78, 1.4... | Toutes déc.    |
|   ent+     | Entier positif  | 1024           | Toutes >= 0    |
|   déc+     | Décimal positif | 8.5, 0.1574... | Toutes >= 0    |
|   $texte$  | Chaîne de carac.| Bois_Clair     | ASCII 80c. max |
└------------┴-----------------┴----------------┴----------------┘


Environnement :
=-=-=-=-=-=-=

2 nouveaux paramètres ont été implantés dans la fonction "environnement" :

1°) STOCHASTIQUE
    =-=-=-=-=-=-
Au moment de lancer le calcul d'une scène et juste avant d'entamer la procédure
du suivi de rayons, LUXART génère un tableau de 512 points pseudo-aléatoires qui
va servir de base à toutes ses fonctions de calcul de turbulence et de
perturbation de normales. Elles sont surtout utilisées pour contrôler les
textures et matières. Jusqu'à présent, on obtenait donc toujours les mêmes
motifs puisque les valeurs de ce tableau ne variaient jamais. Désormais, en
utilisant ce nouveau paramètre "stochastique" dans la structure Environnement,
LUXART calcule les valeurs du tableau à partir d'un générateur de nombres
aléatoires réels et offre ainsi la possibilité d'obtenir des motifs et des
perturbations de surface différents à chaque rendu. Cependant, de par ce fait,
il faudra se rappeler de ne pas interrompre un rendu stochastique final car en
cherchant à le continuer ultérieurement, les textures ne seront plus les mêmes
à partir de la ligne où a été interrompu le tracé de l'image.


2°) ENVELOPPE
    =-=-=-=-=
Paramètre optionnel qui permet de contrôler la contenance des enveloppes (boîtes
englobantes). La valeur par défaut est de 4 (primitives) et semble apparemment
être le meilleur compromis temps de calcul/occupation mémoire. Une valeur
inférieure à 2 serait "suicidaire" et causerait d'inévitables problèmes.
Une valeur trop élevée (8 ou +) forcerait l'arbre hiérarchique à déployer plus
fréquemment de nouvelles ramifications à différents niveaux, ce qui donnerait
des résultats trop superficiels et donc non optimisés. Puisque ce paramètre
est désormais public, il n'est pas interdit de l'utiliser, mais je doute fort
que les résultats obtenus soient meilleurs qu'avec la valeur imposée par défaut.

Exemple :
°°°°°°°
environnement
{
        position_camera 0 -31 4
        pointe_vers     0 9 1
        cote            0 0 1
        champ_visuel    65
        resolution      640 480
        anti_crenelage  recursif
        seuil           4
        facteur_proportionnel 1.3334
        stochastique
        caustiques
        fond            { ciel.pal }
        enveloppes      5
        atmosphere      .08 .08 .09
}


Nouveaux échantillons :
=-=-=-=-=-=-=-=-=-=-=

Remarque : la définition des paramètres "transition" et "cycle" est expliquée
°°°°°°°°   dans le fichier LUXART.DOC (même fonction que les échantillons de
           la v1.0 et 1.1).

1°) ROCHE
    =-=-=
Produit une apparence synthétique de granite pur entre les 2 matières.

matiere
{
 texture
 {
  echantillon    roche
  ajuster        x y z
  cycle          déc+ ou ent+
  ...
  matiere                      // Première matière
  {
   diffuse       r v b
   ...
  }
  matiere                      // Seconde matière
  {
   diffuse       r v b
   ...
  }
 }
}

Exemple :
°°°°°°°
matiere
{
 texture
 {
  echantillon roche
  cycle 3
  ajuster .6 .6 .6
  transition .4
  matiere { diffuse Terre_de_Sienne4 }
  matiere { diffuse Kaki2 }
 }
}


2°) MINERAL
    =-=-=-=
Produit un motif synthétique à base de minerais pur entre les 2 matières,
proche de celui de l'agate ou du marbre.

matiere
{
 texture
 {
  echantillon    mineral
  ajuster        x y z
  transition     déc+ 0 à 1
  cycle          déc+ ou ent+
  octaves        ent+          // Contrôle le niveau de la turbulence infligée
                               // à l'échantillon.
  ...
  matiere                      // Première matière
  {
   diffuse       r v b
   ...
  }
  matiere                      // Seconde matière
  {
   diffuse       r v b
   ...
  }
 }
}

Les valeurs conseillées pour le paramètre "octaves" vont de 1 à 10.

Exemple :
°°°°°°°
matiere
{
 texture
 {
  echantillon mineral
  cycle 2
  transition .7
  octaves 3
  matiere { diffuse Vert_Olive_Fonce speculaire 90 Blanc }
  matiere { diffuse Vieil_Or speculaire 90 Blanc reflexion .2 .2 .2 }
  turbulence { amplitude 4 cycle 4 }
 }
}


3°) TACHE
    =-=-=
Génère un motif de tâches concentriques alternativement et régulièrement
espacées qui répond à l'équation :

     ┌ sin(x) + sin(y) + sin(z)┐²
 M = │──────────────────────── │
     └           3             ┘

matiere
{
 texture
 {
  echantillon    tache
  ajuster        x y z
  transition     déc+ 0 à 1    // contrôle le fondu entre la zone d'espacement
                               // et la tâche
  ...
  matiere                      // Première matière
  {
   diffuse       r v b
   ...
  }
  matiere                      // Seconde matière
  {
   diffuse       r v b
   ...
  }
 }
}

Exemple :
°°°°°°°
matiere
{
 texture
 {
  echantillon tache
  matiere { diffuse Noir speculaire 40 Blanc }
  matiere { diffuse Rouge_Brique speculaire 40 Blanc }
  transition .35
  ajuster .25 .25 .25
 }
}


4°) HYBRIDE
    =-=-=-=
Produit un motif hybride du bois et du marbre (ou de l'agate).

matiere
{
 texture
 {
  echantillon    hybride
  ajuster        x y z
  transition     déc+ 0 à 1
  octaves        ent+          // Contrôle le niveau de la turbulence infligée
                               // à l'échantillon.
  lambda         dec+          // valeur par défaut : 2.0
  omega          dec+          // valeur par défaut : 0.5
  ...
  matiere                      // Première matière
  {
   diffuse       r v b
   ...
  }
  matiere                      // Seconde matière
  {
   diffuse       r v b
   ...
  }
 }
}

"lambda" : contrôle le dosage du facteur "hasard" d'une octave à une autre dans
          la perturbation des veinures de l'échantillon. Plus la valeur fixée
          s'éloigne de 1.0, et plus les trajectoires des turbulences auront
          tendance à tourbillonner.

"omega" : contrôle l'évolution des calculs de la perturbation. Chaque octave
          successive de turbulence est multipliée par cette valeur. Plus la
          valeur est élevée (s'éloigne de 0.0), et plus le degré de turbulence
          sera prononcé dans les octaves successivement croissantes.

Les valeurs conseillées pour le paramètre "octaves" vont de 1 à 10.

Exemple :
°°°°°°°
matiere
{
        texture
        {
                echantillon hybride
                transition .8
                octaves 2
                lambda 1.4
                omega 0.75
                ajuster 4 2 2
                matiere { diffuse Blanc speculaire 60 Blanc }
                matiere { diffuse Noir speculaire 60 Blanc }
        }
}


Nouvelles fonctions de surface :
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

PS : Le mot clé "bosses" devient officiellement "surface", même si "bosses"
°°   est toujours reconnu.

Il y a désormais 5 fonctions de surface en tout. Les deux premières sont déjà
connues : "turbulence" et "vague". Les 3 autres sont :
- sculpture
- graver_image (Bump-mapping)
- plisser


1°) SCULPTURE
    =-=-=-=-=
Permet de sculpter sur la surface de l'objet le motif dessiné par
l'échantillon. On peut alors facilement obtenir une matière dont les veines
sont, par exemple, reproduites en relief. Néanmoins, on peut constater que ce
relief est nettement plus visible lorsque les deux matières de l'échantillon
ont la même couleur.

matiere
{
 texture
 {
  echantillon    mineral
  ajuster        x y z
  transition     déc+ 0 à 1
  cycle          déc+ ou ent+
  octaves        ent+
  ...
  matiere                      // Première matière
  {
   diffuse       r v b
   ...
  }
  matiere                      // Seconde matière
  {
   diffuse       r v b
   ...
  }
 }
 surface
 {
        sculpture
        {
                amplitude déc+ 0 à 1 // quantité max. de perturbation
                                     // infligée à la normale.
                inverse              // option qui inverse le sens de la normale.
        }
 }
}


2°) GRAVER_IMAGE (bump-mapping)
    =-=-=-=-=-=-
Permet de graver un fichier image LUX 24-bits, TGA 24-bits ou GIF 8-bits placé
dans le répertoire TEXTURES (ou dans un des répertoires de la variable LUXART)
sur la surface d'un objet. Son principe est similaire à celui de la fonction
d'image-mapping "plaquer_image" avec la grande différence qu'il perturbe la
normale en chaque point de la surface en fonction de la couleur du pixel
correspondant du fichier.

 {
  graver_image    $texte$  // nom du fichier image LUX, TGA ou GIF.

  position        x y z    // position du coin supérieur gauche de l'image.

  cadre           x y z    // vecteur qui longe le haut de l'image en la
                           // traversant du coin supérieur gauche au coin
                           // supérieur droit.

  normale         x y z    // normale de la surface sur laquelle est
                           // plaquée l'image.

  ajuster         ent+ ou déc+  // taille de l'image sachant que 1.0 est
                                // sa taille réelle.

  amplitude       déc      // variation à infliger à la normale.

  inverse                  // option qui inverse le sens de la normale.
 }
 ...

Précision : cette image est gravée autant de fois qu'il le faut pour recouvrir
°°°°°°°°°   intégralement la surface si l'ajustement de sa taille reste
            inférieure à celle de la surface. Pour qu'il n'embrasse qu'une
            seule fois la surface, il faut jouer sur le paramètre 'ajuster'.

Exemple : (tiré de CAVE2.ART)
°°°°°°°
matiere
{
 diffuse
 {
  plaquer_image carreau8.gif
  centre 0 0 0
  cadre 1 0 0
  normale 0 0 1
  ajuster 27
 }
 surface
 {
  graver_image
  {
   gravure carreaub.gif
   centre 0 0 0
   cadre 1 0 0
   normale 0 0 1
   ajuster 27
   amplitude .8
  }
 }
}

disque
{
 centre 0 0 0
 normale 0 0 1
 rayon 1000
}

Dans cet exemple, on cherche à reproduire un pavage réaliste. Pour cela, on
'plaque' le fichier CARREAU8.LUX qui contient le motif des pavés, et on 'grave'
l'autre fichier CARREAUB.GIF qui contient les contours préparés pour du
bump-mapping de ces mêmes pavés. Vous remarquerez que les valeurs des paramètres
des 2 fonctions sont identiques.


3°) PLISSER
    =-=-=-=
Perturbe la normale en chaque point de la surface de façon à lui donner une
apparence de tissu plissé ou froissé.

matiere
{
   diffuse       r v b
   ...
   surface
   {
        plisser déc+ 0 à 1 // quantité max. de perturbation infligée à la
   }                       // normale.
}


Nouvelles primitives :
=-=-=-=-=-=-=-=-=-=-

1°) SURFACE DE REVOLUTION
    =-=-=-=-=-=-=-=-=-=-=
Construit une surface de révolution en faisant pivoter autour de l'axe de
révolution Z la courbe de profil (2D) génératrice de l'objet.
Beaucoup d'objets autour de nous répondent à ce type de critère (verre, vase,
bouteille, assiette, sculpture, fontaine, table, colonne etc...). Il sera donc
désormais très facile de les reproduire rapidement avec cette nouvelle
primitive.

           +Z                   Coordonnées (x, z) des points :
         6┼   ∙                 (1.6, 6)
         5┼    ∙                (2, 5)
         4┼   ∙                 (1.6, 4)
         3┼ ∙                   (1, 3)
         2┼∙                    (0.5, 2)
         1┼ ∙                   (1, 1)
──────────0─┼∙─┼──┼──┼── +X     (1.3, 0)
          │ 1  2  3  4
          │
          │
          │

Sa syntaxe est la suivante :

revolution
{
        pas     ent+    // valeur incrémentale pour une révolution complète.
        sommets ent+    // nombre de points qui composent le profil de courbe.
        liste   x z     // coordonnées (x, z) de chacun de ces points.
                x z
                ...
}

La surface générée est toujours orientée X Y (normale 0 0 1). Il faut donc au
besoin, l'orienter en l'encadrant dans une structure "bloc / fin_bloc".

Plus la valeur du pas est grande, et plus la surface de révolution engendrée
aura de faces. Ce pas ne doit pas être inférieur à 3. Une valeur raisonnable
se situe entre 20 et 60.
Le nombre de sommets doit être inférieur ou égal à 32. La surface obtenue
est automatiquement lissée afin d'adoucir les contours.

Exemple : (suivant la courbe de profil dessinée ci-dessus)
°°°°°°°
revolution
{
        pas 32
        sommets 7
        liste 1.6  6
              2    5
              1.6  4
              1    3
              .5   2
              1    1
              1.3  0
}


2°) QUADRIQUE
    =-=-=-=-=
Génère une surface définie par l'équation du second degré :

        Ax² + By² + Cz² + Dxy + Exz + Fyz + Gx + Hy + Iz + J = 0

Elle permet de créer des surfaces comme la sphère, l'ellipsoïde, les
paraboloïdes elliptiques ou hyperboliques, les hyperboloïdes à une ou deux
nappes etc... Cependant, de par certaines contraintes que nous imposent la
façon dont LUXART doit traiter les primitives (notamment le fait que l'origine
(0, 0, 0) doit se trouver au centre de la surface générée), l'équation notée
ci-dessus va être considérablement simplifiée et ramenée à :

        Ax² + By² + Cz² + Ey = D

La syntaxe de cette primitive est donc la suivante :

quadrique
{
        centre          x y z   // position initiale de la quadrique.
                                // 0 0 0 est le vecteur par défaut.
        composantes     A B C   // coeff. de l'équation
                        D E 0
}                           └─> doit toujours être un zéro !

Voici un tableau des signes des coefficients de l'équation pour générer les
quadriques "classiques" :

                                A       B       C       D       E
Cône elliptique                 +       -       +       0
Ellipsoïde                      +       +       +       +
Hyperboloïde à une nappe        +       -       +       +
Hyperboloïde à deux nappe       -       -       +       +
Paraboloïde elliptique          +               +       0       -
Paraboloïde hyperbolique        +               -       0       -

Exemple : (génère une ellipsoïde)
°°°°°°°
quadrique
{
        centre 3 0 2
        composantes  5 10 10
                    15  0  0
}


3°) BOITE
    =-=-=
Génère un parallélépipède rectangle dont on fixe la hauteur (axe Z), la
largeur (axe X) et la profondeur (axe Y).
Sa syntaxe est la suivante :

boite
{
        position        x y z   // 0 0 0 est le vecteur par défaut.
        largeur         x
        profondeur      y
        hauteur         z
}

La primitive est déployée depuis les coordonnées (x, y, z) de 'position'.
Une 'largeur' négative signifie que les faces correspondantes seront
construites sur l'axe -X.
Une 'profondeur' négative signifie que les faces correspondantes seront
construites sur l'axe -Y.
Une 'hauteur' négative signifie que les faces correspondantes seront
construites sur l'axe -Z.

Exemple :
°°°°°°°
boite
{
        position        0 -5 1
        largeur         -4
        profondeur      10
        hauteur         3
}


4°) TRIGONOLITHE
    =-=-=-=-=-=-
Ce terme un peu barbare est un mot composé spécialement pour le cas de LUXART.
C'est la fusion de "trigonométrie" et de "lithe", tout cela pour définir cette
puissante primitive qui, à elle seule, effectue le même travail que certains
utilitaires spécifiques destinés à d'autres ray-tracers.
En effet, elle permet d'utiliser directement un fichier ASCII de format RAW
et de le transformer en primitive autonome.
Sa syntaxe est la suivante :

trigonolithe $texte$    // on indique en paramètre de nom du fichier en
                        // question.

Ce type de fichier est exclusivement composé de coordonnées de triangles, la
plupart du temps calculées par des modeleurs ou des utilitaires externes (il y
en a beaucoup en Freeware/Shareware), qui forment un objet complet.
Voici un exemple du contenu d'un tel fichier :

 -3.52 -4.19 -5.08  -3.91 -6.21 -5.08   -3.4 -6.21 -7.01
  -3.4 -6.21 -7.01  -3.07 -4.19 -6.82  -3.52 -4.19 -5.08
 -3.07 -4.19 -6.82   -3.4 -6.21 -7.01  -1.99 -6.21 -8.43
 -0.04 -6.21 -5.08   -3.4 -6.21 -7.01  -3.91 -6.21 -5.08
 -1.99 -6.21 -8.43  -1.79 -4.19  -8.1  -3.07 -4.19 -6.82
 -0.04 -6.21 -5.08  -1.99 -6.21 -8.43   -3.4 -6.21 -7.01
 -1.79 -4.19  -8.1  -1.99 -6.21 -8.43  -0.05 -6.21 -8.95
 -0.04 -6.21 -5.08  -0.05 -6.21 -8.95  -1.99 -6.21 -8.43
 -0.05 -6.21 -8.95  -0.05 -4.19 -8.56  -1.79 -4.19  -8.1
 -3.52 -4.19 -5.08  -2.78 -3.57 -6.65   -3.2 -3.57 -5.08
 -2.78 -3.57 -6.65  -3.52 -4.19 -5.08  -3.07 -4.19 -6.82
 -3.07 -4.19 -6.82  -1.62 -3.57 -7.81  -2.78 -3.57 -6.65
 -1.62 -3.57 -7.81  -3.07 -4.19 -6.82  -1.79 -4.19  -8.1
 -1.79 -4.19  -8.1  -0.05 -3.57 -8.24  -1.62 -3.57 -7.81
 -0.05 -3.57 -8.24  -1.79 -4.19  -8.1  -0.05 -4.19 -8.56
 -2.55 -3.34 -5.08   -3.2 -3.57 -5.08  -2.78 -3.57 -6.65
 -2.78 -3.57 -6.65  -2.23 -3.34 -6.33  -2.55 -3.34 -5.08
  etc...

Ici, chaque ligne correspond à un triangle (X Y Z du premier sommet, X Y Z du
second sommet et X Y Z du troisième sommet).
Cette primitive assemble donc tous ces triangles de façon à générer l'objet,
mais en plus, lisse la surface obtenue afin d'adoucir les angles formés par
les triangles adjacents.
A moins d'avoir une grande quantité de mémoire RAM, cette fonction est à
utiliser avec modération car chaque triangle peut être ici considéré comme une
primitive "triangle lissé" puisque, une fois sa normale déterminée, il en aura
toutes les caractéristiques.
Le fichier de triangles ne doit pas non plus contenir autre chose que les
valeurs numériques décimales des coordonnées. Pas de texte sous peine d'erreur.

Exemple :
°°°°°°°
trigonolithe BUSTE.TRI


5°) TERRAIN FRACTAL
    =-=-=-=-=-=-=-=
Cette primitive permet de générer toute sorte de rocher naturel plus ou moins
accidenté (montagne etc...). Elle se développe à partir d'une technique de
subdivision récursive de triangles.
Sa syntaxe est la suivante :

terrain
{
        etendue x y z           // position du sommet principal
                V1x V1y V1z     // Vecteur1 : étendue du premier côté depuis
                                //            le sommet principal
                V2x V2y V2z     // Vecteur2 : étendue du second côté depuis
                                //            le sommet principal
        composantes     R C It
}

"etendue" : définit la position et la taille du triangle de base qui va être
            récursivement subdivisé. C'est donc à partir de ce triangle que
            va être déployé le terrain.

L'apparence du terrain est contrôlée par le paramètre "composantes". Il est
très important de se rappeler que les résultats obtenus par ces trois valeurs
dépendent essentiellement de LA TAILLE du triangle de base. Les mêmes
composantes ne calculeront pas le même rocher sur 2 triangles qui n'ont pas
la même étendue.
Le paramètre "composantes" se décompose de la façon suivante :
R : déc+ de 0 à 1, contrôle la rugosité ; plus la valeur est proche de 0, et
    plus la primitive sera accidentée.
C : ent+ ou déc+, contrôle la croissance de fractalisation. C'est elle qui
    assure globalement la taille (volume) de la primitive finale générée.
    Cette valeur est très dépendante de la taille du triangle sur lequel on
    travaille. Par exemple, une valeur de 15 apparaîtra faible sur un triangle
    d'une étendue équivalente à 150 ou 200, mais sera colossale sur une
    étendue de 1 ou 2.
It : ent+, indique le nombre d'itérations (niveaux récursifs). Cette valeur
     contrôle donc le nombre total de triangles (facettes) qui vont composer
     la primitive finale. Attention aux valeurs trop élevée qui se révèlent
     vite gourmandes en mémoire :
     1 -> 4 facettes    (4x1)
     2 -> 16 facettes   (4x4)
     3 -> 64 facettes   (16x4)
     4 -> 256 facettes  (64x4)   // donne déjà de bons résultats.
     5 -> 1024 facettes (256x4)  // ma préférée...
     6 -> 4096 facettes (1024x4) // si vous avez du temps et de la mémoire...
     etc...

La primitive finale obtenue est systématiquement lissée afin d'adoucir les
angles formés par les triangles adjacents, ce qui rend le rocher nettement
plus réaliste et moins agressif.

Exemple :
°°°°°°°
terrain
{
        etendue 0 -30 0
                0 30 50
                30 30 0
        composantes 0.6 12.5 5
}


Les 4 primitives suivantes dont dites "complexes", non pas parce qu'elles
manipulent des nombres complexes ou imaginaires, mais parce qu'elles sont
générées par des procédures internes qui mettent en combinaison certaines
primitives de base de LUXART. Ceci est bien évidemment transparent pour
l'utilisateur, mais de par ce fait, il faudra se rappeler que la place qu'elles
occuperont en mémoire sera fonction du nombre de primitives de base qui
serviront à les développer.
Il faut néanmoins noter que ces "formes" (qui ne sont que le début d'une série
que je continuerais et que j'améliorerais dans les futures versions) ouvrent de
nouveaux horizons créatifs et facilitent l'accès à la réalisation de scènes
dont les scripts n'auraient pu être générés que par des procédures externes et
autonomes.


6°) LISSAJOUS
    =-=-=-=-=
Génère une courbe 3D périodique fonction du temps.
Une sphère est systématiquement placée sur chaque point (x, y, z) calculé de la
courbe. Un connecteur cylindrique relie deux sphères contigües de façon à
représenter la primitive par un tube lissé.
Sa syntaxe est la suivante :

lissajous
{
        composantes     M S r R
                        A B Ex Ey Ez
        centre          x y z           // 0 0 0 est le vecteur par défaut.
        collier         dec+            // optionnel
        perles                          // optionnel
}

La primitive générée est toujours orientée X Y (normale 0 0 1). Il faut donc au
besoin, l'orienter en l'encadrant dans une structure "bloc / fin_bloc".

Le paramètre "composantes" se décompose de la façon suivante :
M : ent+ de 1 à 5, représente la méthode de calcul de la courbe. Les équations
    sont donc écrites de 5 façons différentes. C'est ce premier paramètre qui
    contrôle la "forme" finale de la courbe.
S : ent+, correspond au nombre de points (centre de chaque sphère) qui doivent
    composer la courbe. Plus ce nombre est grand, plus la courbe sera lisse.
r : ent+, représente le rayon de chaque sphère.
R : ent+, dénote le rayon global de la primitive. Toutes les coordonnées calculées
    seront comprises entre +R et -R.
A : déc+, première variable qui affecte la génération de la courbe. Les grandes
    valeurs ne donnent pas de bons résultats.
B : déc+, seconde variable qui affecte la génération de la courbe. Les grandes
    valeurs ne donnent pas de bons résultats.
Ex, Ey et Ez : ent+ de 1 à 9, exposants des coordonnées respectives dans les
               équations.

"collier" : Par défaut, le rayon du connecteur cylindrique est le même que celui
            des deux sphères contiguës qu'il relie. Si ce paramètre est spécifié,
            sa valeur sera utilisée comme rayon de ce connecteur.

"perles" : Si ce paramètre est spécifié, seules les sphères seront utilisées
           pour générer la forme de la primitive, les connecteurs seront
           supprimés.

Exemple :
°°°°°°°
lissajous
{
        composantes     3 500 0.5 50
                        0.95 0.5 1 1 1
        centre          10 0 50
}


7°) HELICE
    =-=-=-
Génère une primitive en forme d'hélicoïde.
Une hélice est une courbe engendrée par une droite qui s'enroule régulièrement
sur un cylindre ou un cône.
Une sphère est systématiquement placée sur chaque point (x, y, z) calculé de la
courbe. Un connecteur conique relie deux sphères contigües de façon à
représenter la primitive par un tube lissé.
Sa syntaxe est la suivante :

helice
{
        composantes     R1 R2 r1 r2
                        H nR S
        centre          x y z           // 0 0 0 est le vecteur par défaut.
        collier         dec+            // optionnel
        perles                          // optionnel
}

L'hélice générée est toujours orientée X Y (normale 0 0 1). Il faut donc au
besoin, l'orienter en l'encadrant dans une structure "bloc / fin_bloc".

Le paramètre "composantes" se décompose de la façon suivante :
R1 : déc+, rayon de départ de l'hélice.
R2 : déc+, rayon d'arrivée de l'hélice.
r1 : déc+, rayon de la première sphère qui compose l'hélice. Cette valeur doit
     être obligatoirement inférieure à R1.
r2 : déc+, rayon de la dernière sphère qui compose l'hélice. Cette valeur doit
     être obligatoirement inférieure à R2.
H : déc+, hauteur totale de l'hélice (sur l'axe Z).
nR : ent+, nombre de révolutions complètes effectuées par l'hélice.
S : ent+, nombre de points (centre de chaque sphère) pour 1 révolution de
    l'hélice (nombre de points total = nR * S).

"collier" : Par défaut, le rayon du connecteur conique est le même que celui
            des deux sphères contiguës qu'il relie. Si ce paramètre est spécifié,
            sa valeur sera utilisée comme rayon de ce connecteur.

"perles" : Si ce paramètre est spécifié, seules les sphères seront utilisées
           pour générer la forme de la primitive, les connecteurs seront
           supprimés.

La transition entre r1 et r2 se fait au fur et à mesure du développement de
l'hélice.

Exemple :
°°°°°°°
helice
{
        composantes     4 1 1.2 0.1 12 3 40
        centre          0 -5 5
        perles
}


8°) TRESSE
    =-=-=-
Génère une primitive caractérisée par l'entrelacement de tores déformés.
Une sphère est systématiquement placée sur chaque point (x, y, z) calculé de la
courbe. Un connecteur cylindrique relie deux sphères contigües de façon à
représenter la primitive par un tube lissé.
Sa syntaxe est la suivante :

tresse
{
        composantes     S RS T t R r
        centre          x y z           // 0 0 0 est le vecteur par défaut.
        collier         dec+            // optionnel
        perles                          // optionnel
}

La primitive générée est toujours orientée X Y (normale 0 0 1). Il faut donc au
besoin, l'orienter en l'encadrant dans une structure "bloc / fin_bloc".

Le paramètre "composantes" se décompose de la façon suivante :
S : ent+, nombre total de points (centre de chaque sphère) pour générer la
    primitive.
RS : déc+, rayon individuel de chaque sphère.
T : ent+, nombre de tores à entrelacer.
t : ent+, nombre de tortillons engendrée par chaque tube pour 1 révolution
    complète de la tresse.
R : déc+, rayon majeur de la tresse.
r : déc+, rayon mineur de la tresse.

"collier" : Par défaut, le rayon du connecteur cylindrique est le même que celui
            des deux sphères contiguës qu'il relie. Si ce paramètre est spécifié,
            sa valeur sera utilisée comme rayon de ce connecteur.

"perles" : Si ce paramètre est spécifié, seules les sphères seront utilisées
           pour générer la forme de la primitive, les connecteurs seront
           supprimés.

Exemple :
°°°°°°°
tresse
{
        centre 0 0 1
        composantes 120 0.2 3 2 2.5 0.3
}


9°) PSEUDOTORE
    =-=-=-=-=-
Dans les version antérieures de LUXART, cette primitive était générée par une
procédure "Modèle de Tore" accessible depuis la barre des menus du Bureau.
Elle a été améliorée et ramenée à une primitive interne à part entière, le
pseudotore.
Sa syntaxe est la suivante :

pseudotore
{
        centre          x y z           // 0 0 0 est le vecteur par défaut.
        rayon           déc+ > 0        // rayon du pseudotore.
        rayon_tube      déc+ > 0        // rayon du tube. Doit être inférieur
                                        // au rayon du pseudotore.
        segments        ent+            // nombre total de segments à calculer
                                        // pour créer le pseudotore. Doit être
                                        // supérieur ou égal à 4.
        methode         ent+ 1 ou 2     // type de combinaison de primitives
                                        // de base. Valeur par défaut : 1.
        collier         dec+            // optionnel.
        perles                          // optionnel.
}

Le tore généré est toujours orienté X Y (normale 0 0 1). Il faut donc au besoin,
l'orienter en l'encadrant dans une structure "bloc / fin_bloc".

"methode" : 1 -> sphères + connecteurs.
            2 -> facettes lissées.

Dans le cas où la méthode utilisée est 1 (par défaut), une sphère est
systématiquement placée sur chaque point (x, y, z) calculé de la courbe. Un
connecteur cylindrique relie deux sphères contigües de façon à représenter la
primitive par un tube lissé.

"segments" : Contrôle la forme arrondie du pseudotore. Plus sa valeur est
             élevée, et plus le tore engendré sera lisse. Il permet donc
             d'obtenir des effets intéressants comme par exemple la possibilité
             d'avoir un tore hexagonal, octogonal etc...

"collier" : Par défaut, le rayon du connecteur cylindrique est le même que celui
            des deux sphères contiguës qu'il relie. Si ce paramètre est spécifié,
            sa valeur sera utilisée comme rayon de ce connecteur.
            Ce paramètre n'a aucune fonction si la méthode choisie est 2.

"perles" : Si ce paramètre est spécifié, seules les sphères seront utilisées
           pour générer la forme de la primitive, les connecteurs seront
           supprimés.
           Ce paramètre n'a aucune fonction si la méthode choisie est 2.

Exemple :
°°°°°°°
pseudotore // hexagonal...
{
        centre 0 25 -10
        rayon 5
        rayon_tube .7
        segments 6
}


MISE A JOUR DU FICHIER "COULEURS.INC"
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Dans les précédentes versions de LUXART, il y avait une erreur de syntaxe dans
le fichier de déclaration des couleurs COULEURS.INC. En effet, la couleur
"Viel_Or" a été rectifiée à sa véritable syntaxe qui est "Vieil_Or". Il faudra
donc apporter les modifications nécessaires à vos scripts utilisant cette
couleur afin de ne pas avoir d'erreur lors de la phase d'analyse.
De plus, 91 déclarations de nouvelles couleurs ont été rajoutées, pour la
plupart écrites en anglais.