Niveau 3: manuel programmeur

Généralités
Les objets
Les objets d´anyflo
Propriétés
Les listes chainées
Les blocs
Les datas
Constantes
Appels internes
Debug
Messages
Protocoles
Le compilateur
Les fichiers
Débuger
algorithmes
Temps réel
Transfert



Généralités

     Introduction

     Interpréteur

     Anyflo

     Applications

     Langues

     Link

     Expression

     Evaluation

Introduction

Anyflo est un interpréteur pseudo compilé pouvant prendre ses entrées depuis:
a) Le clavier (fonctionnement par défaut).
     Un ? indique que l´interpréteur attend une ligne de commandes de la forme:
          E1;E2;...En;ENTER
               Les Ei sont des expressions évaluables de l´une des 2 formes:
                    mot1(par1) mot2(par2) ... motn(parn);
                         Les moti sont des mots du langage.
                         Les pari sont des expressions évaluables.
                    mot1(par1) mot2(par2) ... motn(parn)=expr;
                         expr est une expression évaluable.
          Une expression évaluable retourne une valeur.
               Une valeur peut être:
                    Un nombre (entier ou flotant), exemple -123.07.
                    Une liste de nombres, exemple 1,2,-3,125.76.
                    Une chaine de caractères de caractère, exemple "string".
                    Une concaténation des valeurs précédentes, exemple 1,2,3,"string,"-1.23,5.
                    Ou NIL (le vide).
b) L´appel à une fonction retournant une valeur.
c) En mode interaction, le dialogue se faisant via la souris, le clavier ou n´importe quel périphérique.

Interpréteur

Les structures de l´interpréteur et les #define des mots du langage sont définis dans:
     defa.h.
Les sources sont dans les fichiers *a.c et *a.cpp
Les mots du langage sont définis dans:
     koma.h.
Les messages sont définis dans:
     mesa.h.
Le langage esr décrit dans:
     manuel langage.

Anyflo

Les structures d´anyflo sont définies dans:
     defb.h
Les sources sont dans les fichiers *b.c et *b.cpp
Les mots d´anyflo sont définis dans:
     komb.h.
Les messages sont définis dans:
     mesb.h.
Pour le temps réel, dans:
     def_interacb.h.
Pour les périphériques, dans:
     device.h.
Les messages en anglais sont dans:
     Voc_eng
Les messages dans la langue xxx sont dans:
     Voc_xxx
La traduction est effectuée par la fonction long GENERATE_CHAR(long *p1, long *fin) du fichier mesa.c.

Applications

Les structures d´une application sont définies dans:
     defc.h.
Les mots de l´application sont définis dans:
     komc.h.
Les messages sont définis dans:
     mesc.h.
Les sources d´une application peuvent être ajoutées dans:
     utilb.c.
Ce fichier sert d´interface pour link des objets C ou C++ à anyflo. Il sera nécessaire de construire un nouvel exécutable avec VisualC++ dont l´environnement se trouve dans le dossier anyflo
Pratiquement:
     1) Lancer Microsoft Visual C++, file->Open Workspace->anyflo->anyflo.dsw.
     2) Modifier le fichier utilb.c, ajouter éventuellement d´autres fichiers .c ou .cpp (auquel cas les ajouter par Project->Add To Project->files ou new).
     3) Compiler et link par Build->build anyflo.exe
     4) Un nouvel exécutable anyflo.exe est construit dans le dosier anyflo/Debug.
     5) Pour le déboger: Build->Start Debug->Go, etc..
D´autres applications sont dans *d.h, *d.c et *d.cpp, etc..

Langues

Les fichiers komx.h et mesx.h permettent de traduire le système dans une autre langue. Il est possible de définir plusieurs langues simultanément en sur définissant les mots dans komx.h.
Par exemple, dans komb.h:
|1: screen ecr
donne 2 noms screen et ecr pour la commande d´effacement de l´écran.

Link

Le dossier anyflo contient:
Le dossier Debug contenant the objets *.o and the executable anyflo.exe.
Include files *.h
Sources files *.c livrés avec la distribution
Les fichiers nécessaires pour reconstruire anyflo.exe dans l´environnement VisualC++.
Pour cela:
1) Lancer VisualC++
2) File->Open Workspace...
anyflo/anyflo.dsw
3) Modifier des fichiers sources.
4) Build->Build anyflo.exe lance le compilateur et l´éditeur de liens.
5) Pour débuger: Build->Start Debug->Go
Le fichier anyflo_video.js permet de lancer le nouvel exécutable anyflo.exe en mode vidéo.
Remarque: Ce fichier contient un chemin spécifique d´accès à l´exécutable et est différent du fichier distribution/anyflo_video.js.
Voir DEBUG ANYFLO.

Expression

Les données arrivent formatées de la façon suivante dans la fonction EVALUER_1() (commandes d´anyflo): pd0 -> (dim,MULT,n,0)(COM1)(COM2)... (COMn)
     dim = taille (en 32 bits) du buffer
         n = nombre de commandes
         COMi = (dim,env,num)(datas)
             env = numéro de l´environnement
                 0: Interpreteur (commandes de koma.h)
                 1: Anyflo (commandes de komb.h)
                 2: Utilisateur (commandes de komc.h)
             num = numéro de la commande
             si dim > 3 datas = datas

Evaluation

long EVALUER_0(long *pd0, long *pd_eg, long *suite, long *end, long sem): interpréteur (fichier esa.c).
long EVALUER_1(long *pd0, long *pd_eg, long *suite, long *end, long sem): anyflo (fichier exeb.c).
long EVALUER_2(long *pd0, long *pd_eg, long *suite, long *end, long sem): applicatioin (fichier utilb.c).
pd0 -> expression
pd_eg -> datas
suite -> suite du buffer
end -> fin du buffer
L´évaluation est retournée dans pd0.
La fonction retourne 0 si succès, ERR0 si erreur et DEB_EV si débordement.

Les objets

     Structure

     Visibilité d´un objet

     Objets généraux

     Objets simples

     Programmation d´un objet

Structure d´un objet
Structure d´une liste chainée

Structure d´un objet

Les objets sont des structures chainées: struct Objet
{
/* Identificateur */
long num;
char *name;
/* Type */
long type_0, type_1, type_2, type_3, type_type;
long lead; /* 0: leader absolu, sinon leader */
/* Bloc de propriétés */
long *bloc;
long *param;
/* Geometrie */
long nx, ny, nz, close, inc, cpt, valider;
/* Liste chainée d´objets locaux d´un objet autre qu´une fonction */
struct Objet *local;
/* Liste chainée de variables locales d´une fonction */
struct Objet *var;
/* datas pour une fonction (comme displ win func) */
long *tr;
/* Chainage */
struct Objet *fils;
struct Objet *pere;
};
Remarques: 1) Si l´objet est une fonction:
              local = liste des fonctions locales numérotées de 1 à n.
              var = liste des variables formelles, statiques, autos et locales, en cas de dupplication de la fonction (pour une fonction local) elles sont dupliquées et compilées, et leurs copies restent attachées aux fonctions dupliquées.
              nt = '?' pour un menu ?name.
2) Sinon: local = liste chainée des fonctions locales attachées à cet objet.

Structure d´une liste chainée

Certaines informations peuvent être empilées dans des listess chainées de structure:
struct Liste_Chainee
{
char *name;
long num;
long *datas;
struct Liste_Chainee *pere;
struct Liste_Chainee *fils;
};

C´est le cas de certaines commandes (comme geod).

Visibilité d´un objet

Un objet peut être atteint par son identificateur id qui est soit son nom (chaine de caractères), soit son numéro (entier non nul), cet objet est stocké dans une liste chainée Pile_xxx.
Il peut être valide (validate=1) ou non (validate=0).
Le bloc est de la forme: bloc=entete,adresses
       entete de dimension DIM_TETE=4: bloc[0,3] = (dim=DIM_TETE+n,AD,n,1)
     adresses de dimension n: bloc[DIM_TETE,DIM_TETE+n-1] = (p1,p2,...,pn): liste des pointeurs vers les blocs de propriétés.
param matrix.
env,type type principal env = numéro de l´environnement (0: interpréteur, 1: anyflo, >1: applications) type = un numéro caractéristique.
env2,type2 = type secondaire
nx,ny,nz = dimensions d´une grid 3D
close = 0 (ouvert), 1 (fermé)
local -> objet local.
pere -> objet père (nul pour la racine).
fils -> objet fils (nul pour le dernier).

Les objets généraux

A chaque type (eee, ttt) est associée une pile Pile_Ttt d´objets chaînés simples ayant ce même type (eee, ttt), la racine p0 de cette pile est un objet vide indestructible:
       p0->fils = p1 (1er), p0->pere = 0.
       p1->fils = p2 (2ème), p1->pere = p0.
       ...
       pn->fils = 0 (dernier). Un objet général est un objet quelconque dont on ne précise pas le type, sa manipulation éxige de connaître la pile dans laquelle il est stocké:
struct Objet *get_pile(long env, long type)
     Retourne la pile concernée.
struct Objet *set_object_general(long env, long type, long *p_id, long ind)
     Crée et retourne l´objet d´identificateur p_id{ind}.
struct Objet *get_object_general(long env, long type, long *p_id, long ind)
     Retourne l´objet de type (env, type) et d´identificateur p_id{ind}.
void rem_object_general(long env, long type, long *p)
     Supprime les objets de type (env, type) et d´identificateur p_id, tous si p_id = 0.
void init_object(struct Objet *p_obj);
     Initialise à zéro l´objet p_obj.

Les objets simples

