Niveau 3: manuel programmeur
|
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 ",".
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.
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, gen;
/* 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.
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
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..
é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
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.
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:
param -> bloc de la matrice = (58,A_FLOAT,58,1)mat
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 est une structure dynamique non fixée à la compilation.
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
[0,12]: transformations SET_GET_TRANSF(p_obj) (13 floats)
[0,2] = AD_X,AD_Y,AD_Z: displacement
[3,5] = AD_DIL_X,AD_DIL_Y,AD_DIL_Z: dilatation
[6,9] = AD_ROT_A,AD_AXIS_X,AD_AXIS_Y,AD_AXIS_Z: rota,axe_x,axe_y,axez
[10,12] = AD_ROT_X,AD_ROT_Y,AD_ROT_Z: rotx,roty,rotz
[13,28] = [AD_MAT,AD_MAT+15] (AD_MAT=13), matrice 4*4 SET_GET_MATRIX(p_obj) (16 floats)
calculée depuis (x,y,z, cx,cy,cz, a, ax,ay,az) par
glGetFloatv() par un affichage virtuel (fonction CAL_MATRIX() du fichier affb.c:
[29,41]: added transformations ajoutées SET_GET_ADD(p_obj) (13 floats)
[29,31] = AD_X0,AD_Y0,AD_Z0: x0,y0,z0
[32,34] = AD_DIL_X0,AD_DIL_Y0,AD_DIL_Z0: cx0,cy0,cz0
[35,38] = AD_ROT_A0,AD_AXIS_X0,AD_AXIS_Y0,AD_AXIs_z0: rota0,axis_x0,axis_y0,axis_z0
[39,41] = AD_ROT_X0,AD_ROT_Y0,AD_ROT_Z0: ax0,ay0,az0
DIM_MAT=42 = 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 ima jpg tga):
bpm: bitmap
ima, image bitmaps (séquence):
header size: taille de l´en tête (7 longs)
nx: nombre de lignes
ny: nombre de colonnes
nz: nombre de bitmaps
nt: taille des données (4: rgba)
inc: nombre de bits du codage: 8
code: 0 non compressé, 1 compressé.
buf+header size -> pixels (rgba)
jpg: jpeg
tga: tga
flo: image anyflo compressé
(xxxxxx,yyyyyy,c): nx, ny, code
R, G, B, A
X=0,np,x: np fois la même valeur x
X=1,np,x1,x2,...,xnp: np valeurs x1,x2,...,xnp
Matrices
pour lire des nb matrices de nx colonnes et ny lignes:
Lire_Matrice_Nb = nb, Lire_Matrice_Nx = nx, Lire_Matrice_Ny = ny
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 l´ interpréteur, positionner un break sur la ligne COM: de la fonction
EVALUER_0 du fichier esa.c où COM 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.c où COM 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
cours
bret
anyflo.15.2
env
env_eng
env_fra
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.]
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.
Compléments
texture directory
struct Texture_Directory
{
char *dir; /* directory name */
long file; /* 0: directory, 1: files */
long type; /* image, directory */
long var; /* >=0: variable, <0: invariable */
long directory; /* directory number */
long nb_name; /* number of files */
long num1; /* first */
char *name; /* file name */
struct Texture_Directory *father;
struct Texture_Directory *son;
};
Texture_Directory0 est une liste chainée construite par:
Dir_File="dir1\ndir2...";
Texture_NP=NP(Dir_File);
texture directory(Dir_File{0})read(Read);
for(i=1,Texture_NP-1)texture directory(Dir_File{i})add;
où diri sont des dossiers contenant des fichiers *.ima
Nb_File=texture NP; est le nombre d´images.
typedef struct {
long OK, debug;
long cpt, ni, bit1, inc_bit1, number1, nz1, bit2, inc_bit2, number2, nz2;
long *law;
float fbit1, fbit2, speed, type1, type2;
long var; /* >=0: variable, <0: invariable */
long directory; /* directory number */
} Interpol_Texture;
interaction read
interaction read image(num)directory(dir)time(t)dim(nx0,ny0)bitmap
Objet p_obj de Pile_Interaction:
name -> dir = "dir1;dir2;...;dirn"
fermer = memory (0: bitmaps lues à chaque frame, 1: images en mémoire)
gen = nb_images (nombre d´images pour l´option memory=0)
struct IRI:
debug = 0,1,2: pas d´information, nom fichier, numéro bitmap
nx0, ny0, nx, ny, nz = dimensoins des images
time_dir = time(directory), cpt_dir [0,timr_dir[
np_dir = nombre de dossiers, num_dir [0,np_dir[
nb_ima = nombre d´images
bitmap = numéro de la bitmap [0,nz[
num_ima = num
image = numéro de l´image courante
p_image -> obj_image
fp = FILE *
EXEC_INTERACTION() read image(id)name(dir,im)bitmap(bit), cpt++; if(cpt >= nz) end.