Pseudo-code binaire AGAL

Le pseudo-code AGAL doit utiliser le format Endian.LITTLE_ENDIAN.

En-tête du pseudo-code

Le pseudo-code AGAL doit commencer par un en-tête de 7 octets :

A0 01000000 A1 00 -- for a vertex program 
A0 01000000 A1 01 -- for a fragment program

Décalage (octets)	Taille (octets)	Nom	Description
0	1	magic	doit être 0xa0
1	4	version	doit être 1
5	1	shader type ID	doit être 0xa1
6	1	shader type	0 pour un programme de sommets, 1 pour un programme de fragments

Jetons

L’en-tête est immédiatement suivi par un nombre quelconque de jetons. Chaque jeton est de 192 bits (24 octets) et a toujours le format suivant :

[opcode][destination][source1][source2 or sampler]

Tous les codes d’opération n’utilisent pas l’ensemble de ces champs. Les champs non utilisés doivent être définis sur 0.

Codes d’opération

Le champ [opcode] est de 32 bits et peut prendre l’une des valeurs suivantes :

Nom	Code d’op.	Opération	Description
mov	0x00	déplacer	déplacer les données à partir de source1 vers destination, au niveau du composant
add	0x01	ajouter	destination = source1 + source2, au niveau du composant
sub	0x02	soustraire	destination = source1 - source2, au niveau du composant
mul	0x03	multiplier	destination = source1 * source2, au niveau du composant
div	0x04	diviser	destination = source1 / source2, au niveau du composant
rcp	0x05	réciproque	destination = 1/source1, au niveau du composant
min	0x06	minimum	destination = minimum(source1,source2), au niveau du composant
max	0x07	maximum	destination = maximum(source1,source2), au niveau du composant
frc	0x08	fractionnaire	destination = source1 - (float)floor(source1), au niveau du composant
sqt	0x09	racine carrée	destination = sqrt(source1), au niveau du composant
rsq	0x0a	racine réciproque	destination = 1/sqrt(source1), au niveau du composant
pow	0x0b	puissance	destination = pow(source1,source2), au niveau du composant
log	0x0c	logarithme	destination = log_2(source1), au niveau du composant
exp	0x0d	exponentiel	destination = 2^source1, au niveau du composant
nrm	0x0e	normaliser	destination = normalize(source1), au niveau du composant (produit uniquement un résultat de composant 3, la destination doit être masquée sur .xyz ou inférieur)
sin	0x0f	sinus	destination = sin(source1), au niveau du composant
cos	0x10	cosinus	destination = cos(source1), au niveau du composant
crs	0x11	produit vectoriel	destination.x = source1.y * source2.z - source1.z * source2.y destination.y = source1.z * source2.x - source1.x * source2.z destination.z = source1.x * source2.y - source1.y * source2.x (produit uniquement un résultat de composant 3, la destination doit être masquée sur .xyz ou inférieur)
dp3	0x12	produit scalaire	destination = source1.xsource2.x + source1.ysource2.y + source1.z*source2.z
dp4	0x13	produit scalaire	destination = source1.xsource2.x + source1.ysource2.y + source1.zsource2.z + source1.wsource2.w
abs	0x14	absolu	destination = abs(source1), au niveau du composant
neg	0x15	inverser	destination = -source1, au niveau du composant
sat	0x16	saturer	destination = maximum(minimum(source1,1),0), au niveau du composant
m33	0x17	multiplier la matrice 3x3	destination.x = (source1.x * source2[0].x) + (source1.y * source2[0].y) + (source1.z * source2[0].z) destination.y = (source1.x * source2[1].x) + (source1.y * source2[1].y) + (source1.z * source2[1].z) destination.z = (source1.x * source2[2].x) + (source1.y * source2[2].y) + (source1.z * source2[2].z) (produit uniquement un résultat de composant 3, la destination doit être masquée sur .xyz ou inférieur)
m44	0x18	multiplier la matrice 4x4	destination.x = (source1.x * source2[0].x) + (source1.y * source2[0].y) + (source1.z * source2[0].z) + (source1.w * source2[0].w) destination.y = (source1.x * source2[1].x) + (source1.y * source2[1].y) + (source1.z * source2[1].z) + (source1.w * source2[1].w) destination.z = (source1.x * source2[2].x) + (source1.y * source2[2].y) + (source1.z * source2[2].z) + (source1.w * source2[2].w) destination.w = (source1.x * source2[3].x) + (source1.y * source2[3].y) + (source1.z * source2[3].z) + (source1.w * source2[3].w)
m34	0x19	multiplier la matrice 3x4	destination.x = (source1.x * source2[0].x) + (source1.y * source2[0].y) + (source1.z * source2[0].z) + (source1.w * source2[0].w) destination.y = (source1.x * source2[1].x) + (source1.y * source2[1].y) + (source1.z * source2[1].z) + (source1.w * source2[1].w) destination.z = (source1.x * source2[2].x) + (source1.y * source2[2].y) + (source1.z * source2[2].z) + (source1.w * source2[2].w) (produit uniquement un résultat de composant 3, la destination doit être masquée sur .xyz ou inférieur)
kil	0x27	tuer/supprimer (shader de fragments uniquement)	Si le composant source scalaire unique est inférieur à zéro, le fragment est supprimé et non dessiné dans le tampon d’images. (Le registre de destination doit être défini sur tous les 0)
tex	0x28	échantillon de texture (shader de fragments uniquement)	destination équivaut à charger depuis la texture source2 aux coordonnées source1. Dans ce cas, source2 doit être au format de l’échantillonneur.
sge	0x29	définir si supérieur ou égal à	destination = source1 >= source2 ? 1 : 0, au niveau du composant
slt	0x2a	définir si inférieur ou égal à	destination = source1 < source2 ? 1 : 0, au niveau du composant
seq	0x2c	définir si égal à	destination = source1 == source2 ? 1 : 0, au niveau du composant
sne	0x2d	définir si non égal à	destination = source1 != source2 ? 1 : 0, au niveau du composant

