Introduction *

1 Structure d’un programme VREL *

1.1 Forme générale d’un programme VREL *

1.2 Symboles d’un programme VREL *

2 INSTRUCTIONS SIMPLES *

2.1 Déclaration de constantes et de variables : *

2.2 Affectation simple : *

3 Expressions et opérateurs *

3.1 Les opérateurs *

3.2 Ordre de précédence des opérateurs *

4 Instructions de contrôle *

4.1 Séquence d’instructions *

4.2 Sélection par if *

4.3 Boucle while *

5 Classes et objets *

5.1 La création d’objets *

5.2 Les classes composées *

5.3 Les classes étendues *

6 Classes primitives de VREL *

6.1 Classe wall et classes dérivées *

6.2 Classes complexes *

7 Exemples *

Le langage de programmation VREL a été développé de janvier à mars 2000 par Pascal Belin, Yanneck Chevalier, Julien Dauphin et Alexis Jeannerod, élève à l’Ecole Nationale Supérieure des Télécommunications (ENST), dans le cadre d’un projet de dominante Informatique. Il s’inscrit dans un projet beaucoup plus large qu’est le développement de VREng, Virtual Reality Engine, un moteur de réalité virtuelle développé à l’ENST.

Dans VREng, les mondes en 3 dimensions et les objets sont décrit au moyen de fichiers de configuration qui ont un aspect suffisamment rebutant pour décourager tout individu à créer son propre monde. En effet, on y trouve les coordonnées spatiales de l’objet (X, Y, Z, alpha), puis la dimension de l'objet (x, y, z) et éventuellement des éclairages (r, v, b) et des textures (une par plan), tout cela sur une même ligne. D'autres informations telles de des adresses numériques (IP, port, ttl) ou des chaînes de caractères pour le nommage peuvent intervenir pour certains objets.

Le langage VREL a donc pour objectif de pouvoir de décrire et coder facilement les mondes de VREng. VREL est un langage de type langage objet, très largement inspiré de Java.

Les fichiers VREL se traduisent en fichier de configuration grâce au logiciel ‘vrel’, développé en parallèle de VREL et dont les sources sont totalement libres. Nous renvoyons le lecteur au ‘man’ de ce logiciel pour connaître son fonctionnement.

1. Structure d’un programme VREL

 

1. Forme générale d’un programme VREL

Tout programme VREL est composé :

• de directives d’importation ;
• de déclarations globales de variables ;
• de déclarations et de constructeurs de classes d’objets ;
• d’une fonction principale qui construit le monde ;

1. Directives d’importation :

Les directives d’importation permettent d’inclure des bibliothèques de classes d’objets, codées en VREL. Chaque directive d’inclusion commence par le mot import suivi du nom du fichier à inclure entre guillemets.

import "bibli1.vrel"

 

2. Déclarations globales :

Il n’y a pas de distinction de type de variable dans VREL. Une variable ou une constante peut être déclarée globalement pour tout le programme. Une variable globale est une variable dont la portée s’étend sur l’intégralité des fonctions contenues dans le fichier. Les variables globales sont à déclarer, au choix, avant ou après la fonction principale, et en dehors des séquences d’instructions (voir paragraphe 4.1).

 

3. Les définitions de classes :

• classe construite ;
• classe étendue.

• un en-tête composé du nom de la classe suivi d’une liste de paramètres, délimitée par des parenthèses ;
• le corps, délimité par des accolades { et } contenant le(s) constructeur(s) de la classe ; les constructeurs sont composés d’instructions terminées par un point-virgule.

1. La fonction principale :

• soit en les entourant des symboles /* et */ sur une ou plusieurs lignes,
  sans imbrications
• soit en débutant le commentaire par // ; dans ce cas, le commentaire est terminé à la fin de la ligne.

1. Identificateurs :

• les identificateurs de constantes sont écrits en majuscules ;
• les autres identificateurs sont écrits en minuscules ;
• les noms de classes sont écrit en minuscules mais commencent par une majuscule.

1. Mots-clés :

Les mots-clés du langage, réservés à des fins spéciales sont présentés ci-dessous :

abs	constructor	extends	mod	TRUE
begin	do	FALSE	new	var
class	Else	if	not	while
compound	end	import	this

On peut ajouter à ces identificateurs les noms des classes primitives d’objets du langage :

aoi	button	door	host	wall
backwalls	cauldron	earth	step	web
board	doc	gate	vrml

