AGAL-bytecode-indeling

AGAL-bytecode moet de Endian.LITTLE_ENDIAN-indeling gebruiken.

Bytecodeheader

AGAL-bytecode moet beginnen met een uit zeven bytes bestaande header:

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

Offset (bytes)	Grootte (bytes)	Naam	Beschrijving
0	1	magic	moet 0xa0 zijn
1	4	versie	moet 1 zijn
5	1	shadertype-id	moet 0xa1 zijn
6	1	shadertype	0 voor een hoekpuntprogramma; 1 voor een fragmentprogramma

Tokens

De header wordt onmiddellijk gevolgd door een aantal tokens. Elk token is 192 bits (24 bytes) groot en heeft altijd de volgende indeling:

[opcode][destination][source1][source2 of sampler]

Niet elke op-code gebruikt al deze velden. Niet-gebruikte velden moet worden ingesteld op 0.

Bewerkingscodes

Het [opcode]-veld is 32 bits groot en kan een van de volgende waarden hebben:

Naam	Op-code	Bewerking	Beschrijving
mov	0x00	move	gegevens verplaatsen van bron1 naar doel, componentsgewijs
add	0x01	add	doel = bron1 + bron2, componentsgewijs
sub	0x02	subtract	doel = bron1 - bron2, componentsgewijs
mul	0x03	meerdere	doel = bron1 * bron2, componentsgewijs
div	0x04	delen	doel = bron1 / bron2, componentsgewijs
rcp	0x05	wederkerig	doel = 1/bron1, componentsgewijs
min	0x06	minimum	doel = minimum(bron1,bron2), componentsgewijs
max	0x07	maximum	doel = maximum(bron1,bron2), componentsgewijs
frc	0x08	fractioneel	doel = bron1 - (zwevend)ondergrens(bron1), componentsgewijs
sqt	0x09	vierkantswortel	doel = sqrt(bron1), componentsgewijs
rsq	0x0a	wederkerige vierkantswortel	doel = 1/sqrt(bron1), componentsgewijs
pow	0x0b	macht	doel = pow(bron1,bron2), componentsgewijs
log	0x0c	logaritme	doel = log_2(bron1), componentsgewijs
exp	0x0d	exponentieel	doel = 2^bron1, componentsgewijs
nrm	0x0e	normalize	doel = normalize(bron1), componentsgewijs (produceert alleen een resultaat met drie componenten, het doel moet worden gemaskeerd in .xyz of minder)
sin	0x0f	sinus	doel = sin(bron1), componentsgewijs
cos	0x10	cosinus	doel = cos(bron1), componentsgewijs
crs	0x11	kruisproduct	doel.x = bron1.y * bron2.z - bron1.z * bron2.y doel.y = bron1.z * bron2.x - bron1.x * bron2.z doel.z = bron1.x * bron2.y - bron1.y * bron2.x (produceert alleen een resultaat met 3 componenten, het doel moet worden gemaskeerd in .xyz of minder)
dp3	0x12	scalair product	doel = bron1.xbron2.x + bron1.ybron2.y + bron1.z*bron2.z
dp4	0x13	scalair product	doel = bron1.xbron2.x + bron1.ybron2.y + bron1.zbron2.z + bron1.wbron2.w
abs	0x14	absoluut	doel = abs(bron1), componentsgewijs
neg	0x15	negatief maken	doel = -bron1, componentsgewijs
sat	0x16	satureren	doel = maximum(minimum(bron1,1),0), componentsgewijs
m33	0x17	matrix vermenigvuldigen 3x3	doel.x = (bron1.x * bron2[0].x) + (bron1.y * bron2[0].y) + (bron1.z * bron2[0].z) doel.y = (bron1.x * bron2[1].x) + (bron1.y * bron2[1].y) + (bron1.z * bron2[1].z) doel.z = (bron1.x * bron2[2].x) + (bron1.y * bron2[2].y) + (bron1.z * bron2[2].z) (produceert alleen een resultaat met 3 componenten, het doel moet worden gemaskeerd in .xyz of minder)
m44	0x18	matrix vermenigvuldigen 4x4	doel.x = (bron1.x * bron2[0].x) + (bron1.y * bron2[0].y) + (bron1.z * bron2[0].z) + (bron1.w * bron2[0].w) doel.y = (bron1.x * bron2[1].x) + (bron1.y * bron2[1].y) + (bron1.z * bron2[1].z) + (bron1.w * bron2[1].w) doel.z = (bron1.x * bron2[2].x) + (bron1.y * bron2[2].y) + (bron1.z * bron2[2].z) + (bron1.w * bron2[2].w) doel.w = (bron1.x * bron2[3].x) + (bron1.y * bron2[3].y) + (bron1.z * bron2[3].z) + (bron1.w * bron2[3].w)
m34	0x19	matrix vermenigvuldigen 3x4	doel.x = (bron1.x * bron2[0].x) + (bron1.y * bron2[0].y) + (bron1.z * bron2[0].z) + (bron1.w * bron2[0].w) doel.y = (bron1.x * bron2[1].x) + (bron1.y * bron2[1].y) + (bron1.z * bron2[1].z) + (bron1.w * bron2[1].w) doel.z = (bron1.x * bron2[2].x) + (bron1.y * bron2[2].y) + (bron1.z * bron2[2].z) + (bron1.w * bron2[2].w) (produceert alleen een resultaat met 3 componenten, het doel moet worden gemaskeerd in .xyz of minder)
kil	0x27	verwijderen/negeren (alleen fragmentshader)	Als de enige scalaire broncomponent minder is dan nul, wordt het fragment genegeerd en niet naar de framebuffer getekend. (Het doelregister moet volledig ingesteld zijn op 0).
tex	0x28	structuurvoorbeeld (alleen fragmentshader)	doel is gelijk aan laden van bron2 van structuur op bron1 van coördinaten. In dit geval moet bron2 de samplerindeling hebben.
sge	0x29	instellen als groter of gelijk aan	doel = bron1 >= bron2 ? 1 : 0, componentsgewijs
slt	0x2a	instellen als kleiner dan	doel = bron1 < bron2 ? 1 : 0, componentsgewijs
seq	0x2c	instellen indien gelijk	doel = bron1 == bron2 ? 1 : 0, componentsgewijs
sne	0x2d	instellen indien niet gelijk	doel = bron1 != bron2 ? 1 : 0, componentsgewijs

