- program Test;
- uses arb_vertex_program;
- const
- mvp:array[0..3] of vector=state.matrix.mvp;
- var
- pos:vector;
- begin
- pos:=vec_matrixmult(vertex.position,mvp[
- 0]);
- result.position:=pos;
- end.
Beitrag von Lars aus technischen Gründen von mir gepostet:
Der Konverter von fxPascal nach der OpenGL Shading Language ist schon sei längerem fertig, aber es gibt ja noch keine Treiber um das Program ausführlich zu testen.
Die Extensions ARB_vertex_program und ARB_fragment_program sind auch weiterhin nützlich und deshalb habe ich eine zusätzliche Sprache entwickelt, die direkt auf diesem Extensions aufsetzt und an Pascal angelehnt ist. Es gibt die zwei Klassen TFragmentProgram und TVertexProgram, die für die jeweilige Extension übersetzen und auch optimieren. Der Quelltext wird als Stream im Constructor übergeben und bei Fehlern wird eine Exception ausgelöst. 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 Deklarationsblöcken und einem anschließenden Begin End Block. Im var Block werden temporäre 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:
Code:
- 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 dafür, daß dieses Fragment nicht gezeichnet wird.
Es können alle Variablen der jeweiligen ARB Erweiterung benutzt werden. Ein ganz einfaches Program wäre z.B.
Code:
- 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:
Code:
- 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
Code:
- 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;
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)
größter ganzer Integer, der kleiner als x ist
frac(x)
Gibt den Realteil von x zurück.
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 Länge 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 zurück
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 zurück
matrix(row1,row2,row3[,row4]);
Gibt eine Matrix aus den Paramtervektoren zurück
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 Größe size an dem Punkt vec, der relativ zur Lichtquelle angegeben wird.
Die folgenden Funktionen gelten nur für 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 möchte.
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.
| Dateianhänge: |
passhader.zip [15.72 KiB]
641-mal heruntergeladen |