			     Le Langage VREL



		    Virtual Reality Engine Language






			   TABLE DES MATIERES


INTRODUCTION


1	STRUCTURE D'UN PROGRAMME VREL	

1.1	Forme generale d'un programme VREL	
a)	Directives d'importation :	
b)	Declarations globales :	
c)	Les definitions de classes :	
d)	La fonction principale :	

1.2	Symboles d'un programme VREL	
a)	Commentaires :	
b)	Identificateurs :	
c)	Mots-cles :	
d)	Litteraux :	


2	INSTRUCTIONS SIMPLES	

2.1	Declaration de constantes et de variables :	

2.2	Affectation simple :	


3	EXPRESSIONS ET OPERATEURS	

3.1	Les operateurs	
a)	L'operateur d'affectation	
b)	Les operateurs arithmetiques	
c)	Les operateurs relationnels	
d)	Les operateurs logiques	

3.2	Ordre de precedence des operateurs


4	INSTRUCTIONS DE CONTROLE	

4.1	Sequence d'instructions	

4.2	Selection par if

4.3	Boucle while	


5	CLASSES ET OBJETS

5.1	La creation d'objets	

5.2	Les classes composees	

5.3	Les classes etendues

	

6	CLASSES PRIMITIVES DE VREL	

6.1	Classe wall et classes derivees	
a)	Classe wall	
b)	Classe step	
c)	Classe board	
d)	Classe web	
e)	Classe vrml	
f)	Classe doc	
g)	Classe host	

6.2	Classes complexes	
a)	Classe button
b)	Classe door	
c)	Classe gate	
d)	Classe aoi	
e)	Classe earth	
f)	Classe cauldron	
g)	Classe backwalls


7	EXEMPLES	




				INTRODUCTION




Le langage de programmation VREL a ete developpe de janvier a mars 2000 par 
Pascal Belin, Yanneck Chevalier, Julien Dauphin et Alexis Jeannerod, eleve a 
l'Ecole Nationale Superieure des Telecommunications (ENST), dans le cadre d'un 
projet de dominante Informatique. Il s'inscrit dans un projet beaucoup plus 
large qu'est le developpement de VREng, Virtual Reality Engine, un moteur de 
realite virtuelle developpe a l'ENST.

Dans VREng, les mondes en 3 dimensions et les objets sont decrit au moyen de 
fichiers de configuration qui ont un aspect suffisamment rebutant pour 
decourager tout individu a creer son propre monde. En effet, on y trouve les 
coordonnees spatiales de l'objet (X, Y, Z, alpha), puis la dimension de l'objet 
(x, y, z) et eventuellement des eclairages (r, v, b) et des textures (une par 
plan), tout cela sur une meme ligne. D'autres informations telles de des 
adresses numeriques (IP, port, ttl) ou des chaines de caracteres pour le nommage 
peuvent intervenir pour certains objets. 

Le langage VREL a donc pour objectif de pouvoir de decrire et coder facilement 
les mondes de VREng. VREL est un langage de type langage objet, tres largement 
inspire de Java.

Les fichiers VREL se traduisent en fichier de configuration grce au logiciel 
'vrel', developpe en parallele de VREL et dont les sources sont totalement 
libres. Nous renvoyons le lecteur au 'man' de ce logiciel pour connaitre son 
fonctionnement.



1 STRUCTURE D'UN PROGRAMME VREL

1.1 Forme generale d'un programme VREL

Tout programme VREL est compose :
- de directives d'importation ; 
- de declarations globales de variables ;
- de declarations et de constructeurs de classes d'objets ;
- d'une fonction principale qui construit le monde ;

a) Directives d'importation :
Les directives d'importation permettent d'inclure des bibliotheques de classes 
d'objets, codees en VREL. Chaque directive d'inclusion commence par le mot 
import suivi du nom du fichier a inclure entre guillemets.

import "bibli1.vrel"