2. Littéraux :

• les constantes numériques (entières ou réelles) : il s’agit des nombres qui doivent être entrés sous forme décimale.

• les constantes chaînées : une constante chaînée de caractères est formée d’un nombre quelconque de caractères encadrés par des guillemets.

1. INSTRUCTIONS SIMPLES

 

1. Déclaration de constantes et de variables :

Il est très fréquent d’utiliser dans un programme une même valeur, comme Pi en mathématiques. Une telle donnée, dont la valeur ne change pas au cours du programme, s’appelle une constante. A l’inverse, une variable est une donnée dont le contenu peut varier au cours de l’exécution du programme.

En VREL, il n’y a pas de distinction entre ces deux types, et c’est donc au programmeur de gérer la constance de certaines valeurs.

Comme beaucoup de langages, VREL permet de donner un nom à une constante ou une variable. La déclaration d’une variable consiste à donner un nom de variable, précédé du mot-clé var :

var hauteur ;

Les variables peuvent être initialisées lors de leur déclaration :

var longueur = 6 ;

var wood = "images/wood.gif" ;

La déclaration d’une variable doit être faite avant toute utilisation de celle-ci. Puisqu’une déclaration est considérée comme une instruction, elle peut intervenir n’importe où dans le programme. Une déclaration introduit un nom dans une portée. Pour un nom local déclaré dans un constructeur de classe, la portée s’étend depuis le point de déclaration jusqu’à la fin du bloc. Pour une variable globale, la portée s’étend sur toutes les fonctions décrites dans le fichier.

 

2. Affectation simple :

L’instruction d’affectation permet de donner ou d’affecter le résultat d’une expression à une variable. Le symbole utilisé pour l’affectation simple est le signe = .

var hauteur ;

hauteur = 10 ;

 

 

2. Expressions et opérateurs

 

 

Une expression est l’association d’opérateurs et opérandes qui doivent être compatibles entre eux. Les opérandes peuvent être des variables, des constantes ou des objets. Les opérateurs dans VREL peuvent être classé en quatre classes :

 

1. Les opérateurs
1. L’opérateur d’affectation

Une affectation est la mémorisation du résultat d’une expression dans une variable. L’opérateur de l’affectation de VREL est le signe = est et se lit " égal à ". Cet opérateur ne permet que les affectations simples, c’est à dire ne comprenant qu’un signe =, comme par exemple :

hauteur = largeur / 3

mur = new wall (x, y, z, a, l, w, h)

Les affectations multiples ne sont pas acceptées. L’instruction suivante est incorrecte :

hauteur = largeur = 5 ;

 

2. Les opérateurs arithmétiques

Les opérateurs suivants servent à effectuer les opérations arithmétiques de base. Leurs opérandes sont des variables contenant des entiers ou des réels. Les opérateurs division / et modulo % font éventuellement des conversion de genre.

Opérateur	Opération	Remarque
+	Addition
-	Soustraction
*	Produit
/	Quotient	Division entière si les opérandes sont tous les deux des entiers
%	Modulo	Convertit préalablement les réels en leur partie entière

L’expression 5.2/2 renvoie le réel 2.60000

L’expression 5/2 renvoie l’entier 2

L’expression 5%2 renvoie le reste de la division euclidienne : 1

 

3. Les opérateurs relationnels

Ces opérateurs servent à comparer les valeurs de différentes expressions. Si la condition est vérifiée, l’opérateur renvoie un booléen 1 (vrai), sinon, un booléen 0 (faux).

Opérateur	Opération
==	Egalité
!=	Inégalité
<	Plus petit
>	Plus grand
<=	Plus petit ou égal
>=	Plus grand ou égal

L’expression 7 == 4 renvoie le booléen 0

L’expression 7 > 4 renvoie le booléen 1

 

4. Les opérateurs logiques

Ce type d’opérateur accepte des booléens comme opérandes et renvoie un booléen qui est le résultat du test logique.

Opérateur	Opération
!	Négation logique
&&	ET logique
||	OU logique

L’expression !(7 == 4) renvoie le booléen 1

L’expression (7 > 4) && 0 renvoie le booléen 0

L’expression 1 || 0 renvoie le booléen 1

 

2. Ordre de précédence des opérateurs

Quand une expression comporte plusieurs opérateurs, son évaluation se fait en respectant un certain ordre de priorité sur ses opérateurs. La priorité est toujours accordée aux parenthèses. La lecture des opérateurs est effectué suivant l’associativité et les ordres de priorité suivants :