Définition
Une pile d´objets chainés simples est constituée d´objets chainés de même (env,type) ne différant que par leurs identificateurs, la racine p0 de la pile est un objet vide indestructible.
Pour créer une pile Pile_Ttt:
Dans glbb.h: struct Objet Pile_Ttt[1];
Dans extbb.h: struct Objet Pile_Ttt[];
Dans initb.c: init_object(Pile_Ttt);
Si env=2, dans la fonction get_pile_c(long env, long type) ajouter:
case TTT: return(Pile_Ttt);
Accès aux objets simples
struct Objet *set_object_simple(struct Objet *pile, long env, long type, long *p_id, long ind)
     Crée l´objet simple de type (env, type) et d´identificateur p_id{ind} dans pile et le retourne.
struct Objet *set_object_simple_num_name(struct Objet *pile,
long env, long type, long env2, long type2, long *bloc, char *name, long num)

     Crée et retourne l´objet simple de type (env, type, env2, typ2) d´identificateur (nom,num) dans pile, et de bloc bloc, et le retourne.
struct Objet *get_object_simple(struct Objet *pile, long *p_id, long ind)
     Retourne l´objet simple de pile et d´identification p_num{ind}.
struct Objet *get_object_simple_type(struct Objet *pile, long type, long *p_id, long ind)
     Retourne l´objet simple de pile, d´identification p_num[ind] et de type type.
struct Objet *get_object_simple_num_name(struct Objet *pile_object, long num, char *name)
     Retourne l´objet simple de pile et d´identification (num,name)
void rem_object_simple(struct Objet *pile, long *p): supprime les objets simples de p, tous si p = 0
void renumeroter_object_simple(struct Objet *pile)
     Renumerote les numeros des objets simples de pile.

Objets d´anyflo

ancrages
brush
device        standard devices
field        func        font
genetic
history
image        interaction
local        light
memory        menu        message
network
object
palette        pointer
scale        see        stock
texture        trajectory
variable        vol        view

Ancrages

bloc(lead) -> (dim,type,1,1)(lead)
bloc(follow) -> (dim,type,nb_suiveur,1)(suiv1,suiv2,...)
bloc(follow) -> (dim,type,nb_suiveur,1)(suiv1,suiv2,...)
bloc(follow) -> (dim,A_LONG,nb_suiveur,1)(num1,num2,...)
bloc(vertex lead) -> (dim,A_LONG,nb_suiveur,1)(num)
bloc(vertex follow) -> (dim,A_LONG,nb_suiveur,1)(num)

Champs de forces

Dans Pile_Champ. type_0 = FIELD
type_1 = FUNC: champ fonctionnel.
       func("f"): bloc(func) -> nom de la fonction "f")
       func(num): fermer = num field_utilisateur(num,...)
       p_obj->var: fonction anyflo
type_1 = B_IMAGE; image field.
       bloc(B_IMAGE) -> (dim,UNSIGNED_CHAR,nx,ny)(rgba,...)
       bloc(COE) -> (dim,A_FLOAT,1,1)(coe)
       bloc(LIMIT) -> (dim,A_FLOAT,4,1)(x1,y1,x2,y2)
       bloc(A_LIST) -> (objet_image)
       bloc(NUMBER) -> (id_image)
type_1 = ROTA, ROTX, ROTY, ROTZ, FUNC
       champ rotationnel.
type_1 = VOL: champ volumétrique.
       vol(id): bloc(vol) -> identificateur.
       p_obj->var: objet volume (ne pas faire sup_obj(field))
type_2 = VERTEX
       les sommets du volume id sont des champs centraux.

Echelles

Dans Pile_Echelle.
1)échelle linéaire:
scale(id): crée un objet de type scale et d´identificateur id..

2)scale ext:
scale ext("eee")directory("ddd");
       Crée un objet de type scale ayant les propriétés:
       EXT: ".eee"
       DIRECTORY: "ddd\"
              NAME:
              nom1.eee
              nom2.eee
              ...
       nx = largeur de la fenêtre en pixels
       ny = nombre de noms
              nz = numéro cliqué.
              num = numé courrant.
              close= ligne.
       validate 0 (passive) 1 (active).
Les autres options(opt) (colors, ...).
Invoqué par:
scale ext("eee")directory("ddd")poi(x,y)
       La liste est affichée en (x,y).

échelle input:
scale("sss")input
       Crée l´échelle de nom sss
inc, cpt: periode
scale("sss")input poi(x1,y1,x2,y2)
Affiche l´échelle:
bloc B_TEXT -> texte tappé
bloc COL -> couleur du texte
bloc FRAME -> couleur du cadre
bloc RECTANGLE -> couleur du rectangle

3) échelle move:
scale("t1 t2 ...")move(id)poi(x1,y1,x2)dim(t)coe(C1,C2,...)
       Crée l´objet échelle id placé initialement en (x1,y1) constitué de n échelles linéaires dont les n options sont empilées dans bloc=(dim0,.,n,.)(dim1,opt1)(dim2,opt2),...,(dimn,optn),0.
scale move(id)poi(x1,y1,x2)coe(C1,C2,...)
       Affiche les échelles (déplaçables à la souris).

Option mouse(1) P_Id_Scale -> (num,name,lock), si clic gauche: lock=-lock et la fonction et_Id_Scale() retourne 1;

Fonctions

Dans Pile_Fonc.
       name = nom de la fonction
       type_0 = INTERP (exécution d´une ligne de commande).
       type_0 = FUNC (exécution d´une fonction).
       type_1 = FUNC: variable de type fonction dans local.
       nx = nombre de paramètres formels
       nt = type d´appel pour un menu anyflo (?).
       bloc -> (dim,A_CHAR,.,.)("text de la fonction").
       param -> (dim,COMP,0,0)(code compilé).
       var -> liste chainée des variables restituables d´une fonction:
              FORMEL: variables formelles
              -A_STATIC: variables statiques
       Les autres variables, perdues en sortie de la fonction, sont empilées. -AUTO: variables automatiques
              -GLOBALE: variables globales aux fonctions locales
       Une pile Pile_Pile d´objets contient:
              objet de tête, type_0 = PILE
              l´objet fonction.
              les variables chainées.
              fils = 0: fin de pile
              En sortie de la fonction la pile est libérée jusqu´au père de la tête.
              Un appel de fonction est empilé à la suite.

Fontes

Dans Pile_Fonte.
num: numéro OpenGL
name: nom anyflo
nx = Fonte_x, ny = Fonte_y: dimensions courantes, nz = Fonte_e, close = Fonte_d
dim font retourne Fonte_x,Fonte_y,Fonte_e,Fonte_d
dim scale retourne D_Fonte_y = Fonte_y + 2 * Fonte_e, Dy2 = D_Fonte_y + Fonte_d.
nz, close: dimensions par défaut
bloc -> (dim,A_CHAR,nx,ny)(char[nx,ny]0, ...,char[nx,ny]255) pour une font utilisateur définie par pixels. Fonte0 = numéro de la font initiale ("9_BY_15" par défaut), Fonte = numeéro de la font courante.
D_Fonte_y = Fonte_y + 6: hauteur des rectangles et cadres contenant un text text ou une scale.

Génétiques

Dans Pile_Genetique.

History

Dans Pile_History.
       Pile_History->bloc = (dim,AD,n,0)(C1)(C2)..(Cn)
              Ci = (dim,A_CHAR,.,.)("ligne de commandes")

Images

Ce sont des objets simples stockés dans Pile_Image:
       Pile_Image -> image de travail.
       Pile_Image->fils -> 1ère image utilisateur.
       nx,ny,nz = dimensions, np = nx * ny * nz, close = texture.
       bloc(B_IMAGE) -> (unsigned char,np,4) rvba (t)
       bloc(-B_IMAGE) -> (unsigned char,np,4) rvba (t-1)
       bloc(0) -> (float,np,4) rvba (t)
       bloc(1) -> (float,np,4) rvba (t-1)
       speed -> (float,np,4)
       acc -> (float,np,4)
       pixel -> (float,np,2)