b) Declarations globales :
Il n'y a pas de distinction de type de variable dans VREL. Une variable ou une 
constante peut etre declaree globalement pour tout le programme. Une variable 
globale est une variable dont la portee s'etend sur l'integralite des fonctions 
contenues dans le fichier. Les variables globales sont a declarer, au choix, 
avant ou apres la fonction principale, et en dehors des sequences d'instructions 
(voir paragraphe 4.1).

c) Les definitions de classes :
Une classe sert a decrire un objet type du monde 3D. Elle peut etre de 2 types :
- classe construite ;
- classe etendue.

Dans les deux cas, la definition contient :
- un en-tete compose du nom de la classe suivi d'une liste de parametres, 
delimitee par des parentheses ;
- le corps, delimite par des accolades { et } contenant le(s) constructeur(s) de 
la classe ; les constructeurs sont composes d'instructions terminees par un 
point-virgule.

d) La fonction principale :
C'est dans cette fonction que sera decrit le monde. Elle doit etre precedee du 
mot begin et d'une accolade ouvrante {, et finie par une accolade fermante } et 
le mot end. Elle est composee d'instructions terminees par un point-virgule.


1.2 Symboles d'un programme VREL
a) Commentaires :
L'importance des commentaires dans un programme n'est plus a demontrer. Ceux-ci 
peuvent etre introduits dans un programme VREL de deux facons : 
- soit en les entourant des symboles /* et */ sur une ou plusieurs lignes,
sans imbrications
- soit en debutant le commentaire par // ; dans ce cas, le commentaire est 
termine a la fin de la ligne.

b) Identificateurs :
Un identificateur est le nom que le programme donne a une variable, une 
constante ou une classe. Il est forme d'un nombre quelconque de lettres 
majuscules ou minuscules non accentuees, de chiffres, ainsi que du caractere 
souligne considere comme une lettre. Le premier caractere doit etre une lettre. 
Les majuscules et les minuscules sont considerees comme des caracteres 
differents.

Par convention :
- les identificateurs de constantes sont ecrits en majuscules ;
- les autres identificateurs sont ecrits en minuscules ;
- les noms de classes sont ecrit en minuscules mais commencent par une 
majuscule.

c) Mots-cles :
Les mots-cles du langage, reserves a des fins speciales sont presentes ci-
dessous :

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


On peut ajouter a ces identificateurs les noms des classes primitives d'objets 
du langage :

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


d) Litteraux :
Les litteraux sont des constantes associees aux differents types de base du 
langage. On distingue deux sortes de litteraux :
- les constantes numeriques (entieres ou reelles) : il s'agit des nombres qui 
doivent etre entres sous forme decimale. 
	6,52 est une constante numerique.
- les constantes chainees : une constante chainee de caracteres est formee d'un 
nombre quelconque de caracteres encadres par des guillemets.
	"images/wood.gif" est une constante chainee.




2 INSTRUCTIONS SIMPLES


2.1 Declaration de constantes et de variables :

Il est tres frequent d'utiliser dans un programme une meme valeur, comme Pi en 
mathematiques. Une telle donnee, dont la valeur ne change pas au cours du 
programme, s'appelle une constante. A l'inverse, une variable est une donnee 
dont le contenu peut varier au cours de l'execution du programme.

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

Comme beaucoup de langages, VREL permet de donner un nom a une constante ou une 
variable. La declaration d'une variable consiste a donner un nom de variable, 
precede du mot-cle var :

var hauteur ;

Les variables peuvent etre initialisees lors de leur declaration :

var longueur = 6 ;
var wood = "images/wood.gif" ;

La declaration d'une variable doit etre faite avant toute utilisation de celle-
ci. Puisqu'une declaration est consideree comme une instruction, elle peut 
intervenir n'importe ou dans le programme. Une declaration introduit un nom dans 
une portee. Pour un nom local declare dans un constructeur de classe, la portee 
s'etend depuis le point de declaration jusqu'a la fin du bloc. Pour une variable 
globale, la portee s'etend sur toutes les fonctions decrites dans le fichier.


2.2 Affectation simple :