Priorité	Opérateurs	Associativité
1	()	gauche à droite
2	!	droite à gauche
3	* / %	gauche à droite
4	+ -	gauche à droite
5	< <= > >= == !=	gauche à droite
6	&& ||	gauche à droite

 

 

3. Instructions de contrôle

 

 

Le langage VREL dispose d’un jeu réduit d’instructions de contrôle qui est néanmoins suffisant pour la création efficace de mondes virtuels.

1. Séquence d’instructions

Une séquence d’instructions est une suite d’instructions entourées par des accolades { }. On aligne généralement ces instructions les unes sous les autres par convention et par commodité de lecture.

{

largeur = 40 ;

hauteur = 13 ;

new murblanc(largeur, hauteur) ;

}

 

2. Sélection par if

La sélection (ou instruction conditionnelle) if permet de choisir l’exécution ou non d’une séquence d’instructions en fonction d’une condition. Cette condition est une expression renvoyant une valeur booléenne. La plupart du temps, elle est composée d’une ou plusieurs relations de comparaison articulées par des opérateurs logiques. La condition est remplie si la valeur booléenne renvoyée est TRUE.

If peut être suivi ou non d’une alternative qui sera exécutée si la condition du if n’est pas satisfaite. Cette alternative constitue une séquence d’instructions introduite par le mot réservé else.

Utilisation de if sans alternative :

if (i == 10){

mur = new murtexture(x, y, z, a, l, w, h) ;

mur.tex_xp = wood ;

}

Utilisation de if suivi de else :

if ( (i <= 4) && (i != 0)){

hauteur = largeur / i ;

}

else{

hauteur = largeur / 3 ;

}

A noter que les accolades sont obligatoires même si if ou else n’est suivi que d’une instruction.

 

3. Boucle while

Cette instruction est une instruction d’itération qui permet d’exécuter l’exécution d’une séquence d’instructions tant que la condition prescrite est respectée. La syntaxe de l’instruction while est semblable à celle de l’instruction if non suivie de else. Il est indispensable qu’une itération au sein de la séquence d’instructions assure la sortie de la boucle lors de l’exécution du programme.

while (i < 15)

{

Fonction(lieu_x + i*5, lieu_y) ;

i = i + 1 ;

}

La boucle for n’a pas été incorporée au langage VREL car elle est aisément remplaçable par une boucle while correctement programmée.

 

 

4. Classes et objets

  

Le langage VREL est partiellement orienté objet. Partiellement seulement car ce langage n’a qu’une vocation descriptive, et il n’était pas nécessaire d’y introduire la notion de méthodes et d’héritage de méthodes que les lecteurs familiers des langages objet connaissent. La seule méthode proposée dans VREL est la méthode d’auto construction des objets.

La notion d’héritage est néanmoins présente pour les attributs et les types d’objets. Tous les objets crées en VREL héritent de méta classes qui sont les primitives de VREng, dont vous trouverez une description dans la section suivante.

Dans cette partie nous décrirons comment instancier un objet, puis comment créer de nouvelles classes à partir d’autres classes. VREL utilise pour cela 2 concepts : les classes composées et le classes étendues.

 

1. La création d’objets

La création d’un objet à partir d’une classe est faite en appliquant l’opérateur new sur un constructeur de classe. Ce constructeur doit comporter le bon nombre de paramètres, tout en sachant qu’une classe peut admettre plusieurs constructeurs. Chaque constructeur d’une même classe ne diffère que par son nombre d’arguments.

new wall (5, 7, 1, 0, 5, 6, 1) ;

(voir la section 6 pour connaître les paramètres du constructeur de la classe wall)

Un objet ainsi créé peut affecter une variable (cette variable d’un type particulier n’a pas besoin d’être déclarée au préalable).

W1 = new wall (5, 7, 1, 0, 5, 6, 1) ;

Ceci permet ensuite de pouvoir modifier les attributs de l’objet ainsi créé :

W1.tex_xp = wood ;

Attention à bien faire la distinction entre les arguments du constructeur et les attributs d’une classe qui ne sont généralement pas les mêmes. Les attributs sont des champs facultatifs qui sont modifiables par notation pointée ; les arguments sont les paramètres obligatoires du constructeur.

 

2. Les classes composées