identificateur id.
Dimensions: nx, ny, nz.
nz plans de nx*ny pixels RGBA stockés à la suite dans (p_obj->bloc)[DIM_TETE].
La 3ème dimension nz peut être utilisée pour des textures 3D ou pour analyser le comportement dynamic d´une image dans le temps (close variant entre 0 et nz-1): speed, accélération, étude de courbes de variations d´un pixel (par exemple dans une image speed", ces courbes peuvent être très perturbées et demandent à être filtrées).
close = 0 (valeur par défaut), pas de LIBRE associée à l´image.
si close > 0 est le numéro de la LIBRE associée ramené par glGenTextures((GLsizei) 1, &close);
et utilisé par glBindTexture(GL_TEXTURE_2D, ind);.
close image(id)=0 désactive la LIBRE en faisant glDeleteTextures((GLsizei) 1, &close); et p_obj->close = 0;
Les informations sont stockées sous forme de buffers de nx*ny*nz*4 octets dans:
     bloc(1,IMAGE) = image unsigned char rgba (t) actuelle.
Si dyna=p_obj->type_3: image dynamic:
     bloc(1,-IMAGE) = im(0) = image unsigned char rgba (0) au temps 0.
     bloc(1,NORMALE) = 1 (normal pour displ image poi normal) */.
     bloc(0,0) = im(t) = image float rgba (t) au temps t.
     bloc(0,1) = im(t-1) = image float rgba (t-1) au temps t - 1.
     bloc(1,VITESSE) = speed float d(rgba)/dt.
     bloc(MASSE)
     bloc(RESSORT)
     bloc(DUP) pour traj dim image

     bloc(MOYENNE) = n,cpt,nx,ny,P1,P2,...,Pn pi -> nx*ny unsigned char (r,g,b,a,...) image(id)average(n), cpt varie de 0 à n-1, l´image cpt est remplacée par l´image chaque fois que celle-ci est modifiée, elle prend alors la valeur average des n images Pi (nx * ny).

Animation:

     bloc(TRAJ) = traj1,traj2,...

     bloc(PROPR) = tran(x,y) dila(cr,cv,cb) dim(nx,ny) luminance(light) move(x,y) rotx(rx) roty(ry) rotz(rz) transp(t)

interaction

interaction ascii
interaction stock
interaction write

interaction ascii

Dans Pile_Interaction.
     inreraction ascii("c")func("f")
          type_0 = INTERACTION, type_1 = ASCII, type_2 = 0, type_3 = FUNC
          name -> "c"
          bloc NOM -> "f"
          local -> p_func

     inreraction ascii("c")write name("nnn.bmp")image(id)vol win(x1,y1,x2,y2)dim(dx,dy) number("4D",num,inc)format("BGR")
          type_0 = INTERACTION, type_1 = ASCII, type_2 = GARE, type_3 = B_IMAGE, VOL, ...
          name -> "c"
          num = num, inc = inc, close = 0 (pas de codage), 4 (codage "4D"), nz = 1 (normal)
          bloc DIM -> dx,dy
          bloc NOM -> "nnn.bmp"
          bloc FEN -> x1,y2,x2,y2
          bloc FORMAT -> "BGR"
          bloc TYPE -> id

interaction stock

In Pile_Interaction.

     interaction stock win(x1,y1,x2,y2)dim(dx,dy)number("4D",num,ni,inc)format("BGR")
          type_0 = INTERACTION, type_1 = 0, type_2 =STOCK, type_3 = B_IMAGE, VOL
          nx = ni, ny = cpt++
          bloc DIM -> (dimx, dimy), nz = normal (pour image)
          bloc NUMBER -> ["4D"],num,ni,[inc]

interaction write

interaction write

Dans Pile_Interaction.

     interaction write("nnn.eee")win(x1,y1,x2,y2)dim(dx,dy)number("4D",num,ni,inc)format("BGR")
          type_0 = INTERACTION, type_1 = 0, type_2 = GARE, type_3 = B_IMAGE, VOL
          nx = ni, ny = cpt++
          bloc DIM -> (dimx, dimy), nz = normal (pour image)
          bloc NAME -> (nnn.eee), nz = normal (for image)
          bloc NUMBER -> num,ni,[inc]

Fonctions locales

Dans p_obj->local.
local(0)vol(id)="f"; ajoute à p_obj->local une copie compilée de la fonction f numérotée de 1 à n et de type = LOCALE.
La 1ère fonction local est éxecutée juste avant l´affichage du volume id et joue le rôle de la fonction main du langage C, elle a pour père (indestructible) l´objet afin de retrouver les globales dans obj->var.
local(0)vol(id)=num; donne à l´objet id comme 1ère fonction local le case num: de la fonction EXEC_OBJ(p_obj, num) du fichier utilb.c
p_obj->local->type_0=LOCALE, p_obj->local->type_1=num.

Lumières

Dans Pile_Lum.
p_obj->num, p_obj->name: identificateur.
p_obj->nx = numéro de la light d´OpenGL.
p_obj->bloc -> (dim,AD,n,1)(p1,p2,...,pn).
       p1 -> bloc COU: couleur
       p2 -> bloc AMBIANCE: ambiance
       p3 -> bloc POI: position
       p3 -> bloc COE: atténuation en fonction de la distance
Pour un spot:
       p4 -> bloc AIM: point de visée
       p5 -> bloc FOC: ouverture
       p6 -> bloc ROUL(c): l´intensité de la lumière est multipliée par (cos(a))^c, avec a=angle(dor,LP), dir=aim light, L=eye light P=point éclairé.
       p7 -> bloc TRAJ: liste chainée des trajectoires de propeiétés.

2D textures

Ce sont des images de Pile_Image:
              nx,ny = dimensions, close = texture.
              close = ind de glBindTexture(GL_TEXTURE_2D, ind)
texture vol: bloc(TEXTURE)
texture fac vol: bloc(TEXTURE,FAC)-> AD,p1,p2,... pi->datas(texture fac(i)vol(id))

Mémoires

Dans Pile_Memoire.
p_obj->bloc -> (dim,AD,n,1)(p1,p2,...,pn).
       p -> bloc (POI RECTANGLE).

Mémoire d´objet

memory(id1)object(id2) est un objet (1,MEMORY) stocké dans p_obj->local.

Mémoire d´un objet

bloc mémoire.

Menus

Dans Pile_Menu.
generate menu("f0;sm;f1;f2;f3;f4")text("f0;>sm;f1;.f2;!f3;!f4")text("h0;hsm;h1;h2;h3;h4) poi(x,y)col(r,v,b)[rectangle(rr,vr,br)][frame(rc,vc,bc)]
       name = nom "f0" de la 1ère fonction
       nx = nombre de fonctions, ny = verrou, close = mouse (1 par défaut)
       validate = 0 (off), 1 (on)
       bloc -> (DIM_TETE+2,A_D,n,1)(pi)
              bloc NOM = ("f0;>sm;f1;.f2;!f3;!f4;=f5;") noms des fonctions.
              bloc TEXTE = ("f0;sm;f1;f2;f3;f4;f5;") noms des cases.
              bloc TYPE = (0,->,0,-.,-!,-!,-=) types
              bloc MENU = (pf0,pf1,pf2,pf3,pf4,pf5) objets indestructibles (type = LONG et non AD) (sous menu si type==´>´, sinon fonction).
              bloc HELP = ("h0;h1;h2;h3;h4;h5") help
              bloc DESSOUS = (x1i,y1i,x2i,y2i) cadres des hi
              bloc POI = (x1i,y1i,x2i,y2i) cadres des cases
              bloc DESSOUS = (x1i,y1i,x2i,y2i) cadres des helps
              bloc FRAME = (ri,vi,bi) couleurs des cadres du menu.
              bloc RECTANGLE = (ri,vi,bi) couleurs des rectangles du menu.
              bloc MOUSE = (s) mouse
              bloc COU = (ri,vi,bi) couleurs des textes
              bloc EXEC = (pi,cpti,ti) période pi, compteur cpti de la case i >0 de durée ti.
              bloc PERIOD = (pi,nbi,cpti) ci =fluctuation de case, nbi = durée, cpti = coumpter.

Messages

Ce sont des objets simples stockés dans Pile_Message et définis par:
       un identificateur id (num ou name)
       validate = 1 (actif), 0 (passif).
       nx=period, ny=durée, nz=cpt
       nx = période, ny = durée, nz = cpt, close=mouse.
       validate = 0 (caché), 1 (affichable)
       close = mouse: 0 (permanent, 1 (inhibé si on clique dessus) br>        bloc -> (DIM_TETE+2,A_D,3,1)(p1,p2,p3)
              pi -> bloc(A_TIME, -A_TIME, FRAME, COU, FONTE, FORMAT, POI, RECTANGLE, TEXTE, ...)

Objet

Dans Pile_Objet. p_obj->type_type est le numéro interne (< 0) du type dans Type_Dynamique -> (dim,num,"t")(...) 0 de l´objet p_obj créé par object(id)type("t").
Objets de type donné:
object(id)type("t");
       type_type = num numéro interne (< 0) du type "t" dans Type_Dynamique -> (dim,num,"t",0)
object(id1)image(id2);
       type_1 = B_IMAGE
       bloc B_IMAGE -> id2

Palette

Dans Pile_Palette.
bloc: propriétés:
       TEXTE("HELP;SAUV;REST;REST0;PINCEAU;COU;INTERP;FIN"): menu
       POI(1)=(x1,y1), POI(2)=(x2,y2): fenêtre du menu
       COU(rt,vt,bt): couleur du text du menu.
       RECTANGLE COU(rr1,vr1,br1,rr2,vr2,br2): couleurs des cases pleines.
       FRAME COU(rc1,vc1,bc1,rc2,vc2,bc2): couleurs des cases filaires.

Périphériques standards

Audio Traité par DirectX dans des buffers de dimension maximale MAX_AUDIO=16384 (défini dans defb.h).
La capture audio de Audio_DIM échantillons (initialisé par dim(n)audio) se fait dans Buf_audio.
Son analyse se fait dans Buf_audio2.
Les maximums sont stockés dans Audio_Max sur Audio_NP (initialisé par audio NP(n)) images.
Les minimums sont stockés dans Audio_Min sur Audio_NP images.
Les modules sont stockés dans Audio_Module sur Audio_NP images.
L´envelope de précision est calculée dans Buf_Enveloppe_Audio.
La fft du signal est calculée dans Buf_Reelle (partie réelle) et Buf_Imaginaire (partie imaginaire).
L´envelope de la partie réelle est est calculée dans Buf_Enveloppe_Reelle.
L´envelope de la partie imaginaire est est calculée dans Buf_Enveloppe_Imaginaire.

stock audio Cpt_Stocker_Audio dans [0,Fin_Stocker_Audio[
Les informations sont stockées dans Buf_Stocker_Audio et écrites dans le fichier Nom_Stocker_Audio.DAT.

Périphériques (capteurs)

Dans Pile_Periph.
       num, name: indicateur.
       type_0 = TYP:
              P_AUDIO, P_COM, P_DAT, P_IMA, P_ITR, P_LIR, P_MEM, P_MID, P_SOC_TCP, P_SOC_UDP, P_SOURIS, P_TRIER.
       nz = 0: serveur, 1: client.
       inc = tempo.
       validate
       bloc -> bloc de propriétés (dim,AD,np,1)(pi):
              bloc[DIM_TETE+i] -> propri

P_DAT
       device(id)type("DAT")name("nnn")
       bloc(NOM) -> ("name") du fichier DAT.
       propriété VAR = contenu du fichier nnn en float
       nx = nombre de lignes (= nombre de vecteurs), ny = nombre de floats par ligne (= dimension des vecteurs).

P_IMA
       nx,ny = dim image, close = numéro image, poi(x,y)=coin bas left.
       bloc(VAR) = en_tete,datas:
              en_tete = (dim,UNSIGNED_CHAR,np,4) vec np = nx *ny.
              datas = (r,v,b,a,..) nx*ny pixels GL_RGBA.

P_MEM
       si (type_1 = SIMPLE): échange direct dans Buf_Map en caractères.
       bloc(NOM) -> ("name") de la mé:moire partagée.
       nx = dim (taille de la mémoire).
       p_var = bloc(VAR), pd = p_var[DIM_TETE] -> mé:moire.
              *pd = flag (driver -> anyflo): 0 si le driver écrit, 1: disponible.
              pd[1] = flag (ayflo -> driver): 0 si anyflo écrit, 1: libre.
              pd[2,dim-1] = datas.

P_UDP
       type_1 -> (struct sockaddr_in *) client, type_2 -> (struct sockaddr_in *) serveur.

P_LIR
       device(id)type("LIR")name("nnn")dim(n)
       bloc(NOM) -> ("name") du fichier LIR.
       propriété VAR = contenu du fichier nnn en ASCII
       nx = n.

P_SOC_UDP
       device(id)type("UDP")
       nx=id socket, ny=tempo, nz=leader: 0 client (par défaut), 1 serveur.
       close=bloquant
      
env2 -> (SOCKADDR_IN *)serveur, type2 -> (SOCKADDR_IN *)client).

Pinceau

Dans Pile_Pinceau.
Les fils sont les pinceaux définis par l´utilisateur:
       num,name: identificateur.
       type_0=PINCEAU, type_1=DISQUE,RECTANGLE,B_IMAGE
       si type_1==B_IMAGE type_2=DISQUE,RECTANGLE
       nx=dimx, ny=dimy, nz=precision
       close=0 (<- mouse), 1(<- commandes anyflo).
       inc=distance minimum entre 2 écritures.
       validate (0,1).
bloc: propriétés:
              COU(r1,v1,b1,...): couleurs.
              COL(illum,t1,t2,a,0): illum (0: filaire, 1: plein), t1,t2: transparences., a: aléatoire.
              B_IMAGE: (dim,AD,1,1)((unsigned char) pu), pu = (r1,v1,b1,a1,...)
                     type_1=IMAGE (intérieur d´une ligne dans une image), DISQUE ou RECTANGLE.
                     type_3=dynamic.
       bloc(TEXTURE) = numéro de l´image associée (pour image ou smooth.
       RESEAU(id), image lue -> motif -> validate network -> law -> image affichée

Pointeurs

@obj
       type_0 = AD_AD
       local -> obj

Réseaux neuronaux

Dans Pile_Reseau.
       name, num: identificateur
       bloc -> bloc d´adresses:
              pn -> neuronnes
              pf -> FAC (couches) (dim+6,MULT,6,1,1,FAC), (dim,HYBRIDE,nf,0), p1, p2, ..., pnf
                     pi = (np+DIM_TETE,A_LONG,np,1), (n1,n2, ...,nnp)
              pm -> matrix, pmm -> -matrix.
              pm -> (bloc MOTIF)(dim, FLOAT,nx,ny)dim=DT+np*nx*ny -> np = (dim-DT)/(nx*ny)
                     motifi=(ny vecteurs de dimension nx) (image de ny colonnes et nx lignes).
              pm -> (bloc -MOTIF): (dim, FLOAT,nm,dimm)(m1_1,m1_2,...,m1_dimm,...) = motif(t-1)
              pl -> (bloc LAW)(dim, FLOAT,nl,0)law1, law2, ...lawnl
                     lawi=(dim,A_FLOAT,ny,nx)(ny vecteurs de dimension nx) (image de ny colonnes et nx lignes).
              pl -> (bloc LAW)(dim, FLOAT,nl,0)law1, law2, ...lawnl
                     lawi -> (dim, FLOAT,np,dimp)tableau de np vecteurs de dimensions dimp.
              pm -> meta network, apprentissage adaptatif:
                     float c1_1, c1_2, c1, c1_0, dc1_1, dc1_2, dc1, dc1_0; /* coe1 */
                     float c2_1, c2_2, c2, c2_0, dc2_1, dc2_2, dc2, dc2_0; /* coe2 */
                     float moy0, moy; /* moyenne(erreur) */
                     Si moy<.5 c1-=dc1 et c2-=dc2 tout les d
                     long a1, a2, a, a0, cpta; /* Si moy>.5 faire alea(matrix) tout les a */
                     long d1, d2, d, d0, cptd;
                     float noise;
                     long val_cpt; float val_err; long val_stat; long val_nb;
validate network(id) retourne: val_cpt,val_err,val_stat,val_nb

Réseaux brush

network brush(id)=idr
       p_obj(idr) -> réseau luminance. network brush(id)=idr,idv,idb
       p_obj(idr) -> réseau R, p_obj(idv) -> réseau V, p_obj(idb) -> réseau B.

Les objets stock

Dans Pile_Stocker.
type_0 = STOCKER
       type_1 = AUDIO,
       DEVICE
       MOUSE: nz = mouse(0,1,2), close = displ, inc = dist * dist.
nx = NP (nombre de vecteurs), ny = compteur de saisie = [0,np-1], -1 (end).
bloc poi -> np vercteurs de dimension dimp.

Les trajectoires

       Dans Pile_Traj.
Trajectoires d´objets: voir leur description dans bloc de trajectoires.
nx=ni (nombre d´images, 0: fin), ny=cpt(ni): image courante, nz=période, nt=delay, cpt=cpt(delay)
fermer=order, inc=inc cpt(ni), lead=ini
Objet trajectoire: si leur bloc contient des trajectoires, traj de traj.
Si t_id est une traj d´un volume id (traj vol(id)=t_id; et si Interaction_Animer != 0, alors traj de traj (animation d´ordre supérieur), lorsque l´une d´entre elles est terminée (elles doivent toutes avoir le même ni) alors Interaction_Animer=2, et ces trajectoires sont incrémentées.
type_0 = TRAJ, type_1 = P1, type_2 = P2, type3 = ANIMATE (traj de traj
traj(ni)P1(p1)P2(p2)obj(id)
traj(id)animate(ni)P1(p1)P2(p2)
bloc(P1) -> bloc(VAR,P1)
bloc(P1,P2) -> bloc(VAR,P1,P2)
typ1 = NAME: traj(ni)name("nnn.eee")number(n1,n2)image(id):
       bloc(NAME) -> "nnn.eee"
       bloc(FORMAT) -> "4D"
       bloc(NUMBER) -> n1,n2
       bloc(VAR) -> n1,n1+1,...,n2
number: bloc NUMBER, A_LONG
images lues [FLAG_I-1,FLAG_I-ni]: bloc MEMORY, A_LONG

traj name number image transp(t1,t2)transp(t3,t4)col(r1,g1,b1)col(r2,g2,b2):
transf: bloc TRANSP(t1,t2), -TRANSP(t3,t4), COL(r1,g1,b1),-COL(r2,g2,b2)
ext: bloc (VAR,TRANSP), (VAR,-TRANSP), (VAR,COL), (VAR,-COL)
idem pour TRANSP LUMINANCE.

traj(ni)interpol(id1,id2,...idn)image(id)
       bloc(INTERPOL) -> id1,id2,...,idn
       bloc(INTERPOL,INTERPOL) -> (ni,cpt,dcpt)
       (id1,id2,1, id1,id2,.5, id1,id2,0)
       (id2,id3,.5, id2,id3,0)
       (idn-1,idn,.75, idn-1,idn,.5, idn-1,idn,.25, idn-1,idn,0)

traj(ni)transp(t1,t2,...)col(c1,c2,...)image(id)
       ti=ti1,ti2, ci=r1,v1,b1, r2,v2,b2.
       bloc(VAR TRANSP) -> ext(ti1,ti2,0)
       bloc(VAR COL 0) -> ext(ri1,vi1,bi1)
       bloc(VAR COL 1) -> ext(ri2,vi2,bi2)

traj(ni)transp(t1,t2,...)luminance(l1,l2,...)image(id)
       ti=ti1,ti2, li=l1,l2.
       bloc(VAR TRANSP) -> ext(ti1,ti2,0)
       bloc(VAR COL) -> ext(li1,li2,0)

Les variables

Variables externes
       Dans Pile_Extern.
Variables automatiques
       Toute variable non déclarée et présente dans une fonction p_obj, elles sont stockées dans p_obj->var.
Variables formelles
       Toute variable apparaissant dans la déclaration de la fonction f(f1,f2,...) est une variable formelle stockée dans p_obj->var.
Variables globales d´une fonction local à un objet
       Toute variable déclarée global dans une fonction p_obj, est stockée dans Pile_Globale avec num=numéro de l´objet, (env2,type2)=type de l´objet.
Variables statiques
       Toute variable déclarée static dans une fonction p_obj, elles sont stockées dans p_obj->var.

Fenetres anyflo de dialogue

Dans Pile_Voir.
Pile_Voir->validate = 1: petit carré en haut et à droite de l´écran permettant de cliquer pour validate see sur icone.
Pile_Voir->fils est l´objet see:
       validate = 0 (off), 1 (on), -1 (barre)
      
bloc -> bloc d´adresses:
              bloc poi(x1,y1,x2,y2).
              bloc -poi(x1,y1,x2,y2): mémoire poi.
              bloc col text(rt,vt,bt).
              bloc col rectangle(rr,vr,br).
              bloc col frame(rc,vc,bc).
              bloc text("...").
              font("fff")

Volumes

Dans Pile_Vol.
       name, num: identificateur
       nx,ny,nz,close (grid)
       validate = 0 (off), 1 (on)
      
bloc -> bloc d´adresses pi:
              poi(x1,y1,z1, x2,y2,z2, ...)
              fac(fac1,fac2, ...)
              autres propriétés.
      
param -> bloc de la matrice = (58,A_FLOAT,58,1)mat

particle
       type_0=VOL, type_1=VPARTICULE, type_2=0 ALEA RAND
       nz=3 (3D default), 2 (2D), 1(1D)
       bloc(center)(xp,yp,zp)
       bloc(mate ang)(an)
       bloc(mate axis)(ax,ay,az)
       bloc(mate force)(f1,f2,v1,v2)
       bloc(mate normal)(nor1,nor2)
       bloc(mate particle)(np)
       bloc(mate radius)(ray)

Paramètres:
              AD_X=0, mat[AD_X,AD_Y,AD_Z]=x,y,z: déplacement
              AD_DIL_X=3, mat[AD_DIL_X,AD_DIL_Y,AD_DIL_Z]=cx,cy,cz: dilatation
              AD_ROT_A=6, mat[AD_ROT_A]=a: angle de la rotation
              AD_AXE_X=7, mat[AD_AXE_X,AD_AXE_Y,AD_AXE_Z]=xa,ya,za: axe de la rotation
              AD_ROT_X=10, mat[AD_ROT_X,AD_ROT_Y,AD_ROT_Z]=rx,ry,rz: angles des rotations x, y et z
Matrices:
              AD_MAT=13, mat[AD_MAT]=matrice 4*4 de transformation
              AD_X0=AD_MAT+16=29, mat[AD_X0,AD_Y0,AD_Z0]=x,y,z: déplacement cumulé
              AD_DIL_X0=32, mat[AD_DIL_X0,AD_DIL_Y0,AD_DIL_Z0]=cx,cy,cz: dilatation cumulée
              AD_ROT_A0=35, mat[AD_ROT_A0]=a: angle de la rotation
              AD_AXE_X0=36, mat[AD_AXE_X0,AD_AXE_Y0,AD_AXE_Z0]=xa,ya,za: axe de la rotation cumulée
              AD_ROT_X0=39, mat[AD_ROT_X0,AD_ROT_Y0,AD_ROT_Z0]=rx,ry,rz: angles des rotations cumulées x, y et z
              AD_MAT2=42, mat[AD_MAT2]=matrice 4*4 courante (calculée à l´affichage)
Dimension totale=DIM_MAT=AD_MAT2+16=58

Paramètres mémorisés: mat[AD_X0,AD_Y0,AD_Z0]=x,y,z: déplacement
              mat[AD_DIL_X0,AD_DIL_Y0,AD_DIL_Z0]=cx,cy,cz: dilatation
              mat[AD_ROT_A0]=a: rangle de la rotation
              mat[AD_ROT_X0,AD_ROT_Y0,AD_ROT_Z0]=xa,ya,za: axe de la rotation
      

Vues

Dans Pile_Vue.
       type_0=VIEW, type_1=AIM,AXIS, type_3=A_WRITE
       name, num: identificateur
       bloc -> bloc d´adresses:
              poi(x,y): position
              aim(xa,ya,zq): point de visée
              axis(dx,dy,dz): direction
              foc(f): focale
              roll(r): roulis
              autres propriétés.

La construction d´autres listes chainées d´objets simples est en cours d´implémentation.

Programamtion d´un objet

Syntaxe générale, soit obj un type d´objet:
obj(id); crée l´objet d´identificateur id.
obj(id)propr(p)...; crée l´objet id avec les propriétés propr(p) ...
obj ... propr obj2(id2); retourne la propriété obj ... propr de l´objet obj2(id2).
obj ... propr obj2(id2)=p; affecte cette propriété.

Voir un exemple dans utilb.c.

Propriétés

Forme générale

Les propriétés d´un objet sont des blocs dont les adresses sont dans le bloc de cet objet:
object->bloc -> (dim,AD,n,A)(p1,...,pn)
pi -> (dim,MULT,dim1,n,(e1,c1,...,en,cn)
pi + dim1 -> (B1)...(Bn)
Bi -> (dim,ei,ci)(datas)

Les listes chainées

Ce sont des objets réduits à une liste de propriétés. struct Liste_Chainee
{
     char *name;
     long num;
     long *bloc;
     struct Liste_Chainee *pere;
     struct Liste_Chainee *fils;
};

datas -> (DIM_TETE+n,AD,n,1)(p1,p2,...,pn) pi->(dim,ei,ci)(datas);

Les blocs

Un bloc esdt une structure dynamidue non fixée à la compilation.

Les blocs simples
Les blocs multiples
Les blocs d´attaceh
Les blocs de mémoires
Les blocs de trajectoires
Les blocs de trajectoires de sommets
Matrice
Accès aux blocs

Les blocs simples


Un bloc simple est une suite de longs de la forme:
bloc=entete,datas
     entete=dim,type,np,dimp.
          dim=DIM_TETE+n, avec DIM_TETE=4 (taille fixe de l´entête), n=taille de datas.
          type=type des datas
          np,dimp: taille des datas
          type=A_FLOAT
                datas=np vecteurs float de dimension dimp.
                Exemple np=2, dimp=3, datas=x1,y1,z1, x2,y2,z2
          type=A_CHAR
               datas=chaine de np caractères.
          type=HYBRIDE, dimp=0
               datas=np blocs simples

Les blocs multiples

Un bloc multiple est une suite de longs de la forme:
bloc=entete, bloc1,bloc2, ...,blocn
     entete=dim0,MULT,dime,n,e1,c1,e2,c2,...,en,cn
          dim0 = taille totale du bloc = 4 + 2 * n + somme des tailles des bloci
          dime=taille de l´entête = 4 + 2 * n
          n = multiplicité du bloc
          ei,ci = numéro environnement, numéro commande
     bloci = bloc simple

Les blocs attach

attach com1(p1) com2(p2) ... comn(pn) obj(id);
       (dim,MULT,n+2,1)(3,1,ATTACHE) Bloc1 Bloc2 ... Blocn (dim,1,OBJ)(datas id)
Ce bloc est une propriété particulière de l´objet id qui est directement interprétable par evaluer_0().
Si obj=vol: juste après l´affichage de l´objet en tenant compte de ses transformations par sa matrice.
Sinon par EXEC_ATTACHE_OBJ(OBJ, 0) depuis interaction_Idle_Func() juste avant l´affichage.
OBJ est: BROU, CHAMP, GENETIQUE, B_IMAGE, LUM, OBJET, RESEAU ou VUE.
Ce bloc est directement passé à evaluer_0() pour exécution, la récursion infinie est évitée en faisant Sem_ATTACHE = 1 avant l´appel à EVALUER_0() dans la fonction AFF_VOL_1() du fichier affb.c (pour les attach ... vol(id) qui sont exécutés à l´affichage).

Exemples:
Attacher des transformations
attach Ta(a1,a2)vol(ida)Tb(b1,b2)vol(idb);

Attacher des sommets
attach vertex(a1,a2,...)vol(ida)vertex(b1,b2,...)vol(idb);

Attacher une vue interactive
attach vertex(a1,a2,...)vol(ida)vertex(b1,b2,...)vol(idb);

Vue adaptative dynamic
attach aim vol(1)spring(.1,-.1)dist(200)view(1);

Les blocs de mémoires

memory(id1)obj(id2)
obj->bloc -> (dim,AD,n,1)(p1,p2,...,pm,...)
       pm -> (dim,MULT,6,1,1,MEMORY)(pm1,pm2,...)
              pmi -> (dim,num,dim0,"name"),datas
              pmi+2+dim0 -> datas

Les blocs de trajectoires

traj(ni)transf(p)obj(id)...
Données:
En_Tete,Bloc_Traj,Bloc_Transf,[Bloc_Coe,Bloc_Som],Bloc_Obj
       En_Tete=dim,MULT,n,0
       Bloc_Traj=(dim,1,TRAJ)(datas=ni)
       Bloc_Transf=(dim,1,TRANSF)(datas=p)
Eventuellement:
       Bloc_Coe=(dim,1,COE)(datas=p)
       Bloc_Som=(dim,1,SOM)(datas=p)
       Bloc_Obj=(dim,1,OBJ)(datas=id)
       Autres blocs: period, acc, dec, pend, law(x,y,0, ...) servant à la construction de la trajectoire et non codés.
Codage dans le bloc TRAJ:
(dim,OBJ,1,1)(p)
       p->object_traj vide
       p->fils->object_traj (name=id,env=1,type=transf,nx=ni,ny=cpt,nz=period,num=inc)
       (p->fils)->fils->object_traj (env=1,type=transf,nx=ni,ny=cpt,nz=period,num=inc) ...
       p->nx = ni; p->ny = cpt; p->nz = period; p->close = multiplicité.
              object_traj->bloc=(dim,AD,n,1)(p1,p2,...,pn).
                     p1->Bloc_Transf=(dim,FLOAT,np,dimp)(valeurs)
                     Si dimp = 1: valeurs=v1,v2,...,vnp
              Si dimp = 3: valeurs=x1,y1,z1, x2,y2,z2, ..., xnp,ynp,znp
                     p2->Bloc_VAR=(dim,FLOAT,ni,3)(datas)
                     datas=(dim,A_FLOAT,ni,3)(valeurs): codage de l´extension de Bloc_Transf.
                     Si dimp = 1: valeurs=0,v_1,0, 1,v_2,0, ..., ni-1, v_ni,0
                     Si dimp = 3: valeurs=x_1,y_1,z_1, x_2,y_2,z_2, ..., x_ni,y_ni,z_ni

Eventuellement:
              p3->Bloc_Coe=(dimC,1,COE)(datas).
Codage particulier interpol(id1,id2,...)vol(id0):
              object_traj->bloc=(dim,AD,n,1)(p1,p2,...,pn).
                     p1->Bloc_Transf=(dim,FLOAT,np,dimp)(valeurs).
                     p2->Bloc(POI)=(dim,A_LONG,np,1)(pf1,pf2,...) pfi -> points du volume idi.
                     p3->Bloc(-POI)=(dim,A_FLOAT,ni,3)(x1,y1,z1,...): buffer d´extension de la trajectoire d´un sommet.
                     Pas de bloc VAR.

Au cours de l´animation:
       Si period=0 variation: 1,2,...,ni
       Si period=1 cpt varie cycliquement: 1, 2, ..., ni, 1, 2, ..., ni, ...
       Si period=-1 cpt varie cycliquement: 1, 2, ..., ni, ni-1, ni-2, ..., 1, 2, ...
Les coefficients de la matrice de l´objet et les paramètres animés sont modifiés en conséquence.

Les blocs de trajectoires de sommets

traj(ni)transf(p)vertex(s)obj(id)...
Données:
En_Tete,Bloc_Traj_Som,Bloc_Transf,[Bloc_Coe,Bloc_Som],Bloc_Som[vertex]Bloc_Obj
       En_Tete=dim,MULT,n,0
       Bloc_Traj_Som=(dim,np,OBJET,1)(datas=p_obj1,p_obj2,...,p_objn) pour n sommets
              p_obj->objeti = objet vide
              p_objj = p_obji->fils = objet traj transf vertex(i).

Matrix

(DIM_TETE+AD_MAT,A_FLOAT,AD_MAT,1)(datas):
       AD_X=0,AD_Y=1,AD_Z=2: x,y,z: displacement
       cxAD_DIL_X=3,AD_DIL_Y=4,AD_DIL_Z=5: cy,cz: dilatation
       AD_ROT_A=6,AD_AXIS_X=7,AD_AXIS_Y=8,AD_AXIS_Z=9: rota,axe_x,axe_y,axez
       AD_ROT_X=10,AD_ROT_Y=11,AD_ROT_Z=12: rotx,roty,rotz
matrix 4*4 calculée à AD_MAT=13, depuis (x,y,z, cx,cy,cz, a, ax,ay,az) par glGetFloatv() par un affichage virtuel (fonction CAL_MATRIX() du fichier affb.c:
       m00 m01 m02 m03
       m10 m11 m12 m13
       m20 m21 m22 m23
       m30 m31 m32 m33
matrice courante mat2 4*4 at:
       AD_X0=29,AD_Y0=30,AD_Z0=31: x0,y0,z0
       AD_DIL_X0=32,AD_DIL_Y0=33,AD_DIL_Z0=34: cx0,cy0,cz0
       AD_ROT_A0=35,AD_AXIS_X0=36,AD_AXIS_Y0=37,AD_AXIs_z0=38: rota0,axe_x0,axe_y0,axez0
       AD_ROT_X0=39,AD_ROT_Y0=40,AD_ROT_Z0=41: ax0,ay0,az0
DIM_MAT=58 = taille de la matrice.

Accès à un bloc

long *det_bloc_1(long *bloc, long e1, long c1)
     Retourne un pointeur vers le bloc (e1=environnement,type=c1) et 0 si erreur.
Exemple
det_bloc_1(o_obj->bloc,1,COL)
     retourne un pointeur vers la propriété illum de l´objet pointé par p_obj.
Pour une propriété multiple:
long *det_bloc_2(bloc, e1, c1, e2, c2)
long *det_bloc_3(bloc, e1, c1, e2, c2, e3, c3)
long *det_bloc_4(bloc, e1, c1, e2, c2, e3, c3, e4, c4)
long *det_bloc_5(bloc, e1, c1, e2, c2, e3, c3, e4, c4, e5, c5)
long *det_bloc_6(bloc, e1, c1, e2, c2, e3, c3, e4, c4, e5, c5, e6, c6)

long *etendre_bloc(long *p1, long dim)
     Crée le bloc p2 de dimension dim, l´initialise a p1, libere p1 et retourne p2 et 0 si erreur.
long *etendre_bloc_0(long *p1, long dim1, long dim2)
     p1 -> bloc de dimension dim1
     Crée le bloc p2 de dimension dim2, l´initialise a p1, libere p1, retourne p2 et 0 si erreur allocation.

long add_ad(struct Objet *p_obj, long *p)
     Ajoute le pointeur p dans le bloc de p_obj, retourne l´adresse de p dans bloc et < 0 si erreur.

long *cre_ad_bloc(struct Objet *p_obj, long n)
     Retourne un pointeur vers le bloc créé de n adresses nulles, et 0 si erreur.
Exemple
cre_ad_bloc(p_obj, 0)
     Retourne un pointeur vers le bloc=(DIM_TETE=4,AD,0,1) de l´objet pointé par p_obj.

long *add_bloc(struct Objet *p_obj, long dim)
     Ajoute un bloc de dim longs à l´objet pointé par p_obj, retourne ce bloc, et 0 si erreur.

void set_bloc_type_1(long *p_bloc, long e1, long c1)
     Initialise le bloc p_bloc au type (e1,c1)
Pour une propriété multiple:
void set_bloc_type_2(p_bloc, e1, c1, e2, c2)
void set_bloc_type_3(p_bloc, e1, c1, e2, c2, e3, c3)
void set_bloc_type_4(p_bloc, e1, c1, e2, c2, e3, c3, e4, c4)
void set_bloc_type_5(p_bloc, e1, c1, e2, c2, e3, c3, e4, c4, e5, c5)
void set_bloc_type_6(p_bloc, e1, c1, e3, c3, e4, c4, e5, c5, e6, c6) void set_bloc_type_ad(long *p_bloc, long nb_type, long *pd0)
     pd0 -> (dim,e1,c1,...), initialise le bloc p_bloc au type multiple (ei,ci)

long *cre_bloc(long dim)
     Créé un bloc de dim longs, fait Nb_bloc++, retourne un pointeur vers ce bloc et 0 si erreur.
     Le compteur Nb_bloc, initialisé à 0 au lancement du programme, est incrémenté à chaque création et décrémenté à chaque libération, ce qui permet un contrôle.

void free_a(long *p) */
     Si *p > 0: Libere le bloc p et fait Nb_bloc--
     void free_1(char *pc) */
     Libère le bloc pc et fait Nb_bloc--

long *etendre_bloc_0(long *p1, long dim1, long dim2)
     p1 -> bloc de dimension dim1
     Crée le bloc p2 de dimension dim2, l´initialise a p1
     libère p1, retourne p2 et 0 si erreur allocation

Les datas

     Structure des datas

     Datas spéciaux

     Exemple

     Accès aux datas

Structure des datas

bloc_datas -> (dimt,type,np,dimp,mat)(datas)
       dimt = taille du buffer
       type = type des valeurs
              A_SHORT: short
              A_LONG: long
              A_FLOAT: float
              A_CHAR: char
              AD: pointeur vers un bloc (cre_bloc, rem_bloc)
              AD0: pointeur vers un datas (malloc, free)
              HYBRIDE: Il y a np sous blocs ayant la structure de blocs.
              OBJ: pointeurs vers des objets
       np = nombre de vecteurs
       dimp = dimension des vecteurs
       dimp > 0 datas = v_1,...,v_np
              v_i = x_1,...,x_dimp
       dimp = 0 datas = (datas_1)...(datas_np)
              datas_i = datas
Remarque:
mat=1: par défaut
mat > 1: il y a mat datas, dimt = DIM_TETE + mat * (dimt - DIM_TETE)

Datas spéciaux

acc vertex vol
     (dim,A_FLOAT,np,3)(x1,y1,z1,...)
col vertex vol
     (dim,A_FLOAT,np,3)(r1,v1,b1,...)
force vertex vol
     (dim,A_FLOAT,np,4)(x1,y1,z1,v1,...)
          xi,yi,zi = force, vi = viscosité.
speed vertex vol
     (dim,A_FLOAT,np,3)(x1,y1,z1,...)
near vertex vol
     (dim,A_FLOAT,np,3)(x1,y1,z1,...)

Exemple

col vol(1)=1,.75,.25:
pd0 -> en tête:
     15 : dimension
     -1039 : MULT (commande multiple)
     2 : 2 commandes
     0 : sous blocs de dimensions variables
pd0 + 4 -> col
     3 : dimension
     1 : environnement anyflo
     17 : COU
pd0 + 7 -> vol
     8 : dimension
     1 : environnement anyflo
     4 : VOL
pd0 + 10 -> (1)
     5 : dimension
     -1002 : A_FLOAT
     1 : 1 valeur flotante
     1 : de dimension 1
     1.0 codé en flotant
pd_eg -> 1,.75,.25
     7 : dimension
     -1002 : A_FLOAT
     3 : 3 flotants
     1 : de dimension 1
     1,.75,.25 codés en flotant
la fonction EVALUER_1() retourne 1 et l´évaluation dans pd0, ici la valeur affectée: pd0 ->
     7 : dimension
     -1002 : A_FLOAT
     1 : 1 vecteur
     3 : de dimension 3
     1,.75,.25 codés en flotant

Accès aux datas

long *det_datas_1(long *bloc, long e1, long c1)      Retourne un pointeur vers les datas (environnement=e1,type=c1) et 0 si erreur.
Exemple
det_datas_1(o_obj->bloc,1,EXT)
     retourne un pointeur vers la propriété ext de l´objet pointé par p_obj.
Pour une propriété multiple:
long *det_datas_2(bloc, e1, c1, e2, c2)
long *det_datas_3(bloc, e1, c1, e2, c2, e3, c3)
long *det_datas_4(bloc, e1, c1, e2, c2, e3, c3, e4, c4)
long *det_datas_5(bloc, e1, c1, e2, c2, e3, c3, e4, c4, e5, c5)
long *det_datas_6(bloc, e1, c1, e2, c2, e3, c3, e4, c4, e5, c5, e6, c6)

long set_float_1(long *pd0, long *end, float f1)
     Initialise le bloc [pd0,end] au au float f1. Retourne ERR0 si débordement. Si end=0: pas de test de débordement.
Pour plusieurs float:
long set_float_2(long *pd0, long *end, float f1, float f2)
long set_float_3(long *pd0, long *end, float f1, float f2, float f3)
long set_float_4(long *pd0, long *end, float f1, float f2, float f3, float f4)
long set_float_5(long *pd0, long *end, float f1, float f2, float f3, float f4, float f5)
long set_float_6(long *pd0, long *end, float f1, float f2, float f3, float f4, float f5, float f6)

Constantes

Voir defa.h et defb.h.
/* PI */
#define PI 3.14159265358979323846
#define PIS2 1.57079632679489661923
#define DEUXPI 6.28318530717958647692
/* Conversion radians <-> degres */
#define Rad_Deg 57.295776
#define Deg_Rad 0.017453

Appels internes

     Pour simuler en langage C un appel en langage anyflo de la forme:
com1(par1)com2(par2)...
1) Construire une en-tête dans un buffer [pd0,end[:
ini_pile(pd0, end);
2)Empiler les commandes successives (envi,comi,bufi):
add_pile_buf(pd0, end, envi, comi, buf);
3) Appeler la fonction anyflo f correspondante:
f(pd0, end);
D´autres fonctions sont disponibles:
long add_pile_commande(long *pd0, long *end, long n, long env1, long com1, long env2, long com2)
     Pour empiler n<=2 commandes sans paramètres.
long add_pile_float(long *pd0, long *end, long env, long com, long n, float f1, float f2, float f3, float f4)

     Pour empiler une commande suivie de n<=4 float.
long add_pile_char(long *pd0, long *end, long env, long com, char *name)
     Pour empiler une commande suivie d´une chaine de caractères.
long add_pile_com(long *pd0, long *end, long *p_com)
     Pour ajouter p_com=(dim,env,com(datas) dans pd0.

Debug

Les paramètres de la fonction interaction debug sont accessibles en C:
MAX_DEBUG = nombre maximum d´échelles (fixé à 24).
N_Debug = nombre d´échelles (entre 0 et 24).
X1_Debug,Y1_Debug,X2_Debug,Y2_Debug,X3_Debug,X4_Debug = fenêtre d´affichage des échelles.
Val_Debug = valeurs de debuging = (c1_1,c1_2,c1, c2_1,c2_2,c2, ...).
Coe_Debug = bornes des valeurs = (b1_1,b1_2,b1, b2_1,b2_2,b2, ...).

Messages

message(env, num): édite le message numéro num de l´environnement env.
EDITER_IDENTIFICATEUR(p_obj): édite les types, le numéro et le nom de l´objet p_obj.

Protocoles

Les fonctions externes sont référencées dans:
defa.h.
defb.h.
defc.h.

Le compilateur

Principe        Commandes        Messages        Compilation        Fonctions        Pile        appel        exécution        retour        Variables        Instructions        boucle_for        boucle_while        switch        Link        Exécution

Principe

       Un text obéissant à la syntaxe du langage anyflo est "compilé" en un pseudo assembleur qui est linké puis directement interprété en C, ce qui le rend indépendant de l´environnement (système et machine).

Les commandes

       Les descriptions des commandes de l´environnement n (n = a: interpréteur, b: anyflo, c: 1 ère application, ..) se trouvent dans les fichiers komn.h sous la forme:
|num: com aaa
       num est le numéro relatif de la commande
       com est son nom
       aaa est un alias (optionnel)
emp,sem,dim,type
       sem = [yes no] com
       type est le type de la compilation:
              type=0: com com -> com(com)
              type=1: com com -> com com
              type<0: Annule l´evaluation
       v1,v2,...,: valeurs par défaut, autres formes:
              [n]=v: n valeurs initialisées à v
              [n]: n valeurs initialisées à 0
              .: Pas de valeurs

Les nombres des commandes sont stockées dans Nb_Commande[env] avec env = numéro de l´environnement (0: interpréteur, 1: anyflo, >1: applications).
Le nombre de commandes par application est fixé à 200 par la directive:
#define INC_COM 200 du fichier defa.h, ainsi:
les numéros internes des commandes de l´interpréteur appartiennent à l´intervalle [0,199].
les numéros internes des commandes d´anyflo appartiennent à l´intervalle [200,399].
les numéros internes des commandes de la 1ère application appartiennent à l´intervalle [400,599].
etc...
Les noms des commandes sont stockés dans Nom_Commande[Ad_Nom_Commande[com]], où Ad_Nom_Commande stocke les adresses des commandes com.
Les flags emp sont stockés dans Emp_Commande[com].
Les flags yes/no sont stockés dans Sem_Commande[com].
Les nombres des valeurs sont stockés dans Dim_Commande[com].
Les flags type sont stockés dans Type_Commande[com].

Les valeurs par défaut sont stockées dans Def_Commande[Ad_Def_Commande[com]].
Les nombres de valeurs par défaut sont stockés dans Dim_Commande[com].
Les valeurs actuelles sont stockées dans Val_Commande[Ad_Val_Commande[com]].

Empilement des commandes

Certaines commandes (comme geod) peuvent être empilées avant d´être dépilées (comme end geod). Elles sont empilées dans la liste chainée Liste_Commande. Un WARNING est émis pour plus de 3 commandes empilées.
ini system permet de tout dépiler.

Les messages

       Les messges de l´environnement n (a: interpreteur, b: anyflo, c: application, ...) se trouvent dans les fichiers komn.h sous la forme:
|num: text
num = numéro relatif du message pour l´environnement considéré
text = text du message pouvant contenir:
       \n: retour à la ligne
       \7: ring
       \e: espace
       \t: tabulation

Les nombres des messages sont stockées dans Nb_Message[env] avec env = numéro de l´environnement (0: interpréteur, 1: anyflo, >1: applications).
Les textes des messages sont stockés dans Nom_Message.
Les adresses des des adresses des messages sont stockées dans Ad_Env_Mesage.
Les adresses des messages sont stockées dans ad=Ad_Env_Mesage[env]. Le message (env,mes) est dans Nom_Message[ad[mes]].

Compilation

La fonction à compile p_obj est passée à la fonction compile(struct Objet *p_obj) du fichier compa.c.
Une 1ère passe compile_passe_1(p_obj, p_comp00, end_comp,&debordement) résoud les directives, supprime les commentaires, les espaces et les \n.
Le texte est compilé en instructions dans p_obj->param.
Les variables formelles, statics, autos et locales sont crées (et éventuellement initialisées) dans p_obj->var.
Une 2ème passe parenthèse selon les priorités des opérateurs.
Une 3ème passe ajoute éventuellement des parenthèses dans des expressions mal parenthèsées mais sans ambiguïté.
p_obj->nx,ny,nz,close = nombre de variables formelles, statics, autos et locales.
Les paramètres formels déclarés de type func sont codés:
       (dim,-NOM_FUNC,"name").

Fonctions

Une fonction est défini par un objet p_func de Pile_Fonc:
       p_func->name = nom de la fonction.
       p_func->bloc -> text de la fonction.
       p_func->param -> code compilé.
       p_func->pere -> fonction précédante (0 si c´est la 1ère).
       p_func->fils -> fonction suivante (0 si c´est la dernière).
       p_func->var -> tête vide de la liste chainée des variables formelles, statics, auto, func.
              p_var->fils contient la variable suivante.
Remarque:
       p_obj->local -> liste chainée de fonctions locales si p_obj n´est pas une fonction.

Pile

La pile Pile_Pile est un objet indestructible tête d´une liste chainée d´objets contenant:
indicateur de début de pile: (name, type=FUNC, nx=nombre de paramètres formels empilés) de la fonction appelée.
nx copies des paramètres formels de p_func->var de la fonction appelante.
indicateur
etc..
Pile_NP est le dernier.
Au retour de la fonction ces éléments sont restitués dans p_var et détruits.

Appel d´une fonction

Appel d´une fonction f(p1,p2,...);
Dans la fonction evaluer_fonction(long *p0, long sem_ret) du fichier maca.c:
p0 -> (dim,code,p_func,np)(datas). np = nombre de paramètres d´appel ,dans datas.
code = FUNC_DISK (indeterminée -> chercher sur le disque), CODE_FUNC p_func = p0[2].
P_mac = p_func.
p_var=p_func->var est la liste chainée des paramètres:
       formels (éventuelement complétés par des NIL).
       statics qui conservent leurs valeurs.
       autos qui sont les variables internes à la fonction.
       locaux pour une fonction local.

La pile Pile_Pile est utilisée pour stock de Mac0->var (paramètres de la fonction appelante, rien si l´appel vient de l´interpréteur).
Les éléments suivants sont empilés dans Pile_NP = ++Pointeur_Pile:
1) Une copie indestructible de la fonction appelée (p_func->name et les nombres
de paramètres formels (p_func->nx),
de paramètres statics (p_func->ny),
de paramètres autos (p_func->nz),
et de paramètres locaux (p_func->close).
2) Pointeur_Pile -> objet vide de fin de pile.

Au retour de la fonction ces éléments sont dépilés. Pointeur_Pile = Pile_NP->pere.

Exécution

Le code est exécuté par la fonction interp(buf, p_ev) du fichier esa.c:
buf = (tete) I1, I2, ... end
Ii est une instruction.
Les paramètres d´appel ont été copiés dans les paramètres formels empilés qui sont codées dans les instructions par (type = FORMEL, nx = numéro dans la pile), les autres paramètres peuvent être modifiés.
Les noms "string" sont comparés aux noms des variables p_var de type TYPE_FUNC de la fonction exécutée, si yes "string" est codé (-FUNC,p_var).
Le résultat est évalué dans [p_ev, Fin_ev[.
Retourne 2 si RETURN, < 0 si erreur, sinon 0.

Retour

Le retour est empilé dans [p0, Fin_ev[.
Retourne 2 si RETURN, < 0 si erreur, sinon 0.
Les éléments de la pile contenus entre les 2 indicateurs (func et type=0) sont copiés dans p_func->p_var et sont détruits.

Variables

Variables externes: elles sont stockées dans Pile_Extern.
       name = "nom"
       type_0 = EXTERN
       bloc -> datas

Variables formelles, automatiques et statiques d´une fonction p_func: elles sont stockées dans p_func->var.
       name = "nom"
       type_0 = FORMEL, -A_STATIC, -AUTO, -GLOBALE
       bloc -> datas

Variables formelle de type fonction
       elles sont stockées dans p_func->var.
       name = "nom"
       type_0 = COMMANDE (lors de l´éxecution).
       type_1 = numéro de la commande.

Variables globales de fonctions locales
       elles sont stockées dans Pile_Globale avec num=numéro de l´objet, (env2,type2)=type de l´objet.
       name = "nom"
       type_0 = LOCALE
       bloc -> datas

Instructions

Format d´une instruction: I = (dim,p)
       1) Si dim < 0, p codé sur un mot.
              dim = A_FLOAT: p = float.
              dim = -A_EXTERN: p -> objet de Pile_Extern.
              dim = -A_STATIC, FORMEL: p -> objet de p_obj->var.
              dim = GOTO_L<0: p = incrément relatif de saut.
              dim = COMMANDE<0: p = numéro de cette commande.
              p = INDEFINI < 0: (dim,INDEFINI,num,0)("name") résolu au link en:
                     (CODE_FUNC < 0, p_func) p_func -> objet fonction.
              dim = -FUNC: p -> objet fonction de Pile_Fonc.
              dim = TYPE_FUNC: p -> objet variable fonction.
                     Le link transforme en T=(COMMANDE,com) ou (T=-FUNC,objet)
       2) Si dim > 0: I = dim,type,np,dimp)(datas).
Une fonction est codée comme (CODE_FUNC,p_func) p_func étant un pointeur vers un objet de Pile_Fonc avec:
       p_func->bloc = text de la fonction.
       p_func->param = code compilé.
       p_func->local = liste chainée des variables formelles, statics et locales.
L´appel d´une fonction f est codé comme (dim,INDEFINI,"f") qui sera résolu au link.
Un paramètre formel d´une fonction est codé comme (FORMEL,p_var) p_var étant un pointeur vers un objet de la pile local de cette fonction..
Une variable local d´une fonction est codée comme (VAR_LOC,p_var) p_var étant un pointeur vers un objet de la pile local de cette fonction.
Une variable static d´une fonction est codée comme (-A_STATIC,p_var) p_var étant un pointeur vers un objet de la pile local de cette fonction.
Une constante est codée comme un datas.
Une variable externe est codée comme (VAR_GLB,p_var) p_var étant un pointeur vers un objet de Pile_Extern.
       3) Si dim = 0: fin compilation.

Les boucles for

Première forme:
for(init;cond;inc){...}
compile (FOR1,.)(init;cond;inc){...}
link (FOR0,a1)a0(6,FOR_L1,a2,a3,a4,a5)a1(ini;)a2(cond;)a3(inc){a4...}(goto a0)a5...
exec(FOR0) -> exec(a1): initialisation.
exec(FOR_L1) -> if(exec(a2){exec(a3);goto a4;}else goto a5;
Si condition -> incrémenter et exécuter {...}, sinon continuer.
Deuxière forme:
for(i=a,b,c){...} génère le code:
compile (FOR2,.)(i=a,b,c){...}
link (FOR0,a0),(7,FOR_L2,a,b,a4,a5,c)({...}
exec(FOR0) a=a0: initialisation.
exec(FOR_L2) a+=c, si a n´atteint pas b goto a´4, sinon goto a5.

Boucle while

while(cond){...} génère:
a0(4,WHILE,a1,a2,a3)a1(cond;)a1(ini;)a2{...}(goto a0)a3...
exec(WHILE) -> if(exec(a1))goto a2; else goto a3: ttq cond vraie faire a2 sinon continuer.

switch

switch(ins){case c1:ins1;break;case c2:ins2;...default;insd;} génère:
a0(dim,SWITCH,ai,a1,a2,...,ad,suite)ai(ins;)a1(ins1;goto suite;)a2(ins2;goto suite;) ad(insd);
Remarque:
Ce codage permet des cases quelconques (float, chaines, hybride, instructions exécutables).

Le if

if(cond){ins1;}else {ins2} génère:
(dim,IF,a1,a2,a3)a1(cond;)a2({ins1;}goto a4;)a3(ins2;)a4...
exec(IF) -> if(exec(a1))goto a2;else goto a3;

Link

Les références indéfinies sont résolues:
L´appel d´une fonction "f" donne lieu à une recherche de cette fonction dans Pile_Fonc, en cas d´échec, le fichier "f.func" est recherché dans le dossier de lancement, puis dans le dossier utilisateur et enfin dans le dossier de l´environnement, en cas d´échec il y a sortie en erreur ("fonction f non définie"), sinon ce fichier est chargé, puis compilé. Si de tels indéfinis ont été detectés le link est relancé (normalement avec succès).

Exécution

Le code compilé est interprété très rapidement en C.

Les fichiers

Fonctions        Images        Matrices        Objets        Stocker        Variables

Fonctions

Les fichiers *.func de fonctions en langage anyflo sont en ascii.

Images

Codées selon leur extension (bmp flo jpg tga):
bpm: bitmap
jpg: jpeg
tga: tga
flo:
       xxxxxx yyyyyy c\n: xxxxxx yyyyyy taille en xy, c: code (0: non compressé), 1: compressé). (sur 16 octets)
       rgba rgba ... lise de pixels.

Matrices

pour lire des nb matrices de nx colonnes et ny lignes:
Lire_Matrice_Nb = nb, Lire_Matrice_Nx = nx, Lire_Matrice_Ny = ny

Objets

Les fichiers *.ext ont la structure suivante:
numéro.
name: (dim,"nom") si dim == 1 pas de nom.
type: type_0, type_1, type_2, type_3, type_type.
leader
géometrie: nx, ny, nz, close, inc, validate.
Propriétés:
       (dim,MULT,dim0,n,e1,c1,e2,c2,...,en,cn)(datas) datas=(dim,type,np,dimp)(valeurs)
bloc param:
       (42+DIM_TTE, A_FLOAT, 42, 1)(x,y,z,cx,cy,cz,a,xa,ya,za, mat, mat2)

Stocker

La commande stock obj empile dans Pile_Stocker des objets de type_0 obj et de bloc un datas (dim,MULT,n,0)(p1,p2,...):
       name("N.ext")
       ext("nD") le nom du fichier est alors Nnum.ext (num sur n chiffres, 4 par défaut).
       number(num) incrémenté à chaque pas de l´animation
       period(p) pour une animation d´ordre supérieur.
Pour une image:
       dim(dimx,dimy)
       win(x1,y1,x2,y2)
       format("RGB")

Variables

La commande write var("v")name("name") write dans le fichier v.var les valeurs de la variable extern v sous la forme:
dim_name: dimension du name + 1 (en longs).
write le bloc de l´objet.
si dim_name!=1, gare le nom sur dim_name longs.

Débuger

Débuger une ligne de commandes

Si la commande à débuger commence par une commande de interpréteur, positionner un break sur la ligne COM: de la fonction EVALUER_0 du fichier esa.cCOM est le nom de la commande.
Si la commande à débuger commence par une commande d´anyflo, positionner un break sur la ligne COM: de la fonction EVALUER_1 du fichier exeb.cCOM est le nom de la commande.

Tracer une erreur

Les messages (env,mes) sont émis par la fonction message(env,mes) du fichier mesa.c, placer un break dans cette fonction pour tracer une erreur.

Temps réel

Le problème
Les structures

Le problème

Les structures d´anyflo sont dynamiques et ne sont donc pas limitées en nombre d´effets, mais ceci est au détriment du temps réel qui éxige des structures figées rapidement accessibles. C´est pourquoi un compilateur de datas prenant, en entrée, les structures très générales d´anyflo et donnant, en sortie, des structures compactes et figées compatibles avec les fonction d´OpenGL et de DirectX permet, de façon transparente pour l´utilisateur, le temps réel.

Les structures

def_interacb.h.

Transfert

Files structure

Level 0

cours

Level 1

bret

anyflo.15.2

Level 2

env

Level 3

env_eng
env_fra

read write add

permet de concaténer des fichiers en un fichier unique et de les déconcaténer:
anyflo/env/concatene.func:
       le dossier ext doit exister
              *.c sont concaténés dans ext/c.add
              *.cpp sont concaténés dans ext/cpp.add
              *.h sont concaténés dans ext/h.add
anyflo/env/deconcatene.func:
       les fichiers ext/c.add, ext/cpp.add et ext/h.add, doivent exister ainsi que le dossier deconcatene.
              c.add est déconcaténé en decontatene/*.c
              cpp.add est déconcaténé en /*.cpp

              h.add est déconcaténé en decontatene/*.h
Les noms des dossiers peuvent être changés dans les fonctions.]

read write inclu

permet de coder et décoder des fichiers.
anyflo/env/src_ext.func:
       src/*.[c cpp h] sont codés en src_ext/[c cpp h].ext
Remarque:
seulement l´extension et le texte sont codés, il est donc nécessaire de construire un dossier spécial pour chaque extension (dans ce cas: c, cpp et h).
anyflo/env/ext_src.func:
       src_ext/[c cpp h].ext sont décodés en ext_src/*.[c cpp h]
Les noms des dossiers peuvent être changés dans les fonctions.