L'instruction d'affectation permet de donner ou d'affecter le resultat d'une 
expression a une variable. Le symbole utilise pour l'affectation simple est le 
signe = .

var hauteur ;
hauteur = 10 ;




3 EXPRESSIONS ET OPERATEURS


Une expression est l'association d'operateurs et operandes qui doivent etre 
compatibles entre eux. Les operandes peuvent etre des variables, des constantes 
ou des objets. Les operateurs dans VREL peuvent etre classe en quatre classes :


3.1 Les operateurs

a) L'operateur d'affectation
Une affectation est la memorisation du resultat d'une expression dans une 
variable. L'operateur de l'affectation de VREL est le signe = est et se lit " 
egal a ". Cet operateur ne permet que les affectations simples, c'est a dire ne 
comprenant qu'un signe =, comme par exemple :

hauteur = largeur / 3
mur = new wall (x, y, z, ?, l, w, h)

Les affectations multiples ne sont pas acceptees. L'instruction suivante est 
incorrecte :

hauteur = largeur = 5 ;

b) Les operateurs arithmetiques
Les operateurs suivants servent a effectuer les operations arithmetiques de 
base. Leurs operandes sont  des variables contenant des entiers ou des reels. 
Les operateurs division / et modulo % font eventuellement des conversion de 
genre. 

+ Addition

- Soustraction

* Produit

/ Quotient
Division entiere si les operandes sont tous les deux des entiers

% Modulo
Convertit prealablement les reels en leur partie entiere

L'expression 	5.2/2   renvoie le reel 2.60000
L'expression 	5/2 	renvoie l'entier 2
L'expression 	5%2	renvoie le reste de la division euclidienne : 1


c) Les operateurs relationnels
Ces operateurs servent a comparer les valeurs de differentes expressions. Si la 
condition est verifiee, l'operateur renvoie un booleen 1 (vrai), sinon, un 
booleen 0 (faux).

== Egalite
!= Inegalite
< Plus petit
> Plus grand
<= Plus petit ou egal
>= Plus grand ou egal

L'expression 	7 == 4	renvoie le booleen 0
L'expression 	7 > 4 	renvoie le booleen 1

d) Les operateurs logiques

Ce type d'operateur accepte des booleens comme operandes et renvoie un booleen 
qui est le resultat du test logique.

!  Negation logique
&& ET logique
|| OU logique

L'expression	!(7 == 4)  renvoie le booleen 1 
L'expression	(7 > 4) && 0  renvoie le booleen 0 
L'expression	1 || 0	renvoie le booleen 1


3.2 Ordre de precedence des operateurs

Quand une expression comporte plusieurs operateurs, son evaluation se fait en 
respectant un certain ordre de priorite sur ses operateurs. La priorite est 
toujours accordee aux parentheses. La lecture des operateurs est effectue 
suivant l'associativite et les ordres de priorite suivants :

Priorite	Operateurs		Associativite
1		()			gauche a droite
2		!			droite a gauche
3		*  /  %			gauche a droite
4		+ -			gauche a droite
5		<  <=  >  >=  ==  !=	gauche a droite
6		&&  ||			gauche a droite




4 INSTRUCTIONS DE CONTROLE

Le langage VREL dispose d'un jeu reduit d'instructions de contrle qui est 
neanmoins suffisant pour la creation efficace de mondes virtuels.


4.1 Sequence d'instructions

Une sequence d'instructions est une suite d'instructions entourees par des 
accolades { }. On aligne generalement ces instructions les unes sous les autres 
par convention et par commodite de lecture.

{
	largeur = 40 ;
	hauteur = 13 ;
	new murblanc(largeur, hauteur) ;
}


4.2 Selection par if

La selection (ou instruction conditionnelle) if permet de choisir l'execution ou 
non d'une sequence d'instructions en fonction d'une condition. Cette condition 
est une expression renvoyant une valeur booleenne. La plupart du temps, elle est 
composee d'une ou plusieurs relations de comparaison articulees par des 
operateurs logiques. La condition est remplie si la valeur booleenne renvoyee 
est TRUE.
If peut etre suivi ou non d'une alternative qui sera executee si la condition du 
if n'est pas satisfaite. Cette alternative constitue une sequence d'instructions 
introduite par le mot reserve else.