Le langage VREL offre la possibilité de construire de nouvelles classes d’objets à partir de classes déjà existantes (primitives ou d’autres classes composées ou étendues crées par le programmeur).

En VREL, la définition de nouvelle classes composées est introduite par le mot class. Celui-ci doit être suivi du nom de la classe créée, et du mot compound. La définition de la classe est ensuite mise, entre accolades.

class tabouret compound

{

// définition de la classe

}

Dans la définition de la classe, on distingue deux sections qui sont, dans l’ordre :

la liste des attributs ;

la liste des constructeurs ;

La liste des attributs se présente comme une liste de déclarations de variables. On peut affecter une valeur par défaut à un ou plusieurs attributs :

class tabouret compound

{

// attribut de la classe :

var texture = wood ;

// constructeurs de la classe :

}

Une classe peut ensuite admettre plusieurs constructeurs, ceux-ci devant avoir un nombre différent de d’arguments. Chaque constructeur est précédé du mot constructor, suivi de la liste des arguments entre parenthèses, puis d’une liste d’instructions entre accolades. Ces instructions constituent la méthodes de construction de la classe.

class tabouret compound

{

// attribut de la classe :

var texture = wood ;

// constructeur de la classe :

constructor (posX, posY, posZ)

{

w1 = new wall(posX, posY, posZ, 0, 2.5, 2.5, 0.2) ;

w1.tex_zp = texture ;

w2 = new wall(posX+2.2, posY+2.2, posZ-2.5, 0, 0.1, 0.1, 2.5);

w3 = new wall(posX–2.2, posY+2.2, posZ–2.5, 0, 0.1, 0.1, 2.5);

w4 = new wall(posX+2.2, posY-2.2, posZ-2.5, 0, 0.1, 0.1, 2.5);

w5 = new wall(posX-2.2, posY-2.2, posZ-2.5, 0, 0.1, 0.1, 2.5);

}

}

 

3. Les classes étendues

Il existe une syntaxe plus simple lorsqu’il s’agit de faire une simple extension d’une classe. On peut vouloir par exemple faire une classe " mur_bleu " qui ne serait qu’une extension de wall avec les attributs de texture précisés à bleu.

Pour réaliser ce type d’extension, on remplace le compound de la méthode précédente par extends suivi de la classe dont la classe étendue hérite. La définition de la classe ne comporte plus que des affectations.

Class mur_bleu extends wall

{

tex_xp = bleu ;

tex_xn = bleu ;

tex_yp = bleu ;

// etc…

}

Attention : un attribut fixer dans un extends n’est plus modifiable.

W = new mur_bleu (1, 1, 0, 0, 4, 4, 6) ;

W.tex_xp = wood ; // cette affectation n’a aucun effet.

 

 

5. Classes primitives de VREL

  

Ces classes sont la base de la programmation VREL car toutes les classes d’objets que l’utilisateur créera les réutiliseront. Nous allons en faire une description succincte, le lecteur pourra se référer à la documentation de Holger Krauth Comment écrire des fichiers de configuration pour une explication détaillé des primitives de VREng.

L’utilisation avancée de ces classes peut paraître difficile, mais le but de VREL est de proposer des bibliothèques de classes pré configurées, ce qui allège le travail des concepteurs de monde.

Avertissement : Pour éviter les redondances, nous avons défini des champs de paramètres dont les noms sont soulignés, et dont le contenu n’est expliqué qu’une seule fois. La description de la classe wall éclairera le lecteur sur les champs de paramètres les plus fréquemment rencontrés, comme Position, Orientation et Dimension.

 

1. Classe wall et classes dérivées

La classe wall est la base d’une famille de classes qu’on pourrait appeler box (boite). Les autres classes décrites dans cette partie ne font qu’ajouter à wall des actions associées. Il est conseillé au débutant de bien se familiariser avec la classe wall.

1. Classe wall

• Position : coordonnées cartésiennes x, y, z.
• Orientation : angle a d’une rotation d’axe vertical de l’objet. Les angles sont mesurés en radiants depuis l’axe des abscisses positives.
• Dimension : longueurs dx, dy, dz correspondant à largeur, profondeur et hauteur.

• Textures : on indique une URL pour chaque face qu’on désire texturer. Les variables à affecter après instanciation de l’objet sont les suivantes, avant que la rotation d’angle a ne soit effectuée :