Format du champ Destination

Le champ [destination] est de 32 bits :

31.............................0 
----TTTT----MMMMNNNNNNNNNNNNNNNN

T = type de registre (4 bits)

M = masque d’écriture (4 bits)

N = numéro de registre (16 bits)

- = non défini, doit être 0

Format du champ Source

Le champ [source] est de 64 bits :

63.............................................................0 
D-------------QQ----IIII----TTTTSSSSSSSSOOOOOOOONNNNNNNNNNNNNNNN

D = direct=0/indirect=1 pour direct Q et I sont ignorés, 1 bit

Q = sélection du composant du registre d’index (2 bits)

I = type de registre d’index (4 bits)

T = type de registre (4 bits)

S = réagencement des données en surface (8 bits, 2 bits par composant)

O = décalage indirect (8 bits)

N = numéro de registre (16 bits)

- = non défini, doit être 0

Format du champ Sampler

Le deuxième champ source correspondant au code d’opération tex doit être au format [sampler], qui est de 64 bits :

63.............................................................0 
FFFFMMMMWWWWSSSSDDDD--------TTTT--------BBBBBBBBNNNNNNNNNNNNNNNN

N = numéro de registre de l’échantillonneur (16 bits)

B = valeur de niveau de détail de la texture, entier signé, échelle par 8. La valeur à virgule flottante utilisée est b/8.0 (8 bits)

T = type de registre, doit être 5, Sampler (4 bits)

F = filtre (0=le plus proche,1=linéaire) (4 bits)

M = mipmap (0=désactivé,1=le plus proche, 2=linéaire)

W = enveloppe (0=verrouillage,1=répétition)

S = Bits d’indicateurs spéciaux (doivent être 0)

D = dimension (0=2D, 1=Cube)

Registres de programme

Les types de registres suivants sont définis : Utilisez la valeur répertoriée pour spécifier un type de registre dans les champs d’un jeton :

Nom	Valeur	Nombre par programme de fragments	Nombre par programme de sommets	Utilisation
Attribut	0	sans objet	8	Entrée de shader de sommets ; à lire à partir d’un tampon de sommets spécifié à l’aide de Context3D.setVertexBufferAt().
Constante	1	28	128	Entrée de shader ; à définir à l’aide de la famille de fonctions Context3D.setProgramConstants().
Temporaire	2	8	8	Registre temporaire pour le calcul, non accessible en dehors du programme.
Sortie	3	1	1	Sortie de shader : dans un programme de sommets, la sortie correspond à la position de l’espace du clip ; dans un programme de fragments, la sortie est une couleur.
Variable	4	8	8	Transférez les données interpolées entre les shaders de sommets et de fragments. Les registres de variables du programme de sommets sont appliqués en tant qu’entrée au programme de fragments. Les valeurs sont interpolées en fonction de la distance par rapport aux sommets du triangle.
Echantillonneur	5	8	sans objet	Entrée de shader de fragments ; à lire à partir d’une texture spécifiée à l’aide de Context3D.setTextureAt().