Utilisation de if sans alternative :
if (i == 10){
	mur = new murtexture(x, y, z, ?, 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 meme si if ou else n'est suivi que 
d'une instruction.


4.3 Boucle while

Cette instruction est une instruction d'iteration qui permet d'executer 
l'execution d'une sequence d'instructions tant que la condition prescrite est 
respectee. La syntaxe de l'instruction while est semblable a celle de 
l'instruction if non suivie de else. Il est indispensable qu'une iteration au 
sein de la sequence d'instructions assure la sortie de la boucle lors de 
l'execution du programme.

while (i < 15)
{
	Fonction(lieu_x + i*5, lieu_y) ;
	i = i + 1 ;
}

La boucle for n'a pas ete incorporee au langage VREL car elle est aisement 
remplacable par une boucle while correctement programmee.



5 CLASSES ET OBJETS

Le langage VREL est partiellement oriente objet. Partiellement seulement car ce 
langage n'a qu'une vocation descriptive, et il n'etait pas necessaire d'y 
introduire la notion de methodes et d'heritage de methodes que les lecteurs 
familiers des langages objet connaissent. La seule methode proposee dans VREL 
est la methode d'auto construction des objets.
La notion d'heritage est neanmoins presente pour les attributs et les types 
d'objets. Tous les objets crees en VREL heritent de meta classes qui sont les 
primitives de VREng, dont vous trouverez une description dans la section 
suivante.

Dans cette partie nous decrirons comment instancier un objet, puis comment creer 
de nouvelles classes a partir d'autres classes. VREL utilise pour cela 2 
concepts : les classes composees et le classes etendues.


5.1 La creation d'objets

La creation d'un objet a partir d'une classe est faite en appliquant l'operateur 
new sur un constructeur de classe. Ce constructeur doit comporter le bon nombre 
de parametres, tout en sachant qu'une classe peut admettre plusieurs 
constructeurs. Chaque constructeur d'une meme classe ne differe que par son 
nombre d'arguments.

new wall (5, 7, 1, 0, 5, 6, 1) ;
(voir la section 6 pour connaitre les parametres du constructeur de la classe 
wall)

Un objet ainsi cree peut affecter une variable (cette variable d'un type 
particulier n'a pas besoin d'etre declaree au prealable).

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

Ceci permet ensuite de pouvoir modifier les attributs de l'objet ainsi cree :

W1.tex_xp = wood ;

Attention a bien faire la distinction entre les arguments du constructeur et les 
attributs d'une classe qui ne sont generalement pas les memes. Les attributs 
sont des champs facultatifs qui sont modifiables par notation pointee ; les 
arguments sont les parametres obligatoires du constructeur.


5.2 Les classes composees

Le langage VREL offre la possibilite de construire de nouvelles classes d'objets 
a partir de classes deja existantes (primitives ou d'autres classes composees ou 
etendues crees par le programmeur). 

En VREL, la definition de nouvelle classes composees est introduite par le mot 
class. Celui-ci doit etre suivi du nom de la classe creee, et du mot compound. 
La definition de la classe est ensuite mise, entre accolades.

class tabouret compound 
{ 
// definition de la classe
 }

Dans la definition 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 presente comme une liste de declarations de variables. 
On peut affecter une valeur par defaut a 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 different de d'arguments. Chaque constructeur est precede du mot 
constructor, suivi de la liste des arguments entre parentheses, puis d'une liste 
d'instructions entre accolades. Ces instructions constituent la methodes 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);
}
}


5.3 Les classes etendues

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 precises a bleu. 

Pour realiser ce type d'extension, on remplace le compound de la methode 
precedente par extends suivi de la classe dont la classe etendue herite. La 
definition 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.



6 CLASSES PRIMITIVES DE VREL


