Lingo

Les variables numériques en Lingo sont simplifiées. Les variables globales ou d'objet ne se déclarent qu'en dehors des fonctions. Les variables locales sont déclarées implicitement.

Le typage est implicite, ainsi:

• a=10 crée un integer
• a=10.0 crée un décimal.

Il n'existe pas de variables booléennes, Lingo utilise les entiers 0 et 1, qui pour des raisons de lisibilité peuvent toutefois s'écrire true et false.

Les chaînes de caractères peuvent être lus comme des tableaux à l'aide de la variable globale "the itemDelimiter" et la prioriété .item des strings, ou bien les propriétés .line et .word des string.

les noms des variables peuvent contenir des lettres, des chiffres, ou le signe underscore. Elles ne peuvent pas commencer par un chiffre.

On peut créer des symboles avec le signe dièse (#). Un symbole n'est pas une variable mais un nom de variable ou fonction.

Par exemple, dans maCouleur = #rouge, le mot #rouge ne signifie rien pour Lingo ; en revanche, maCouleur = couleurs[#rouge] permet de retrouver la propriété rouge de l'objet couleurs, la fonction call(#rouge, obj, arguments...) permet d'appeler la méthode rouge de l'objet obj.

• l'affectation se fait avec le signe =
• la comparaison se fait ainsi :
  • = (égalité)
  • < (inférieur)
  • > (supérieur)
  • <= (inférieur ou égal)
  • >= (supérieur ou égal)

les opérateurs sont les mêmes qu'il faille comparer des entiers, des chaînes, ou quoi que ce soit d'autre.

• il y a deux types de division, toutes les deux se codent avec le caractère /. Si les deux nombres sont des entiers alors lingo effectue une division entière. Le reste de la division est obtenu avec l'opérateur mod.
• les fonctions bitAnd(), bitOr(), bitXor() et bitNot() permettent d'effectuer des opérations binaires sur des entiers traités comme des tableaux de 32 bits. Ces fonctions sont lourdes car elles passent par des conversions: pour lire rapidement un tableau de bits on utilise plutôt la division entière et le modulo, mais on perd le 32^e bit.

Lingo possède une liste de classe correspondant aux structures de données classiques, avec d'importantes automatisations.

La classe list contient un tableau à mémoire dynamique. Ces tableaux sont "one-based", le premier index est égal à 1. Cela permet d'utiliser le zéro comme identifiant nul lorsque l'on référence les index.

Y écrire ou y lire le contenu d'une cellule est une opération aussi lourde que la syntaxe pointée (plus lente sur des grosses listes que des petites). Pour optimiser les opérations sur les tableaux il faut utiliser le plus possible l'algèbre des tableaux, qui évite de nombreuses lectures de cellule.

Les listes se créent ainsi :

monTableau = [] ou monTableau = [1,2,"a",0,"b"]

Les tableaux peuvent contenir n'importe quel types de données:

monTableau =[[1,vector(1,2,3)],[model1,image12]]

• list.sort() permet un tri croissant automatique.
• list.add() permet d'insérer des données dans une liste sortie en conservant l'ordre de tri.
• list.append() ajoute un élément à la fin du tableau, casse l'ordre de tri
• list.getOne(valeur) fait une recherche automatique dans le tableau pour trouver l'index de la valeur
• list.deleteOne(valeur) rechercher l'index de la valeur puis efface la cellule
• list.deleteAt(index) efface une valeur à un index précis
• list.addAt(index, value) insère une valeur à l'index voulu

Les tableaux peuvent utiliser tous les types d'opérateurs compatibles avec le contenu des cellules. Cela permet une considérable accélération des boucles de calcul puisque celles-ci sont alors gérées en natif.

Exemples avec les entier et les décimaux:

[1,2,3]+[4,5,6] renvoie [5,7,9]

[1,2,3]-[1,1,1] renvoie [0,1,2]

[1,2,3]*[1,2,3] renvoie [1,4,9]

[1,1] / [2,2.0] renvoie [0,0.5]

[1,1] mod [2,2.0] renvoie [1,1]

[1,2] > [2,1] renvoie false (0)

Pour les exemples avec des tableaux de vecteurs et matrices, voir les classes vector et transform.

Contient un tableau associatif. Les identifiants peuvent être soit:

• des symboles: monTableau = [#age:24, #sexe:"masculin", #taille: 1.80]
• des chaines de caractère (attention, la lecture est très lente): monTableau = ["age":10,"sex":"m"]

L'algèbre est identique à celui des listes linéaires.

Encode un tableau à deux dimensions. Ajouté à la v11 pour les terrains du moteur physx.

Encode un vecteur 2d. Ses coordonnées se nomment "locH" et "locV". Elles peuvent être entières ou décimales.

p = point( a, b )

Les données se lisent par les propriétés locV / locH ou comme un tableau:

p.locH ou p[1] renvoie a

p.locV ou p[2] renvoie b

L'algèbre des vecteurs 2d se comporte exactement comme l'algèbre des tableaux et peut se combiner avec:

point(1,1)+point(2,2) renvoie point(3,3)

[p1,p2]+[p3,p4] renvoie [p1+p3,p2+p4]

Encode un rectangle. Les valeurs peuvent être entières ou décimales.

:r = rect(left, top, right, bottom) :r.left, r.top, r.right, r.bottom ou r[1], r[2], r[3], r[4] renvoient ses coordonnées :r.width et r.height renvoient sa largeur et sa hauteur

Quelques méthodes:

r1.intersects(r2) renvoie le rectangle d'intersection entre deux rectangles

point.inside(r1) renvoie true si le point est à l'intérieur du rectangle

map(targetRect, sourceRect, destinationRect) effectue une homothétie du point

map(targetPoint, sourceRect, destinationRect) effectue une homothétie du rectangle

rect1.union(rect2) renvoie le rectangle englobant deux autres rectangles

L'algèbre des rectangles est identique à celui des points 2d.

Encode un quadrilatère. Utile surtout pour les manipulations d'images.

Encode un vecteur 3d. Nombres décimaux uniquement.

v=vector(10,20,30)

Ses coordonnées sont accessibles de deux manières: soit avec les propriétés x, y, z, soit avec l'index de dimension:

v.x ou v[1] renvoie 10

Quelques méthodes:

vector.magnitude renvoie la longueur

vector.normalize() lui attribue une longueur égale à 1 sans changer sa direction

vector1.cross(vector2) renvoie le produit de deux vecteurs

L'algèbre des vecteurs 3d diffère de celle des listes et des vecteurs 2d:

• la division et le modulo ne sont pas permis
• la multiplication renvoie le produit scalaire

vector(1,0,0)*vector(0,1,0) renvoie 0.0

L'algèbre des vecteurs peut se combiner avec celui des tableaux.

[vector(1,0,0), vector(0,1,0)] + [vector(0,1,0), vector(1,0,0)] renvoie [vector(1,1,0), vector(1,1,0)]

[vector(1,0,0), vector(0,1,0)] * [vector(0,1,0), vector(1,0,0)] renvoie [0,0]

Encode une matrice de transformation 3d composée de 16 décimales.

matrice = transform()

Les 3 premiers groupes de 4 nombres encodent les 3 vecteurs du repère. Le dernier groupe encode l'origine. (le 4^e nombre de ces groupes sert aux calculs internes).

Exemple: choisir le vecteur (0,0,1) pour l'axe X:

matrice[1]=1

matrice[2]=0

matrice[3]=0

Quelques méthodes:

matrice.invert() inverse la matrice

matrice.inverse() renvoie l'inverse de la matrice

matrice.rotate() matrice.translate() effectue une transformation absolue

matrice.preRotate() matrice.preTranslate() effectue une transformation relative

matrice1.multiply(matrice2) renvoie la matrice 2 transformée par la matrice 2

matrice1.preMultiply(matrice2) renvoie la matrice 2 transformée par la matrice 1 en relatif

matrice1.interpolate(matrice2,pourcentage) renvoie l'interpolation entre deux transformations

Algèbre des matrices:

matrice1 * matrice2 équivaut à multiply

matrice * vecteur renvoie le vecteur transformé par la matrice

L'algèbre des matrices se combine également avec les tableaux:

[matrice1,matrice2] * [vecteur1,vecteur2] renvoie le tableau des vecteurs transformés

[matrice1,matrice2] * [matrice3,matrice4] renvoie le tableau des matrices transformés

Sous-classe de "member" qui s'affiche comme un sprite et permet de rendre une scène 3d avec directx ou opengl

Suit un pattern de type "fabrique" : tous les éléments de la scène 3d sont instanciés et détruits à l'aide de méthodes de la classe scene. En voici quelques-uns:

Stocke des vertexbuffers ("meshes") et référence des shaders par défaut.

Note: ses méthodes de construction ne suivent pas la structure des vertexbuffer, chaque triangle est renseigné indépendamment. Une fois appelée la méthode build() les vecteurs sont triés par groupe utilisant le même shader, les vertexBuffer obtenus sont accessibles via le modificateur #meshDeform des models utilisant la ressource.

Référence une matrice, une liste de shaders et un modelresource. Génère automatiquement une boundingSphere. La classe model permet d'afficher le modelResource. Son modificateur #meshDeform permet d'accéder aux vertexBuffer du modelResource.

Permet de contrôler une scène 3d avec le moteur physx de nvidia. Sous-classe d'xtra member, se contrôle comme un script xtra classique.

Suit le pattern fabrique qui permet de créer divers objets physiques: corps convexe, concave, cloth, personnage, etc. Requiert le modificateur #meshDeform pour lire les structures polygonales.

Ce sont les scripts utilisés pour le code procédural.

Ces scripts reçoivent quelques fonctions-événements prédéfinis qui correspondent à l'ouverture de l'application, sa fermeture, le rafraichissement d'image.

Événements d'ouverture et clôture:

• on prepareMovie s'exécute avant l'affichage de la première image. C'est là qu'on prépare le splash screen.
• on startMovie s'exécute après l'affichage de la première image. C'est là qu'on initialise l'application.
• on stopMovie s'exécute à la clôture de l'application, c'est là qu'on détruit son contenu.

Événements de rafraichissement d'image:

• on prepareFrame s'exécute avant le rendu de l'image, c'est ici qu'on met les relevés de temps.
• on enterFrame s'exécute pendant le laps de temps restant avant le rendu de la prochaine image, c'est là qu'on met tous les calculs.
• on exitFrame s'exécute juste avant le déplacement de la tête de lecture, c'est ici qu'on lui indique l'image qu'elle doit rendre (avec go to)

Événement indépendant:

• on idle s'exécute selon un intervalle multiple de 16 millisecondes (60 images par seconde). C'est là qu'on met le code indépendant du frameRate de l'application.

Événements souris:

• on mouseDown et on mouseUp, appelés quand la souris est pressée ou relâchée.

Ce sont des scripts qui se trouvent directement à l'intérieur d'un acteur. Leur type n'est pas défini mais ils fonctionnent comme les "movie script".

Ils reçoivent les évènements de souris et de rafraichissement lorsqu'une instance de l'acteur est visible.

Permettent de simuler des classes d'objet. La syntaxe des méthodes reste procédurale : il faut faire passer une référence à l'objet "me" en premier argument.

Voici un exemple de script parent instancié:

-- propriétés
property pNombre 
-- méthodes constructeur et destructeur
on new me, n , obj
  pObject = obj
  pNombre = n
  return me
end
on delete me
  pObject = void
end
-- méthodes utilisateur
on incremente me
  pNombre = pNombre +1
end

Si ce script se nomme "nombre", on l'instanciera par exemple de cette manière :

monNouveauNombre = new(script "nombre", 10, obj)

et on invoquera sa fonction "incremente" de cette manière :

monNouveauNombre.incremente()

Un script parent peut servir de classe statique.

On accède à sa référence comme ceci:

myStaticClass = Script("script_name")

L'héritage en Lingo ne fonctionne pas comme dans les langages objet classiques, il se base sur la propriété "ancestor" des scripts parents, qui correspond à une instance de la classe-mère. Il ne s'agit donc pas d'héritage mais d'une surcharge.

Director remonte automatiquement aux propriétés de l'objet ancestor depuis la référence fille ce qui permet de retrouver l'effet d'une classe héritée. Attention donc à la valeur de l'argument "me": il doit toujours correspondre à l'instance de dernière génération.

Cela ne marche pas pour toutes les propriétés et méthodes des classes natives de director (auquel cas il faut pointer l'ancestor).

Exemple de simulation d'une sous-classe de List

property ancestor
on new ( me ) -- sous classe de l'objet list
  ancestor = [1,10,20,30]
  return me -- attention: on ne renvoie pas "ancestor" mais "me"
end

obj=new Script( "testClass" )
put obj[ 1 ] -- on retrouve les propriétés de l'ancestor

Ce sont des objets complexes dont le script n'est pas directement accessible. Ils contiennent de nombreux événements permettant d'interagir avec les sprites, la souris, le clavier, par exemple pour créer des boutons ou des éditeurs de texte.

Les scripts de comportement sont souvent développés pour être réutilisés par des graphistes ou intégrateurs. Par un simple glisser-déposer ces scripts se rattachent à des objets de la scène : image, sprite, acteur, frame... Ces scripts ont des fonctions prédéfinies qui permettent de paramétrer manuellement les instances de même que les composants Flash.

Depuis sa version MX2004, le logiciel Director accepte l'usage de deux langages différents : le Lingo, et une implémentation de JavaScript/ECMAScript qui exécute une grosse partie des opérations Lingo.