Indeling van het veld Doel

Het veld [doel] is 32 bits groot:

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

T = Registertype (4 bits)

M = Schrijfmasker (4 bits)

N = Registernummer (16 bits)

- = niet-gedefinieerd, moet 0 zijn

Indeling van het veld Bron

Het veld [bron] is 64 bits groot:

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

D = Direct=0/Indirect=1 voor direct worden Q en I genegeerd, 1 bit

Q = Indexregistercomponent selecteren (2 bits)

I = Indexregistertype (4 bits)

T = Registertype (4 bits)

S = Swizzle (8 bits, 2 bits per component)

O = Indirecte offset (8 bits)

N = Registernummer (16 bits)

- = niet-gedefinieerd, moet 0 zijn

Indeling van het veld Sampler

Het tweede bronveld voor de tex-op-code moet de [sampler]-indeling van 64 bits groot hebben:

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

N = Samplerregisternummer (16 bits)

B = Structuur-LOD-afwijking (Level-Of-Detail), geheel getal met teken, schalen factor 8. De gebruikte zwevende-kommawaarde is b/8.0 (8 bits)

T = Registertype, moet 5 zijn, Sampler (4 bits)

F = Filter (0=dichtstbijzijnd,1=lineair) (4 bits)

M = Mipmap (0=uitschakelen,1=dichtstbijzijnd, 2=lineair)

W = Insluiten (0=vastzetten,1=herhalen)

S = Speciale-markeringbits (moet 0 zijn)

D = Dimensie (0=2D, 1=Kubus)

Programmaregisters

De volgende registertypen zijn gedefinieerd. Gebruik de vermelde waarde om een registertype op te geven in de velden van een token:

Naam	Waarde	Aantal per fragmentprogramma	Aantal per hoekpuntprogramma	Gebruik
Attribuut	0	n.v.t.	8	Hoekpuntshaderinvoer; lezen uit een hoekpuntbuffer die is opgegeven met Context3D.setVertexBufferAt().
Constante	1	28	128	Shaderinvoer; ingesteld met de Context3D.setProgramConstants()-functies.
Tijdelijke opslag	2	8	8	Tijdelijk register voor berekening, niet toegankelijk buiten programma.
Uitvoer	3	1	1	Shaderuitvoer: in een hoekpuntprogramma is de uitvoer de positie van de clipruimte. In een fragmentprogramma heeft de uitvoer de vorm van een kleur.
Variabel	4	8	8	Breng geïnterpoleerde gegevens over tussen hoekpunt- en fragmentshaders. De variabele-registers uit het hoekpuntprogramma worden als invoer toegepast op het fragmentprogramma. Waarden worden geïnterpoleerd op basis van de afstand tot de hoekpunten van de driehoek.
Sampler	5	8	n.v.t.	Fragmentshaderinvoer; lezen vanuit een structuur die is opgegeven met Context3D.setTextureAt().