Ces classes sont la base de la programmation VREL car toutes les classes 
d'objets que l'utilisateur creera les reutiliseront. Nous allons en faire une 
description succincte, le lecteur pourra se referer a la documentation de Holger 
Krauth Comment ecrire des fichiers de configuration pour une explication 
detaille des primitives de VREng.

L'utilisation avancee de ces classes peut paraitre difficile, mais le but de 
VREL est de proposer des bibliotheques de classes pre configurees, ce qui allege 
le travail des concepteurs de monde.

Avertissement : Pour eviter les redondances, nous avons defini des champs de 
parametres dont les noms sont soulignes, et dont le contenu n'est explique 
qu'une seule fois. La description de la classe wall eclairera le lecteur sur les 
champs de parametres les plus frequemment rencontres, comme Position, 
Orientation et Dimension.


6.1 Classe wall et classes derivees

La classe wall est la base d'une famille de classes qu'on pourrait appeler box 
(boite). Les autres classes decrites dans cette partie ne font qu'ajouter a wall 
des actions associees. Il est conseille au debutant de bien se familiariser avec 
la classe wall.
a) Classe wall
La classe wall est la classe de base de VREL : il s'agit en fait d'un 
parallelepipede rectangle dont il faut preciser obligatoirement les attributs 
suivants : position, orientation et dimensions. Ces trois informations forment 
les parametres d'appel de la classe wall.

- Position : coordonnees cartesiennes x, y, z.
- Orientation : angle ? d'une rotation d'axe vertical de l'objet. Les angles 
sont mesures en radiants depuis l'axe des abscisses positives.
- Dimension : longueurs dx, dy, dz correspondant a largeur, profondeur et 
hauteur.

Un appel de wall se fait necessairement par :
new wall(x, y, z, ?, dx, dy, dz)  ;


La classe wall possede egalement des attributs optionnels : textures, jeux de 
lumiere.

- Textures : on indique une URL pour chaque face qu'on desire texturer. Les 
variables a affecter apres instanciation de l'objet sont les suivantes, avant 
que la rotation d'angle ? ne soit effectuee :
pour les faces perpendiculaires a l'axe des x : tex_xp, tex_xn, ou p et n 
indique qu'il s'agit de la face orientee vers les abscisses positifs ou 
negatifs.
De meme, pour les autres faces, on a tex_yp, tex_yn, tex_zp, tex_zn.

- Jeux de lumiere : les parametre modifiables sur l'aspect des objets sont 
l'eclairage diffus, la lumiere d'ambiance, la brillance, et la reflexion. On 
peut pas tous les utiliser en meme temps : il faut choisir entre eclairage 
diffus et lumiere d'ambiance, et entre brillance, et reflexion.

Les parametres des jeux lumieres sont les suivants :
diffRed, diffGreen, diffBlue, pour l'eclairage diffus.
ambRed, ambGreen, ambBlue, pour la lumiere d'ambiance.
shinPar1, shinPar2, shinPar3, pour la brillance.
specPar1, specPar2, specPar3, pour la reflexion.
Les valeurs des composantes ...Red ...Green ...Blue de la lumiere dans eclairage 
diffus et lumiere d'ambiance sont des valeurs comprises entre 0 et 1


Pour creer un mur texture sur sa face superieure, il faut d'abord instancier un 
wall puis affecter l'attribut correspondant a la face superieure :
mur = new wall(x, y, z, ?, dx, dy, dz)  ;
mur.tex_zp = "http://www.enst.fr/images/wood.gif" ;

b) Classe step
La classe step est similaire a la classe wall. Contrairement a cette derniere 
qui ne permet pas l'escalade, elle fait automatiquement monter l'avatar sur la 
face superieure du parallelepipede (sans utiliser la touche insert qui permet de 
voler). Elle est particulierement utile pour construire des escaliers.
Pour la construction, se referer a la classe wall.

Un appel de step se fait par :
new step(x, y, z, ?, dx, dy, dz)  ;

c) Classe board
La classe board est egalement similaire a la classe wall, mais elle possede une 
action associee : l'ouverture d'une application de dessin
Pour la construction, se referer derechef a la classe wall.