• Jeux de lumière : les paramètre modifiables sur l’aspect des objets sont l’éclairage diffus, la lumière d’ambiance, la brillance, et la réflexion. On peut pas tous les utiliser en même temps : il faut choisir entre éclairage diffus et lumière d’ambiance, et entre brillance, et réflexion.
• Les paramètres des jeux lumières sont les suivants :

1. Classe step

La classe step est similaire à la classe wall. Contrairement à cette dernière qui ne permet pas l’escalade, elle fait automatiquement monter l’avatar sur la face supérieure du parallélépipède (sans utiliser la touche insert qui permet de voler). Elle est particulièrement utile pour construire des escaliers.

Pour la construction, se référer à la classe wall.

Un appel de step se fait par :

new step(x, y, z, a, dx, dy, dz)  ;

2. Classe board

La classe board est également similaire à la classe wall, mais elle possède une action associée : l’ouverture d’une application de dessin

Pour la construction, se référer derechef à la classe wall.

Un appel de board se fait par :

new board(x, y, z, a, dx, dy, dz)  ;

3. Classe web

• Adresse URL : adresse url d’une page html que la classe web ouvre par action associée dans le navigateur.

1. Classe vrml

La classe vrml ressemble comme deux gouttes d’eau à la classe web, mais l’action associée est l’ouverture d’un fichier vrml (extension .wrl) et non d’une page html. On utilise exactement la même syntaxe que pour web.

Un appel de vrml se fait par :

new vrml(x, y, z, a, url, dx, dy, dz)  ;

2. Classe doc

La classe doc fonctionne comme la classe web, mais l’action associée est l’ouverture d’un fichier Postscript (extension .ps) et non d’une page html. On utilise exactement la même syntaxe que pour web.

Un appel de doc se fait par :

new doc(x, y, z, a, url, dx, dy, dz)  ;

3. Classe host

• Nom d’hôte : adresse hostname d’un ordinateur susceptible d’offrir une connexion par telnet.

0. Classes complexes

1. Classe button

• Etat de départ : état startstate (0 ou 1) dans lequel se trouve le bouton au chargement du monde.
• Objet cible : paramètre targetname qui donne le nom de l’objet cible. Attention : l’objet cible doit être un objet possédant un numéro de scène et un numéro d’objet.
• SID/OID : l’acronyme sid/oid (Scene Identity/ Object Identity) désigne le numéro de scène et le numéro d’objet d’un objet modifiable. Le numéro de scène est fixé à 1, car VREng ne gère pas encore les interactions entre mondes.
• Méthodes : les méthodes method1 et method2 sont les méthodes d’action qu’on applique à l’objet cible.

1. Classe door

• Nom de porte : nom est un paramètre indispensable car il sert d’identifiant pour les boutons qui pourraient agir sur cette porte.
• Angles de parcours : Les angles spécifiées en radiants par angleopen et angleclosed sont les angles que fait la porte avec l’axe des abscisses positives quand elle est respectivement ouverte ou fermée. Attention : l’un de ces deux paramètres doit être égal à l’angle a définissant Orientation
• Vitesse : speed ne définit pas seulement la vitesse à laquelle la porte s’ouvre ou se ferme. Le signe de ce paramètre indique également dans quel sens la porte s’ouvre, les valeurs positives étant celles du repère orthonormal direct utilisé par VREng.
• Taille de gonds : xoffset précise simplement l’écart entre le bord intérieur de la porte et son axe de rotation. Ceci permet en particulier de simuler la présence de gonds et de rendre le mouvement plus réaliste.

1. Classe gate

• Adresse URL : adresse url d’un fichier de configuration VREng (extension .cfg) qui décrit le monde auquel on accède.
• Adresse IP multicast : adresse ipm du monde d’arrivée. Elle a une structure bien définie : groupe/port/ttl

1. Classe aoi

• Nom de l’aoi : aoiname est la chaîne de caractères donnant le nom de l’aoi.

1. Classe earth

• Rayon : rayon r de la sphère.

• Texture de sphère : chaîne de caractères tex donnant l’adresse de la texture à appliquer à la sphère.

1. Classe cauldron

• Rayons de tore : R est le grand rayon du tore, et r le petit rayon.

1. Classe backwalls

7. Exemples

Le lecteur trouvera dans cette partie différents exemples de fichiers Vrel afin de mieux comprendre le langage décrit dans les parties précédentes. Les exemples proposent de construire des objets de type mobiliers.

var N = 5 ;