

Die Extensions ARB_vertex_program und ARB_fragment_program sind auch weiterhin
ntzlich und deshalb habe ich eine zustzliche Sprache entwickelt, die direkt
auf diesen Extensions aufsetzt und an Pascal angelehnt ist. Es gibt die zwei
Klassen TFragmentProgram und TVertexProgram, die fr die jeweilige Extension
bersetzen. Der Quelltext wird als Stream im Constructor bergeben und bei Fehlern
wird eine Exception ausgelst. Das ARB Program kann man dann aus der Eigentschaft
Source auslesen und mit der Funktion GetSymbolOffset kann man die Position einer
Variable abfragen.

Alle Programme bestehen aus optionalen Deklarationsblcken und einem anschlieenden
Begin End Block. Im var Block werden temporre Variablen deklariert. Im Param Block
kann man die Program Parameter definieren und im Varying Block wird die Schnittstelle
 zwischen Vertex und Fragment Program festgelegt.

Beispiel:

var
 a,b,c;
param
 param1,params[10];
varying
 texcoord;

Es gibt keine speziellen Datentypen, weil alles Vektoren sind. Im Param Block kann
man aber Arrays definieren, indem man die Anzahl der Elemente in Klammern hinter
den Bezeichner schreibt. Der Begin End Block besteht aus einer Reihe von Anweisungen.
Es gibt die Zuweisung mit ":=", with, if then else und discard. Discard ist nur in
Fragmentprogrammen erlaubt und sorgt dafr, da dieses Fragment nicht gezeichnet wird.
Es knnen alle Variablen der jeweiligen ARB Erweiterung benutzt werden. Ein ganz
einfaches Program wre z.B.


begin
result.position:=MatrixMult4(state.matrix.mvp,vertex.position);
result.color:=vertex.color;
result.texcoord[0]:=vertex.texcoord[0];
end;

Die folgende Kombination von Vertex und Fragment Program berechnet Tangent Space Blinn Bumpmapping:

Fragment Program:

param
 LightSize,LightColor,LightSpecular;
varying
 texcoord,LightVec,LightVec2,ViewVec;
var
 color,halfvec,specular,bump;
begin
bump:=NormalMap(3,texcoord);
color:=sat(dot3(bump,normalize(LightVec)))*Texture2D(0,texcoord)*LightColor;
color:=sat(dot3(bump,normalize(LightVec)))*color*LightColor;
halfvec:=normalize(LightVec+ViewVec);
specular:=power(sat(dot(halfvec,bump)),8)*LightSpecular*Texture2D(4,texcoord);
result.color:=(color+specular)*lightatten(LightVec2,LightSize)*bump.w;
end;


Vertex Program:

param
 LightPos,CamPos;
varying
 texcoord,LightVec,LightVec2,ViewVec;
var
 lv;
begin
result.position:=MatrixMult4(state.matrix.mvp,vertex.position);
result.color:=vertex.color;
texcoord:=vertex.attrib[8];
lv:=LightPos-vertex.position;
LightVec:=MatrixMult3(Matrix(vertex.attrib[6],cross(vertex.attrib[6],vertex.attrib[2]),vertex.attrib[2]),lv);
LightVec2:=lv;
lv:=CamPos-vertex.position;
ViewVec:=MatrixMult3(Matrix(vertex.attrib[6],cross(vertex.attrib[6],vertex.attrib[2]),vertex.attrib[2]),lv);
end;[/code]

Es gibt folgende Operatoren:
+,-,*,/,
=,<>,<=,<,>,>=
NOT,AND,OR,XOR

In beiden Program Typen sind folgenden Funktionen erlaubt:
min(x,y)
Minimum von x und y

max(x,y)
Maximum von x und y

abs(x)
Absolutwert

cross(x,y)
Kreuzprodukt

dot(x,y)dot3(x,y)
3 Komponenten Skalarprodukt

dot4(x,y)
4 Komponenten Skalarprodukt

doth(x,y)
 Homogeneous Dot Product

floor(x)
 grter ganzer Integer, der kleiner als x ist

frac(x)
 Gibt den Realteil von x zurck.
exp2(x)
 Berechnet 2 hoch x

log2(x)
 Berechnet den 2er Logarithmus von x

power(x,y)
 =x hoch y

normalize(x)
 Normalisiert x

length(x)
 Berechnet die Lnge von x

dist(x,y)
 Berechnet die Entfernung von x und y

sqr(x)
 =x*x

sqrt(x)
 Gibt die Wurzel der ersten Komponente von x zurck

rsqrt(x)
 Berechnet den Kehrwert der Wurzel vor der ersten Komponente von x 

matrixmult3(matrix,x)
 Multipliziert x mit der 3*3 Matrix

matrixmult4(matrix,x)
 Multipliziert x mit der 4*4 Matrix

vector(x,y,z,w)
 Gibt den Vektor aus den Parametern zurck

matrix(row1,row2,row3[,row4]);
 Gibt eine Matrix aus den Paramtervektoren zurck

clamp(x,min,max)
 =max(min,min(x,max))

sat(x)
 =clamp(x,0,1), wird in Fragment Programmen speziell optimiert

reflect(x,y)
 Berechnet den Refletionsvektor von x an y

sin(x)
 Berechnet den Sinus von x

cos(x)
 Berechnet den Cosinus von x

pi
 =PI

lightatten(vec,size)
 Berechnet die Lichthelligkeit einer Lichtquelle der Gre size an dem  Punkt vec, der relativ zur Lichtquelle angegeben wird.

Die folgenden Funktionen gelten nur fr Fragment Programme

Texture1D(tex,coord[,bias]);
Texture2D(tex,coord[,bias]);
Texture3D(tex,coord[,bias]);
TextureCubeMap(tex,coord[,bias]);
TextureRect(tex,coord[,bias]);
 Die Funktionen lesen jeweils an der angegebenen Stelle aus der Texture tex. Tex ist die Nummer der Textureeinheit, aus der man lesen mchte.
Optional kann auch noch ein LOD Bias angegeben werde.

Texture1DProj(tex,coord);
Texture2DProj(tex,coord);
Texture3DProj(tex,coord);
TextureCubeMapProj(tex,coord);
TextureRectProj(tex,coord);
 Die Funktionen lesen jeweils an der Stelle coord/coord.w aus der Texture tex.

NormalMap(tex,coord[,bias]);
 Mit der Funktion NormalMap kann eine Normalmap gelesen und entpackt werden. 