Un appel de board se fait par :
new board(x, y, z, ?, dx, dy, dz)  ;

d) Classe web
La classe web fonctionne exactement comme la classe wall, sauf pour l'appel de 
la classe qui contient un argument supplementaire : 

- Adresse URL : adresse url d'une page html que la classe web ouvre par action 
associee dans le navigateur.

Un appel de web se fait par :
new web(x, y, z, ?, url, dx, dy, dz)  ;
e) Classe vrml
La classe vrml ressemble comme deux gouttes d'eau a la classe web, mais l'action 
associee est l'ouverture d'un fichier vrml (extension .wrl) et non d'une page 
html. On utilise exactement la meme syntaxe que pour web.

Un appel de vrml se fait par :
new vrml(x, y, z, ?, url, dx, dy, dz)  ;

f) Classe doc
La classe doc fonctionne comme la classe web, mais l'action associee est 
l'ouverture d'un fichier Postscript (extension .ps) et non d'une page html. On 
utilise exactement la meme syntaxe que pour web.

Un appel de doc se fait par :
new doc(x, y, z, ?, url, dx, dy, dz)  ;
g) Classe host
La classe host se base sur la classe wall, mais elle a un argument 
supplementaire. L'action associee est l'ouverture d'une wall connexion telnet 
avec un hte specifie : 

- Nom d'hte : adresse hostname d'un ordinateur susceptible d'offrir une 
connexion par telnet.

Un appel de host se fait par :
new host(x, y, z, ?, hostname, dx, dy, dz)  ;


6.2 Classes complexes

Ces classes reprennent pour la plupart des champs de parametres rencontres dans 
la partie precedente. Elles introduisent neanmoins des nouveautes notables.
a) Classe button
La classe button est comme un wall, mais associee a une action de commutation 
entre deux etats, comme par exemple pour ouvrir une porte. Il faut donc preciser 
un objet cible sur lequel l'action sera effectuee. Pour l'instant, les objets 
dont l'avatar peut modifier l'etat sont les portes et les boutons. 

Cette classe fait intervenir plusieurs champs de parametres nouveaux :

- Etat de depart : etat startstate (0 ou 1) dans lequel se trouve le bouton au 
chargement du monde.
- Objet cible : parametre targetname qui donne le nom de l'objet cible. 
Attention : l'objet cible doit etre un objet possedant un numero de scene et un 
numero d'objet.
- SID/OID : l'acronyme sid/oid (Scene Identity/ Object Identity) designe le 
numero de scene et le numero d'objet d'un objet modifiable. Le numero de scene 
est fixe a 1, car VREng ne gere pas encore les interactions entre mondes.
- Methodes : les methodes method1 et method2 sont les methodes d'action qu'on 
applique a l'objet cible.
Un appel de button se fait par :
new button(	x, y, z, ?, startstate, targetname, method1,
	method2, SID/OID, dx, dy, dz) ;

b) Classe door
La classe door est le second type d'objet modifiable par l'avatar, il peut 
l'ouvrir ou la fermer. Des parametres speciaux doivent etre ici aussi precises.

- Nom de porte : nom est un parametre indispensable car il sert d'identifiant 
pour les boutons qui pourraient agir sur cette porte.
- Angles de parcours : Les angles specifiees 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 fermee. Attention : l'un de ces deux 
parametres doit etre egal a l'angle ? definissant Orientation
- Vitesse : speed ne definit pas seulement la vitesse a laquelle la porte 
s'ouvre ou se ferme. Le signe de ce parametre indique egalement dans quel sens 
la porte s'ouvre, les valeurs positives etant celles du repere orthonormal 
direct utilise par VREng.
- Taille de gonds : xoffset precise simplement l'ecart entre le bord interieur 
de la porte et son axe de rotation. Ceci permet en particulier de simuler la 
presence de gonds et de rendre le mouvement plus realiste.

Un appel de door se fait par :
new door(	name, x, y, z, ?, angleopen, angleclosed, speed,
	xoffset, SID/OID, dx, dy, dz)  ;

c) Classe gate
La classe gate permet d'acceder a un autre monde VREng par l'action de 
teleportation. Elle fonctionne comme la classe wall, sauf pour l'appel de la 
classe qui contient deux arguments supplementaires : 

- Adresse URL : adresse url d'un fichier de configuration VREng (extension .cfg) 
qui decrit le monde auquel on accede.
- Adresse IP multicast : adresse ipm du monde d'arrivee. Elle a une structure 
bien definie : groupe/port/ttl

Un appel de gate se fait par :
new gate(x, y, z, ?, url, ipm, dx, dy, dz)  ;

On pourra faire par exemple :
adresse = "www.enst.fr/~perso/monde.cfg";
ipmulti = "225.224.0.2/62666/15";
new gate(12, 4, 0, ?, adresse, ipmulti, 0.1, 2, 2)  ;

d) Classe aoi
L'acronyme aoi designe Area Of Interest, a savoir une region parallelepipedique 
de l'espace ou tous les avatars presents peuvent communiquer entre eux via une 
adresse IP multicast. Pour une definition plus detaille des aoi, se referer a la 
documentation existante.

La declaration d'une aoi ressemble a celle du wall a quelques exceptions pres. 
Les parametres d'appel obligatoires sont la Position, le Nom de l'aoi, son 
Adresse IP multicast et sa Dimension :

- Nom de l'aoi : aoiname est la chaine de caracteres donnant le nom de l'aoi.

Attention : il n'y a pas de champ Orientation.

Un appel de aoi se fait par :
new aoi(x, y, z, aoiname, ipm, dx, dy, dz) ;

e) Classe earth
La classe earth decrit une sphere qui tourne lentement. Ses proprietes sont 
evidemment radicalement differentes de celles de wall. On retrouve le champ 
Position, mais il y a un nouveau parametre obligatoire :

- Rayon : rayon r de la sphere.

Un appel de earth se fait par :
new earth(x, y, z, r) ;

Attention : un monde ne peut contenir qu'un objet de la classe earth.

Comme une sphere blanche qui tourne n'est pas tres interessante, l'usage des 
textures est fortement recommande. Il faut modifier l'attribut texture apres 
l'instanciation de la sphere.

- Texture de sphere : chaine de caracteres tex donnant l'adresse de la texture a 
appliquer a la sphere.

De la meme maniere que pour le wall, il y a des attributs Jeux de lumiere.

On pourra faire par exemple :
wood = "http://www.enst.fr/~perso/images/wood.gif" ;
rayon = 1 ;
terre = new earth(12, 4, 0, rayon) ;
terre.tex = wood ;

f) Classe cauldron
La classe cauldron cree un tore solide. Elle est assez simple car il n'y a pas 
de texture. Cette classe reprend le champ Position, et utilise egalement un 
champ pour ses dimensions propres :

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

Un appel de cauldron se fait par :
new cauldron(x, y, z, R, r) ;

Encore une fois, il y a des attributs Jeux de lumiere comme pour wall.

g) Classe backwalls
Un backwall est un wall le long duquel on peut glisser. Il faut le specifier 
dans un fichier de configuration special (d'extension .cfg) contenant dix 
colonnes :

xStart xEnd yStart yEnd zSart zEnd red green blue

On ne peut pas les tourner ni leur donner de textures. On ne donne que les 
coordonnees des points ou les murs commencent et finissent. Les champs red, 
green et blue definissent les composantes primaires de la couleur du mur, elles 
ont des valeurs entre 0 et 1.

La classe primitive backwalls de VREL fait simplement appel a l'adresse URL de 
ce fichier de configuration special.

Un appel de backwalls se fait par :
new backwalls(url) ;



7 EXEMPLES

Le lecteur trouvera dans cette partie differents exemples de fichiers Vrel afin 
de mieux comprendre le langage decrit dans les parties precedentes. Les exemples 
proposent de construire des objets de type mobiliers. 


Fichier walluni.vrel :


Var wood =  "http://www.infres.enst.fr/vreng/gif/wood.gif"


class WallUni compound
{
	var text ;

	constructor(posX, posY, posZ, Angle, EpX, EpY, EpZ, text)
	{ 
	w = new wall(posX, posY, posZ, Angle, EpX, EpY, EpZ);	
	w.tex_xp = text ;
	w.tex_xn = text ;
	w.tex_yp = text ;
	w.tex_yn = text ;
	w.tex_zp = text ;
	w.tex_zn = text ;
	}

	constructor(posX, posY, posZ, Angle, EpX, EpY, EpZ)
	{ 
	w = new wall(posX, posY, posZ, Angle, EpX, EpY, EpZ);	
	w.tex_xp = tex ;
	w.tex_xn = tex ;
	w.tex_yp = tex ;
	w.tex_yn = tex ;
	w.tex_zp = tex ;
	w.tex_zn = tex ;
	}
}



class wallwood extends wallUni
	{
	text = wood ;
	}



Fichier tabouret.vrel : 

import "walluni.vrel"

class Tabouret  compound
{
	constructor (posX, posY, posZ)
{
	new wallwood(posX, posY, posZ, 0, 2.5, 2.5, 0.2) ;
	new wallwood(posX+2.2, posY+2.2, posZ-2.5, 0, 0.1, 0.1, 2.5);
	new wallwood(posX-2.2, posY+2.2, posZ-2.5, 0, 0.1, 0.1, 2.5);
	new wallwood(posX+2.2, posY-2.2, posZ-2.5, 0, 0.1, 0.1, 2.5);
	new wallwood(posX-2.2, posY-2.2, posZ-2.5, 0, 0.1, 0.1, 2.5);
}
}



Fichier chaise.vrel :

import "tabouret.vrel"

class Chaise compound
{
	constructor (posX, posY, posZ)
	{
	new Tabouret (posX, posY, posZ) ;
	new Wallwood (posX+2.4, posY, posZ+2.5, 0, 0.1, 2.5, 2.5) ;
	}
}



Fichier table.vrel

import "walluni.vrel"

class Table compound
{
	constructor (posX, posY, posZ)
	{
	new WallUni(posX, posY, posZ-2.5, 0, 7.5, 5, 0.2, wood);
	new WallUni(posX+6.6, posY+4.4, posZ-5, 0, 0.15, 0.15, 2.5, wood);
	new WallUni(posX-6.6, posY+4.4, posZ-5, 0, 0.15, 0.15, 2.5, wood);
	new WallUni(posX+6.6, posY-4.4, posZ-5, 0, 0.15, 0.15, 2.5, wood);
	new WallUni(posX-6.6, posY-4.4, posZ-5, 0, 0.15, 0.15, 2.5, wood);
	}

	constructor(posX, posY, posZ, texture)
{
w1 = new WallUni(posX, posY, posZ, 0, 0.25, 0.25, 0.02, wood) ;
w2 = new WallUni(posX+2.2, posY+2.2, posZ-2.5, 0, 0.1, 0.1, 2.5);
	 w3 = new WallUni(posX-2.2, posY+2.2, posZ-2.5, 0, 0.1, 0.1, 2.5);
	 w4 = new WallUni(posX+2.2, posY-2.2, posZ-2.5, 0, 0.1, 0.1, 2.5);
	 w5 = new WallUni(posX-2.2, posY-2.2, posZ-2.5, 0, 0.1, 0.1, 2.5); 
	 w1.tex = texture ;
	 w2.tex = texture ;
	 w3.tex = texture ;
	 w4.tex = texture ;
	 w5.tex = texture ;
	 } 
}



Fichier main :

import "chaise.vrel"
import "table.vrel"

var N = 5;

begin
{
  var i;

  i = 0;
  while (i < N) {
    new Chaise (5 * i, 15, 0.5);
    new Table  (4 * i, 15, 1);
    i = i+1;
  }
}
end







Pour plus d'information sur VREng, se reporter a la documentation consultable 
en ligne : http://www.infres.enst.fr/vreng
