aboutsummaryrefslogtreecommitdiffstats
path: root/demos
diff options
context:
space:
mode:
Diffstat (limited to 'demos')
-rwxr-xr-xdemos/MiscDemos/TestListener.java748
-rw-r--r--demos/gltestperf.java871
-rw-r--r--demos/natives/x11/gltestperf.c580
-rw-r--r--demos/natives/x11/xfont.c195
-rwxr-xr-xdemos/natives/x11/xfont.sh9
5 files changed, 2403 insertions, 0 deletions
diff --git a/demos/MiscDemos/TestListener.java b/demos/MiscDemos/TestListener.java
new file mode 100755
index 0000000..6fbb361
--- /dev/null
+++ b/demos/MiscDemos/TestListener.java
@@ -0,0 +1,748 @@
+import java.awt.*;
+import gl4java.*;
+import gl4java.awt.*;
+import gl4java.drawable.*;
+
+/** Tests the GLComponentFactory/GLEventListener mechanism via a port
+ of the OpenGL logo applet. */
+
+public class TestListener implements GLEventListener, GLEnum {
+
+ GLFunc gl;
+ GLUFunc glu;
+
+ static final int RAND_MAX = 100;
+
+ /* some math.h's don't define M_PI */
+ static final float M_PI = 3.14159265359f;
+
+ static final int ACC = 8;
+ static final int ACC2 = 16;
+ static final int ACC3 = 48;
+ static final int ACC4 = 24;
+ static final float THLD = 0.6f;
+ static final float THLD2 = 0.8f;
+
+ int angle, rotating;
+
+ float TRANS[][];
+ float ROTAXIS[][];
+ float ROT[];
+
+ float char_El[][][];
+ float normal_El[][][];
+
+ float char_O[][][];
+ float normal_O[][][];
+
+ float char_P[][][];
+ float normal_P[][][];
+
+ float char_G[][][];
+ float normal_G[][][];
+
+ float accSIN[], accCOS[];
+
+ float difmat4[] = { 0.425f, 0.570f, 0.664f, 1.0f };
+ float difamb4[] = { 0.425f, 0.570f, 0.664f, 1.0f };
+ float matspec4[] = { 0.174f, 0.174f, 0.174f, 1.0f };
+
+ float lightpos[] = { 1.0f, 1.0f, 1.0f, 0.0f };
+ float lightamb[] = { 0.3f, 0.3f, 0.3f, 1.0f };
+ float lightdif[] = { 0.8f, 0.8f, 0.8f, 1.0f };
+ float speed=0f, progress = 1f;
+
+ public void init(GLDrawable drawable) {
+ gl = drawable.getGL();
+ glu = drawable.getGLU();
+
+ /* here we should add and initialize our JAVA components */
+ TRANS = new float[7][3];
+ ROTAXIS = new float[7][3];
+ ROT = new float[7];
+
+ char_El=new float[ACC3+1][ACC+1][3];
+ normal_El=new float[ACC3+1][ACC+1][3];
+
+ char_O=new float[ACC4][ACC+1][3];
+ normal_O=new float[ACC4][ACC+1][3];
+
+ char_P=new float[ACC2][ACC+1][3];
+ normal_P=new float[ACC2][ACC+1][3];
+
+ char_G=new float[ACC4][ACC+1][3];
+ normal_G=new float[ACC4][ACC+1][3];
+
+ accSIN=new float[ACC+1];
+ accCOS=new float[ACC+1];
+
+ randomize();
+
+ gl.glShadeModel (GL_SMOOTH);
+ gl.glEnable(GL_DEPTH_TEST);
+ gl.glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
+ gl.glLightfv(GL_LIGHT0, GL_AMBIENT, lightamb);
+ gl.glLightfv(GL_LIGHT0, GL_DIFFUSE, lightdif);
+ gl.glEnable(GL_LIGHTING);
+ gl.glEnable(GL_LIGHT0);
+ gl.glColor3f(1.0f, 1.0f, 1.0f);
+ gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+ gl.glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+ gl.glEnable(GL_NORMALIZE);
+ def_logo();
+ gl.glCullFace(GL_BACK);
+ gl.glEnable(GL_CULL_FACE);
+ }
+
+ public void preDisplay(GLDrawable drawable)
+ { }
+
+ public void display(GLDrawable drawable) {
+ int i;
+
+ // just render it
+ gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+ setCamera();
+ draw_logo();
+ }
+
+ public void postDisplay(GLDrawable drawable)
+ {
+ //
+ // computation for an animation sequence ...
+ //
+ speed = -0.95f*speed + progress*0.05f;
+ if (progress > 0.0f && speed < 0.0003f)
+ speed = 0.0003f;
+ if (speed > 0.01f)
+ speed = 0.01f;
+ progress = progress - speed;
+ }
+
+ public void reshape(GLDrawable drawable, int width, int height) {
+ gl.glMatrixMode (GL_MODELVIEW);
+ gl.glViewport (0, 0, width, height);
+ gl.glLoadIdentity();
+ setCamera();
+ }
+
+ public void cleanup(GLDrawable drawable)
+ { }
+
+ void setCamera() {
+ gl.glMatrixMode (GL_PROJECTION);
+ gl.glLoadIdentity ();
+ gl.glFrustum (-0.1333f, 0.1333f, -0.1f, 0.1f, 0.2f, 150.0f);
+ gl.glMatrixMode(GL_MODELVIEW);
+ gl.glLoadIdentity();
+ glu.gluLookAt(0,1.5f,2, 0,1.5f,0, 0,1,0);
+ gl.glTranslatef(0.0f, -8.0f, -45.0f);
+ gl.glRotatef(-progress*720f, 0.0f, 1.0f, 0.0f);
+ }
+
+ int rnd(int i) {
+ return ( (int)((float)Math.random()*RAND_MAX) )%i;
+ }
+
+ void groen_texture() {
+ gl.glMaterialfv(GL_FRONT, GL_DIFFUSE, difmat4);
+ gl.glMaterialfv(GL_FRONT, GL_AMBIENT, difamb4);
+ gl.glMaterialfv(GL_FRONT, GL_SPECULAR, matspec4);
+ gl.glMaterialf(GL_FRONT, GL_SHININESS, 35.0f);
+ }
+
+ void def_O() {
+ float a, s, c, ln;
+ int i,j,k,l,m,n;
+ float dx, dy;
+ float dx1, dx2, dy1, dy2, dz1, dz2;
+ float center_O[][];
+ float width_O[];
+
+ center_O=new float[ACC4+4][3];
+ width_O=new float[ACC4+4];
+
+ for (i=0;i<ACC4;i++)
+ {
+ a = 2.0f*((float) i)*M_PI/ACC4;
+ s = 1+(float)Math.sin(a);
+ c = (float)Math.cos(a);
+ center_O[i][0] = c*3.8f;
+ center_O[i][1] = s*3.8f+(s<-1.01f?-0.8f:(s>1.01f?0.8f:0)) + 0.8f;
+ center_O[i][2] = 0.0f;
+ width_O[i] = 0.6f;
+ }
+
+ /* I should be able to generalise this. oh well */
+ for (i=0;i<ACC4;i++)
+ {
+ j = (i+1)%ACC4;
+ k = (i+ACC4-1)%ACC4;
+ for (a=0;a<ACC;a++)
+ {
+ c = (float)Math.cos(a*M_PI*2.0f/ACC);
+ s = (float)Math.sin(a*M_PI*2.0f/ACC);
+ dx = center_O[j][0] - center_O[k][0];
+ dy = center_O[j][1] - center_O[k][1];
+ ln = (float)Math.sqrt(dx*dx+dy*dy);
+ dx = dx/ln;
+ dy = dy/ln;
+ char_O[i][(int) a][0] = center_O[i][0] + width_O[i] * dy * c;
+ char_O[i][(int) a][1] = center_O[i][1] - width_O[i] * dx * c;
+ char_O[i][(int) a][2] = (s<-THLD?-THLD:(s>THLD?THLD:s));
+ }
+ }
+ for (i=0;i<ACC;i++)
+ {
+ j = (i+1)%ACC;
+ k = (i-1+ACC)%ACC;
+ for (l=0;l<ACC4;l++)
+ {
+ m = (l+1)%ACC4;
+ n = (l+ACC4-1)%ACC4;
+ dx1 = char_O[m][i][0] - char_O[n][i][0];
+ dy1 = char_O[m][i][1] - char_O[n][i][1];
+ dz1 = char_O[m][i][2] - char_O[n][i][2];
+ dx2 = char_O[l][k][0] - char_O[l][j][0];
+ dy2 = char_O[l][k][1] - char_O[l][j][1];
+ dz2 = char_O[l][k][2] - char_O[l][j][2];
+ normal_O[l][i][0] = dy2*dz1 - dy1*dz2;
+ normal_O[l][i][1] = dz2*dx1 - dz1*dx2;
+ normal_O[l][i][2] = dx2*dy1 - dx1*dy2;
+ }
+ }
+ }
+
+ void def_P() {
+ float a, s, c, ln;
+ int i,j,k,l,m,n;
+ float dx, dy;
+ float dx1, dx2, dy1, dy2, dz1, dz2;
+ float center_P[][];
+ float width_P[];
+
+ center_P=new float[ACC2][3];
+ width_P=new float[ACC2];
+
+
+ for (i=0;i<ACC2;i++)
+ {
+ a = 2.0f*((float) i)*M_PI/ACC2;
+ s = 1+(float)Math.sin(a);
+ c = (float)Math.cos(a);
+ center_P[i][0] = c*2.15f;
+ center_P[i][1] = s*2.1f + (s<-1.01f?-0.7f:(s>1.01f?0.7f:0)) + 0.7f;
+ center_P[i][2] = 0.0f;
+ width_P[i] = 0.5f;
+ }
+
+ for (i=0;i<ACC2;i++)
+ {
+ j = (i+1)%ACC2;
+ k = (i+ACC2-1)%ACC2;
+ for (a=0;a<ACC;a++)
+ {
+ accCOS[(int) a] = c = (float)Math.cos(a*M_PI*2.0f/ACC);
+ accSIN[(int) a] = s = (float)Math.sin(a*M_PI*2.0f/ACC);
+ dx = center_P[j][0] - center_P[k][0];
+ dy = center_P[j][1] - center_P[k][1];
+ ln = (float)Math.sqrt(dx*dx+dy*dy);
+ dx = dx/ln;
+ dy = dy/ln;
+ char_P[i][(int) a][0] = center_P[i][0] + width_P[i] * dy * c;
+ char_P[i][(int) a][1] = center_P[i][1] - width_P[i] * dx * c;
+ char_P[i][(int) a][2] = (s<-THLD?-THLD:(s>THLD?THLD:s));
+ }
+ }
+ for (i=0;i<ACC;i++)
+ {
+ j = (i+1)%ACC;
+ k = (i-1+ACC)%ACC;
+ for (l=0;l<ACC2;l++)
+ {
+ m = (l+1)%ACC2;
+ n = (l+ACC2-1)%ACC2;
+ dx1 = char_P[m][i][0] - char_P[n][i][0];
+ dy1 = char_P[m][i][1] - char_P[n][i][1];
+ dz1 = char_P[m][i][2] - char_P[n][i][2];
+ dx2 = char_P[l][k][0] - char_P[l][j][0];
+ dy2 = char_P[l][k][1] - char_P[l][j][1];
+ dz2 = char_P[l][k][2] - char_P[l][j][2];
+ normal_P[l][i][0] = dy2*dz1 - dy1*dz2;
+ normal_P[l][i][1] = dz2*dx1 - dz1*dx2;
+ normal_P[l][i][2] = dx2*dy1 - dx1*dy2;
+ }
+ }
+ }
+
+ void def_El() {
+ float a, s, c, ln;
+ int i,j,k,l,m,n;
+ float dx, dy;
+ float dx1, dx2, dy1, dy2, dz1, dz2;
+ float center_El[][];
+ float width_El[];
+
+ center_El=new float[ACC3+3][3];
+ width_El=new float[ACC3+3];
+
+ for (i=0;i<ACC3+1;i++)
+ {
+ /* a = (ACC3/24 + i*11/12)*M_PI*2.0f/ACC3; */
+ a = (ACC3/8 + ((float) i)*3/4)*M_PI*2.0f/ACC3;
+ s = 1+(float)Math.sin(a);
+ c = (float)Math.cos(a);
+ center_El[i][0] = c*18.0f;
+ center_El[i][1] = s*9.3f;
+ center_El[i][2] = 0.0f;
+ width_El[i] = (float)Math.pow(3.5, Math.sin(i*M_PI/ACC3))-0.6f;
+ }
+
+ for (i=0;i<ACC3+1;i++)
+ {
+ j = (i+1)%ACC3;
+ k = (i+ACC3-1)%ACC3;
+ for (a=0;a<ACC;a++)
+ {
+ c = (float)Math.cos(a*M_PI*2.0f/ACC);
+ s = (float)Math.sin(a*M_PI*2.0f/ACC);
+ dx = center_El[j][0] - center_El[k][0];
+ dy = center_El[j][1] - center_El[k][1];
+ ln = (float)Math.sqrt(dx*dx+dy*dy);
+ dx = dx/ln;
+ dy = dy/ln;
+ char_El[i][(int) a][0] = center_El[i][0] + width_El[i] * dy * c;
+ char_El[i][(int) a][1] = center_El[i][1] - width_El[i] * dx * c;
+ char_El[i][(int) a][2] = (s<-THLD2?-THLD2:(s>THLD2?THLD2:s));
+ }
+ }
+ for (i=0;i<ACC+1;i++)
+ {
+ j = (i+1)%ACC;
+ k = (i-1+ACC)%ACC;
+ for (l=0;l<ACC3;l++)
+ {
+ m = (l+1)%ACC3;
+ n = (l+ACC3-1)%ACC3;
+ dx1 = char_El[m][i][0] - char_El[n][i][0];
+ dy1 = char_El[m][i][1] - char_El[n][i][1];
+ dz1 = char_El[m][i][2] - char_El[n][i][2];
+ dx2 = char_El[l][k][0] - char_El[l][j][0];
+ dy2 = char_El[l][k][1] - char_El[l][j][1];
+ dz2 = char_El[l][k][2] - char_El[l][j][2];
+ normal_El[l][i][0] = dy2*dz1 - dy1*dz2;
+ normal_El[l][i][1] = dz2*dx1 - dz1*dx2;
+ normal_El[l][i][2] = dx2*dy1 - dx1*dy2;
+ }
+ }
+ }
+
+ void def_G() {
+ float a, s, c, ln;
+ int i,j,k,l,m,n;
+ float dx, dy;
+ float dx1, dx2, dy1, dy2, dz1, dz2;
+ float center_G[][];
+ float width_G[];
+
+ center_G=new float[ACC4][3];
+ width_G=new float[ACC4];
+
+ for (i=0;i<ACC4;i++)
+ {
+ a = 2.0f*((float) i)*M_PI/ACC4;
+ s = 1+(float)Math.sin(a);
+ c = (float)Math.cos(a);
+ center_G[i][0] = c*3.8f;
+ center_G[i][1] = s*3.8f+(s<-1.01f?-0.8f:(s>1.01f?0.8f:0)) + 0.8f;
+ center_G[i][2] = 0.0f;
+ width_G[i] = 0.9f;
+ if (i>ACC4*3/4)
+ width_G[i] = 0.9f - ((i-ACC4*3/4)*0.9f)/ACC;
+ }
+ for (i=0;i<ACC4;i++)
+ {
+ j = (i+1)%ACC4;
+ k = (i+ACC4-1)%ACC4;
+ for (a=0;a<ACC;a++)
+ {
+ c = (float)Math.cos(a*M_PI*2.0f/ACC);
+ s = (float)Math.sin(a*M_PI*2.0f/ACC);
+ dx = center_G[j][0] - center_G[k][0];
+ dy = center_G[j][1] - center_G[k][1];
+ ln = (float)Math.sqrt(dx*dx+dy*dy);
+ dx = dx/ln;
+ dy = dy/ln;
+ char_G[i][(int) a][0] = center_G[i][0] + width_G[i] * dy * c;
+ char_G[i][(int) a][1] = center_G[i][1] - width_G[i] * dx * c;
+ char_G[i][(int) a][2] = (s<-THLD?-THLD:(s>THLD?THLD:s));
+ }
+ }
+ for (i=0;i<ACC;i++)
+ {
+ j = (i+1)%ACC;
+ k = (i-1+ACC)%ACC;
+ for (l=0;l<ACC4;l++)
+ {
+ m = (l+1)%ACC4;
+ n = (l+ACC4-1)%ACC4;
+ dx1 = char_G[m][i][0] - char_G[n][i][0];
+ dy1 = char_G[m][i][1] - char_G[n][i][1];
+ dz1 = char_G[m][i][2] - char_G[n][i][2];
+ dx2 = char_G[l][k][0] - char_G[l][j][0];
+ dy2 = char_G[l][k][1] - char_G[l][j][1];
+ dz2 = char_G[l][k][2] - char_G[l][j][2];
+ normal_G[l][i][0] = dy2*dz1 - dy1*dz2;
+ normal_G[l][i][1] = dz2*dx1 - dz1*dx2;
+ normal_G[l][i][2] = dx2*dy1 - dx1*dy2;
+ }
+ }
+ }
+
+ void randomize() {
+ int i;
+ for (i=0;i<7;i++)
+ {
+ TRANS[i][0] = rnd(100)-rnd(100);
+ TRANS[i][1] = rnd(100)-rnd(100);
+ TRANS[i][1] = rnd(100)-rnd(100);
+ ROTAXIS[i][0] = rnd(100)-rnd(100);
+ ROTAXIS[i][1] = rnd(100)-rnd(100);
+ ROTAXIS[i][1] = rnd(100)-rnd(100);
+ ROT[i]=rnd(3600)-rnd(3600);
+ }
+ }
+
+ void def_logo() {
+ def_O();
+ def_P();
+ def_El();
+ def_G();
+ }
+
+ void draw_O() {
+ int i,j,k;
+ for (i=0;i<ACC;i++)
+ {
+ k = i+1;
+ if (k>=ACC)
+ k = 0;
+ gl.glBegin(GL_QUAD_STRIP);
+ for (j=0;j<ACC4;j++)
+ {
+ gl.glNormal3f(normal_O[j][k][0], normal_O[j][k][1], normal_O[j][k][2]);
+ gl.glVertex3f(char_O[j][k][0], char_O[j][k][1], char_O[j][k][2]);
+ gl.glNormal3f(normal_O[j][i][0], normal_O[j][i][1], normal_O[j][i][2]);
+ gl.glVertex3f(char_O[j][i][0], char_O[j][i][1], char_O[j][i][2]);
+ }
+ gl.glNormal3f(normal_O[0][k][0], normal_O[0][k][1], normal_O[0][k][2]);
+ gl.glVertex3f(char_O[0][k][0], char_O[0][k][1], char_O[0][k][2]);
+ gl.glNormal3f(normal_O[0][i][0], normal_O[0][i][1], normal_O[0][i][2]);
+ gl.glVertex3f(char_O[0][i][0], char_O[0][i][1], char_O[0][i][2]);
+ gl.glEnd();
+ }
+ }
+
+ void draw_P() {
+ int i,j,k;
+ for (i=0;i<ACC;i++)
+ {
+ k = i+1;
+ if (k>=ACC)
+ k = 0;
+ gl.glBegin(GL_QUAD_STRIP);
+ for (j=0;j<ACC2;j++)
+ {
+ gl.glNormal3f(normal_P[j][k][0], normal_P[j][k][1], normal_P[j][k][2]);
+ gl.glVertex3f(char_P[j][k][0], char_P[j][k][1], char_P[j][k][2]);
+ gl.glNormal3f(normal_P[j][i][0], normal_P[j][i][1], normal_P[j][i][2]);
+ gl.glVertex3f(char_P[j][i][0], char_P[j][i][1], char_P[j][i][2]);
+ }
+ gl.glNormal3f(normal_P[0][k][0], normal_P[0][k][1], normal_P[0][k][2]);
+ gl.glVertex3f(char_P[0][k][0], char_P[0][k][1], char_P[0][k][2]);
+ gl.glNormal3f(normal_P[0][i][0], normal_P[0][i][1], normal_P[0][i][2]);
+ gl.glVertex3f(char_P[0][i][0], char_P[0][i][1], char_P[0][i][2]);
+ gl.glEnd();
+ }
+ j = 0;
+ gl.glBegin(GL_QUAD_STRIP);
+ for (i=0;i<ACC;i++)
+ {
+ gl.glNormal3f(normal_P[0][i][0], normal_P[0][i][1], normal_P[0][i][2]);
+ gl.glVertex3f(char_P[0][i][0]-4.3f, -1.6f, 1.0f*char_P[0][i][2]);
+ gl.glVertex3f(char_P[0][i][0]-4.3f, 6.0f, 1.0f*char_P[0][i][2]);
+ }
+ gl.glNormal3f(normal_P[0][0][0], normal_P[0][0][1], normal_P[0][0][2]);
+ gl.glVertex3f(char_P[0][0][0]-4.3f, -1.6f, 1.0f*char_P[0][0][2]);
+ gl.glVertex3f(char_P[0][0][0]-4.3f, 6.0f, 1.0f*char_P[0][0][2]);
+ gl.glEnd();
+ }
+
+ void draw_E() {
+ int i,j,k;
+ for (i=0;i<ACC;i++)
+ {
+ k = i+1;
+ if (k>=ACC)
+ k = 0;
+ gl.glBegin(GL_QUAD_STRIP);
+ gl.glNormal3f(normal_P[0][k][0], normal_P[0][k][1], normal_P[0][k][2]);
+ gl.glVertex3f(char_P[0][k][0], char_P[0][k][1]+0.0f, char_P[0][k][2]);
+ gl.glNormal3f(normal_P[0][i][0], normal_P[0][i][1], normal_P[0][i][2]);
+ gl.glVertex3f(char_P[0][i][0], char_P[0][i][1]+0.0f, char_P[0][i][2]);
+ for (j=1;j<ACC2;j++)
+ {
+ gl.glNormal3f(normal_P[j][k][0], normal_P[j][k][1], normal_P[j][k][2]);
+ gl.glVertex3f(char_P[j][k][0], char_P[j][k][1], char_P[j][k][2]);
+ gl.glNormal3f(normal_P[j][i][0], normal_P[j][i][1], normal_P[j][i][2]);
+ gl.glVertex3f(char_P[j][i][0], char_P[j][i][1], char_P[j][i][2]);
+ }
+ gl.glNormal3f(normal_P[0][k][0], normal_P[0][k][1], normal_P[0][k][2]);
+ gl.glVertex3f(char_P[0][k][0], char_P[0][k][1]-0.4f, char_P[0][k][2]);
+ gl.glNormal3f(normal_P[0][i][0], normal_P[0][i][1], normal_P[0][i][2]);
+ gl.glVertex3f(char_P[0][i][0], char_P[0][i][1]-0.4f, char_P[0][i][2]);
+ gl.glEnd();
+ }
+
+ gl.glBegin(GL_QUAD_STRIP);
+ j = ACC2*3/4;
+ for (i=0;i<ACC;i++)
+ {
+ gl.glNormal3f(normal_P[j][i][0], normal_P[j][i][1], normal_P[j][i][2]);
+ gl.glVertex3f(-2.0f, char_P[j][i][1]+2.55f, 1.0f*char_P[j][i][2]);
+ gl.glVertex3f(2.0f, char_P[j][i][1]+2.55f, 1.0f*char_P[j][i][2]);
+ }
+ gl.glNormal3f(normal_P[j][0][0], normal_P[j][0][1], normal_P[j][0][2]);
+ gl.glVertex3f(-2.0f, char_P[j][0][1]+2.55f, 1.0f*char_P[j][0][2]);
+ gl.glVertex3f(2.0f, char_P[j][0][1]+2.55f, 1.0f*char_P[j][0][2]);
+ gl.glEnd();
+ }
+
+ void draw_El() {
+ int i,j,k;
+ for (i=0;i<ACC;i++)
+ {
+ k = i+1;
+ if (k>=ACC)
+ k = 0;
+ gl.glBegin(GL_QUAD_STRIP);
+ for (j=0;j<=ACC3;j++)
+ {
+ gl.glNormal3f(normal_El[j][k][0], normal_El[j][k][1], normal_El[j][k][2]);
+ gl.glVertex3f(char_El[j][k][0], char_El[j][k][1], char_El[j][k][2]);
+ gl.glNormal3f(normal_El[j][i][0], normal_El[j][i][1], normal_El[j][i][2]);
+ gl.glVertex3f(char_El[j][i][0], char_El[j][i][1], char_El[j][i][2]);
+ }
+ gl.glEnd();
+ }
+ }
+
+ void draw_N() {
+ int i,j,k;
+ for (i=0;i<ACC;i++)
+ {
+ k = i+1;
+ if (k>=ACC)
+ k = 0;
+ gl.glBegin(GL_QUAD_STRIP);
+ for (j=0;j<=ACC2/2;j++)
+ {
+ gl.glNormal3f(normal_P[j][k][0], normal_P[j][k][1], normal_P[j][k][2]);
+ gl.glVertex3f(char_P[j][k][0], char_P[j][k][1], char_P[j][k][2]);
+ gl.glNormal3f(normal_P[j][i][0], normal_P[j][i][1], normal_P[j][i][2]);
+ gl.glVertex3f(char_P[j][i][0], char_P[j][i][1], char_P[j][i][2]);
+ }
+ gl.glEnd();
+ }
+
+ j = 0;
+ gl.glBegin(GL_QUAD_STRIP);
+ for (i=0;i<ACC;i++)
+ {
+ gl.glNormal3f(normal_P[0][i][0], normal_P[0][i][1], normal_P[0][i][2]);
+ gl.glVertex3f(char_P[0][i][0]-4.3f, 0.2f, 1.0f*char_P[0][i][2]);
+ gl.glVertex3f(char_P[0][i][0]-4.3f, 6.0f, 1.0f*char_P[0][i][2]);
+ }
+ gl.glNormal3f(normal_P[0][0][0], normal_P[0][0][1], normal_P[0][0][2]);
+ gl.glVertex3f(char_P[0][0][0]-4.3f, 0.2f, 1.0f*char_P[0][0][2]);
+ gl.glVertex3f(char_P[0][0][0]-4.3f, 6.0f, 1.0f*char_P[0][0][2]);
+ gl.glEnd();
+ j = 0;
+
+ gl.glBegin(GL_QUAD_STRIP);
+ for (i=0;i<ACC;i++)
+ {
+ gl.glNormal3f(normal_P[0][i][0], normal_P[0][i][1], normal_P[0][i][2]);
+ gl.glVertex3f(char_P[0][i][0], 0.2f, 1.0f*char_P[0][i][2]);
+ gl.glVertex3f(char_P[0][i][0], 3.4f, 1.0f*char_P[0][i][2]);
+ }
+ gl.glNormal3f(normal_P[0][0][0], normal_P[0][0][1], normal_P[0][0][2]);
+ gl.glVertex3f(char_P[0][0][0], 0.2f, 1.0f*char_P[0][0][2]);
+ gl.glVertex3f(char_P[0][0][0], 3.4f, 1.0f*char_P[0][0][2]);
+ gl.glEnd();
+ }
+
+ void draw_G() {
+ int i,j,k;
+ for (i=0;i<ACC;i++)
+ {
+ k = i+1;
+ if (k>=ACC)
+ k = 0;
+ gl.glBegin(GL_QUAD_STRIP);
+ gl.glNormal3f(normal_G[0][k][0], normal_G[0][k][1], normal_G[0][k][2]);
+ gl.glVertex3f(char_G[0][k][0], char_G[0][k][1]+1.2f, char_G[0][k][2]);
+ gl.glNormal3f(normal_G[0][i][0], normal_G[0][i][1], normal_G[0][i][2]);
+ gl.glVertex3f(char_G[0][i][0], char_G[0][i][1]+1.2f, char_G[0][i][2]);
+ for (j=1;j<ACC4;j++)
+ {
+ gl.glNormal3f(normal_G[j][k][0], normal_G[j][k][1], normal_G[j][k][2]);
+ gl.glVertex3f(char_G[j][k][0], char_G[j][k][1], char_G[j][k][2]);
+ gl.glNormal3f(normal_G[j][i][0], normal_G[j][i][1], normal_G[j][i][2]);
+ gl.glVertex3f(char_G[j][i][0], char_G[j][i][1], char_G[j][i][2]);
+ }
+ gl.glEnd();
+ }
+
+ gl.glBegin(GL_QUAD_STRIP);
+ j = ACC4*3/4;
+ for (i=0;i<ACC;i++)
+ {
+ gl.glNormal3f(accSIN[i], 0.0f, accCOS[i] );
+ gl.glVertex3f(4.0f+0.9f*accSIN[i], 4.0f+0.9f*accSIN[i], 0.9f*accCOS[i] );
+ gl.glVertex3f(4.0f+0.9f*accSIN[i], 0.0f, 0.9f*accCOS[i]);
+ }
+ gl.glNormal3f(accSIN[0], 0.0f, accCOS[0] );
+ gl.glVertex3f(4.0f+0.9f*accSIN[0], 4.0f+0.9f*accSIN[0], 0.9f*accCOS[0] );
+ gl.glVertex3f(4.0f+0.9f*accSIN[0], 0.0f, 0.9f*accCOS[0]);
+ gl.glEnd();
+
+ gl.glBegin(GL_QUAD_STRIP);
+ j = ACC4*3/4;
+ for (i=0;i<ACC;i++)
+ {
+ gl.glNormal3f(0.0f, accSIN[i], accCOS[i] );
+ gl.glVertex3f(4.0f-0.9f*accSIN[i], 4.0f-0.9f*accSIN[i], 0.9f*accCOS[i] );
+ gl.glVertex3f(0.0f, 4.0f-0.9f*accSIN[i], 0.9f*accCOS[i]);
+ }
+ gl.glNormal3f(0.0f, accSIN[0], accCOS[0] );
+ gl.glVertex3f(4.0f-0.9f*accSIN[0], 4.0f-0.9f*accSIN[0], 0.9f*accCOS[0] );
+ gl.glVertex3f(0.0f, 4.0f-0.9f*accSIN[0], 0.9f*accCOS[0]);
+ gl.glEnd();
+
+ j = ACC4*3/4;
+ gl.glBegin(GL_TRIANGLE_FAN);
+ gl.glNormal3f(-1.0f, 0.0f, 0.0f);
+ gl.glVertex3f(0.0f, 4.0f, 0.0f);
+ for (i=0;i<ACC;i++)
+ gl.glVertex3f(0.0f, 4.0f+0.9f*accSIN[i], 0.9f*accCOS[i]);
+ gl.glVertex3f(0.0f, 4.0f+0.9f*accSIN[0], 0.9f*accCOS[0]);
+ gl.glEnd();
+ }
+
+ void draw_L() {
+ int i;
+
+ gl.glBegin(GL_QUAD_STRIP);
+ for (i=0;i<ACC;i++)
+ {
+ gl.glNormal3f(accSIN[i], 0.0f, accCOS[i] );
+ gl.glVertex3f(0.9f*accSIN[i], 9.6f, 0.9f*accCOS[i]);
+ gl.glVertex3f(0.9f*accSIN[i], 0.9f+0.9f*accSIN[i], 0.9f*accCOS[i] );
+ }
+ gl.glNormal3f(accSIN[0], 0.0f, accCOS[0] );
+ gl.glVertex3f(0.9f*accSIN[0], 9.6f, 0.9f*accCOS[0]);
+ gl.glVertex3f(0.9f*accSIN[0], 0.9f+0.9f*accSIN[0], 0.9f*accCOS[0] );
+ gl.glEnd();
+
+ gl.glBegin(GL_QUAD_STRIP);
+ for (i=0;i<ACC;i++)
+ {
+ gl.glNormal3f(0.0f, accSIN[i], accCOS[i] );
+ gl.glVertex3f(0.9f*accSIN[i], 0.9f+0.9f*accSIN[i], 0.9f*accCOS[i] );
+ gl.glVertex3f(5.6f, 0.9f+0.9f*accSIN[i], 0.9f*accCOS[i]);
+ }
+ gl.glNormal3f(0.0f, accSIN[0], accCOS[0] );
+ gl.glVertex3f(0.9f*accSIN[0], 0.9f+0.9f*accSIN[0], 0.9f*accCOS[0] );
+ gl.glVertex3f(5.6f, 0.9f+0.9f*accSIN[0], 0.9f*accCOS[0]);
+ gl.glEnd();
+
+ gl.glBegin(GL_TRIANGLE_FAN);
+ gl.glNormal3f(1.0f, 0.0f, 0.0f);
+ gl.glVertex3f(5.6f, 0.9f, 0.0f);
+ for (i=ACC-1;i>=0;i--)
+ gl.glVertex3f(5.6f, 0.9f+0.9f*accSIN[i], 0.9f*accCOS[i]);
+ gl.glVertex3f(5.6f, 0.9f+0.9f*accSIN[ACC-1], 0.9f*accCOS[ACC-1]);
+ gl.glEnd();
+ }
+
+ void draw_part(int i) {
+ gl.glPushMatrix();
+ gl.glTranslatef(TRANS[i][0]*progress, TRANS[i][1]*progress, TRANS[i][2]*progress);
+ gl.glRotatef(ROT[i]*progress, ROTAXIS[i][0], ROTAXIS[i][1], ROTAXIS[i][2]);
+ switch(i)
+ {
+ case 0: draw_El(); break;
+ case 1: draw_O(); break;
+ case 2: draw_P(); break;
+ case 3: draw_E(); break;
+ case 4: draw_N(); break;
+ case 5: draw_G(); break;
+ case 6: draw_L(); break;
+ }
+ gl.glPopMatrix();
+ }
+
+ void draw_logo() {
+ groen_texture();
+ gl.glEnable(GL_CULL_FACE);
+ gl.glTranslatef(-2.8f, 0.0f, 0.0f);
+
+ draw_part(0);
+ gl.glTranslatef(-12.0f, 4.3f, 0.0f);
+ draw_part(1);
+ gl.glTranslatef(7.3f, 0.0f, 0.0f);
+ draw_part(2);
+ gl.glTranslatef(5.4f, 0.0f, 0.0f);
+ draw_part(3);
+ gl.glTranslatef(5.4f, 0.0f, 0.0f);
+ draw_part(4);
+ gl.glTranslatef(7.4f, 0.0f, 0.0f);
+ draw_part(5);
+ gl.glTranslatef(6.8f, 0.0f, 0.0f);
+ draw_part(6);
+ }
+
+ void go() {
+ GLCapabilities caps = new GLCapabilities();
+ /*
+ caps.setDoubleBuffered(true);
+ caps.setTrueColor(true);
+ caps.setStereo(false);
+ caps.setDepthBits(32);
+ caps.setRedBits(5);
+ caps.setGreenBits(5);
+ caps.setBlueBits(5);
+ */
+ GLAnimCanvas canvas =
+ GLDrawableFactory.getFactory().createGLAnimCanvas(caps, 400, 400);
+ if (canvas == null) {
+ throw new RuntimeException("Unable to match required GLCapabilities");
+ }
+ canvas.addGLEventListener(this);
+ canvas.start();
+ Frame frame = new Frame();
+ frame.add(canvas);
+ frame.setSize(400, 400);
+ frame.pack();
+ frame.show();
+ }
+
+ public static void main(String[] args) {
+ GLContext.gljNativeDebug = true;
+ GLContext.gljThreadDebug = false;
+ GLContext.gljClassDebug = true;
+
+ new TestListener().go();
+ }
+}
diff --git a/demos/gltestperf.java b/demos/gltestperf.java
new file mode 100644
index 0000000..a97445e
--- /dev/null
+++ b/demos/gltestperf.java
@@ -0,0 +1,871 @@
+/**
+ * @(#) gltestperf.java
+ * @(#) author: David Bucciarelli ([email protected]), Humanware s.r.l.
+ *
+ * This program is under the GNU GPL.
+ * Use at your own risk.
+ *
+ * Transformed to java, using OpenGL[tm] for Java[tm] (gl4java),
+ * by Sven Goethel [email protected], http://www.jausoft.com/gl4java
+ *
+ */
+
+import java.applet.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.lang.*;
+import java.util.*;
+import java.io.*;
+import java.util.*;
+
+import gl4java.*;
+import gl4java.drawable.*;
+import gl4java.awt.*;
+
+public class gltestperf extends GLCanvas
+{
+
+ static boolean frontbuffer = true;
+
+ static final float BMARKS_TIME = 5.0f;
+
+ static final int NUM_BMARKS = 6;
+
+ static int firstBenchMark = 0;
+ static int lastBenchMark = NUM_BMARKS-1;
+
+ /* 554 ~= (float)Math.sqrt(640*480) */
+
+ protected benchmark[/*NUM_BMARKS*/] bmarks = null;
+
+ protected abstract class benchmark
+ {
+ public String name;
+ public String unit;
+ public int type;
+ public int numsize;
+ public int[/*10*/] size;
+
+ public abstract void init ();
+ public abstract int run ( int size, int num ) ;
+
+ public String toString()
+ {
+ return "benchmark \""+name+"\"\n [ unit="+unit+
+ ", type="+type+
+ ", numsize="+numsize+"]";
+ }
+ }
+
+ public benchmark[] getAllBenchmarks()
+ {
+ benchmark[] _bmarks = new benchmark[NUM_BMARKS];
+ _bmarks[0] = new Pnts();
+ _bmarks[1] = new Lins();
+ _bmarks[2] = new Tris1();
+ _bmarks[3] = new Tris2();
+ _bmarks[4] = new Tris3();
+ _bmarks[5] = new Clrs();
+
+ return _bmarks;
+ }
+
+ public static void main( String args[] )
+ {
+ int i;
+
+ gltestperf canvas = null;
+ Dimension d = new Dimension(640, 480);
+ GLCapabilities glCaps = new GLCapabilities();
+
+ gl4java.drawable.GLDrawableFactory df =
+ gl4java.drawable.GLDrawableFactory.getFactory();
+
+ //Create our canvas and add it to the center of the applet
+ if(df instanceof gl4java.drawable.SunJDK13GLDrawableFactory)
+ {
+ gl4java.drawable.SunJDK13GLDrawableFactory sdf =
+ (gl4java.drawable.SunJDK13GLDrawableFactory)df;
+ canvas = new gltestperf
+ (sdf.getGraphicsConfiguration(glCaps), glCaps, d.width, d.height);
+ } else {
+ canvas = new gltestperf(glCaps, d.width, d.height);
+ }
+
+ for(i=0; i<args.length; i++)
+ {
+ if(args[i].equals("--help"))
+ {
+ System.out.println("usage:");
+ System.out.println(" --bm <int> : run only this BenchMark");
+ System.out.println(" --first <int> : firstBenchMark to run");
+ System.out.println(" --last <int> : lastBenchMark to run");
+ System.out.println(" --help : this message");
+ benchmark[] _bmarks = canvas.getAllBenchmarks();
+
+ System.out.println("Avaiable Benchmarks: ");
+ for(int j=0; j<NUM_BMARKS; j++)
+ {
+ System.out.println("Benchmarks Number: "+j);
+ System.out.println(_bmarks[j]);
+ System.out.println();
+ }
+
+ System.exit(0);
+ }
+ if(args[i].equals("--first"))
+ {
+ i++;
+ try {
+ gltestperf.firstBenchMark=
+ Integer.valueOf(args[i]).intValue();
+ } catch (Exception ex) {}
+
+ if(gltestperf.firstBenchMark<0)
+ gltestperf.firstBenchMark=0;
+ if(gltestperf.firstBenchMark>=NUM_BMARKS)
+ gltestperf.firstBenchMark=NUM_BMARKS-1;
+ } else if(args[i].equals("--last")) {
+ i++;
+ try {
+ gltestperf.lastBenchMark=
+ Integer.valueOf(args[i]).intValue();
+ } catch (Exception ex) {}
+
+ if(gltestperf.lastBenchMark<0)
+ gltestperf.lastBenchMark=0;
+ if(gltestperf.lastBenchMark>=NUM_BMARKS)
+ gltestperf.lastBenchMark=NUM_BMARKS-1;
+ } else if(args[i].equals("--bm")) {
+ i++;
+ try {
+ gltestperf.lastBenchMark=
+ Integer.valueOf(args[i]).intValue();
+ } catch (Exception ex) {}
+ if(gltestperf.lastBenchMark<0)
+ gltestperf.lastBenchMark=0;
+ if(gltestperf.lastBenchMark>=NUM_BMARKS)
+ gltestperf.lastBenchMark=NUM_BMARKS-1;
+ gltestperf.firstBenchMark=
+ gltestperf.lastBenchMark;
+ } else {
+ System.out.println("ERROR Unknown Argument !");
+ System.out.println("arg "+i+": "+args[i]);
+ System.exit(1);
+ }
+ }
+
+ if(gltestperf.firstBenchMark>gltestperf.lastBenchMark)
+ gltestperf.firstBenchMark=
+ gltestperf.lastBenchMark;
+
+ Frame f = new Frame("gltestperf");
+
+ GLContext.gljNativeDebug = false;
+ GLContext.gljThreadDebug = false;
+ GLContext.gljClassDebug = false;
+
+ f.addWindowListener( new WindowAdapter()
+ {
+ public void windowClosed(WindowEvent e)
+ {
+ System.exit(0);
+ }
+ public void windowClosing(WindowEvent e)
+ {
+ windowClosed(e);
+ }
+ }
+ );
+
+ f.setLayout(new BorderLayout());
+ canvas.requestFocus();
+ f.add("Center", canvas);
+ Dimension ps = canvas.getPreferredSize();
+ f.setBounds(-100,-100,99,99);
+ f.setVisible(true);
+ //f.setVisible(false);
+ //f.setVisible(true);
+ Insets is = f.getInsets();
+ f.setBounds(0,0,
+ ps.width+is.left+is.right,
+ ps.height+is.top+is.bottom);
+ f.setVisible(true);
+ }
+
+ public gltestperf(GraphicsConfiguration g, GLCapabilities glCaps,
+ int w, int h)
+ {
+ super(g, glCaps, w, h);
+ }
+
+ public gltestperf(GLCapabilities glCaps, int w, int h)
+ {
+ super(glCaps, w, h);
+ }
+
+ public void init()
+ {
+ System.out.println("**** Window Size: "+getSize());
+ System.out.println("**** Running Benchmarks ["+
+ firstBenchMark+".."+lastBenchMark+"]");
+ bmarks = getAllBenchmarks();
+ }
+
+ public void display()
+ {
+ int i;
+
+ if (glj.gljMakeCurrent() == false) return;
+
+ if (frontbuffer)
+ gl.glDrawBuffer(GL_FRONT);
+ else
+ gl.glDrawBuffer(GL_BACK);
+
+ for (i = firstBenchMark; i <= lastBenchMark; i++) {
+ System.out.println("**** Benchmark: "+i);
+
+ switch (bmarks[i].type) {
+ case 0:
+ case 3:
+ dotest0param(bmarks[i]);
+ break;
+ case 1:
+ case 2:
+ dotest1param(bmarks[i]);
+ break;
+ }
+ }
+
+ glj.gljSwap();
+ glj.gljCheckGL();
+ glj.gljFree();
+
+ }
+
+/***************************************************************************/
+
+protected void dotest0param(benchmark bmark)
+{
+ long stime, etime, tottime, maxtime, mintime;
+ double dtime;
+ int num=0, numelem=0, calibnum=0, j=0;
+
+ gl.glPushAttrib(GL_ALL_ATTRIB_BITS);
+ bmark.init();
+
+ stime=System.currentTimeMillis();
+
+ dtime = 0.0D;
+ calibnum = 0;
+ while (dtime < 2.0D) {
+ bmark.run(0, 1);
+ gl.glFinish();
+ etime = System.currentTimeMillis();
+ dtime = (etime - stime) / 1000.0D;
+ calibnum++;
+ }
+ gl.glPopAttrib();
+
+ System.out.println("***** Elapsed time for the calibration test ("+
+ calibnum+"): "+dtime);
+
+ num = (int) ((BMARKS_TIME / dtime) * calibnum);
+
+ if (num < 1)
+ num = 1;
+
+ System.out.println("***** Selected number of benchmark iterations: "+
+ num);
+
+
+ mintime = Long.MAX_VALUE;
+ maxtime = Long.MIN_VALUE;
+
+ for (tottime = 0, j = 0; j < 5; j++) {
+ gl.glPushAttrib(GL_ALL_ATTRIB_BITS);
+ bmark.init();
+
+ stime = System.currentTimeMillis();
+ numelem = bmark.run(0, num);
+ gl.glFinish();
+ etime = System.currentTimeMillis();
+
+ gl.glPopAttrib();
+
+ dtime = (etime - stime) / 1000.0D;
+ tottime += dtime;
+
+ System.out.println("****** Elapsed time for run "+
+ j+": "+dtime);
+
+
+ if (dtime < mintime)
+ mintime = (long)dtime;
+ if (dtime > maxtime)
+ maxtime = (long)dtime;
+ }
+
+ tottime -= mintime + maxtime;
+
+ System.out.println("***** "+bmark.name+"\n***** "+
+ (numelem / (tottime / 3.0D))+" "+bmark.unit+"/sec");
+
+ if (bmark.type == 3)
+ System.out.println(", MPixel Fill/sec: "+
+ ( (numelem * bmark.size[0] * (float) bmark.size[0]) /
+ (1000000.0D * tottime / 3.0D)
+ ) +"\n\n");
+
+ else
+ System.out.println("\n");
+}
+
+/***************************************************************************/
+
+protected void dotest1param(benchmark bmark)
+{
+ double stime, etime, dtime, tottime, maxtime, mintime;
+ int num, numelem, calibnum, j, k;
+
+ System.out.println("***** "+bmark.name);
+
+ for (j = 0; j < bmark.numsize; j++) {
+ System.out.println("****** "+ "Current size: "+ bmark.size[j]);
+
+ gl.glPushAttrib(GL_ALL_ATTRIB_BITS);
+ bmark.init();
+
+ stime = System.currentTimeMillis();
+
+ dtime = 0.0D;
+ calibnum = 0;
+ while (dtime < 2.0D) {
+ bmark.run(bmark.size[j], 1);
+ gl.glFinish();
+ etime = System.currentTimeMillis();
+ dtime = (etime - stime) / 1000.0D;
+ calibnum++;
+ }
+ gl.glPopAttrib();
+
+ System.out.println("****** Elapsed time for the calibration test ("+
+ calibnum+"): "+dtime);
+
+ num = (int) ((BMARKS_TIME / dtime) * calibnum);
+
+ if (num < 1)
+ num = 1;
+
+ System.out.println("****** Selected number of benchmark iterations: "+
+ num);
+
+ mintime = Long.MAX_VALUE;
+ maxtime = Long.MIN_VALUE;
+
+ for (numelem = 1, tottime = 0.0D, k = 0; k < 5; k++) {
+ gl.glPushAttrib(GL_ALL_ATTRIB_BITS);
+ bmark.init();
+
+ stime = System.currentTimeMillis();
+ numelem = bmark.run(bmark.size[j], num);
+ gl.glFinish();
+ etime = System.currentTimeMillis();
+
+ gl.glPopAttrib();
+
+ dtime = (etime - stime) / 1000.0D;
+ tottime += dtime;
+
+ System.out.println("******* Elapsed time for run "+
+ k+": "+dtime);
+
+ if (dtime < mintime)
+ mintime = dtime;
+ if (dtime > maxtime)
+ maxtime = dtime;
+ }
+
+ tottime -= mintime + maxtime;
+
+ System.out.print("****** "+ "SIZE="+bmark.size[j]+" => "+
+ (numelem / (tottime / 3.0D)) + " "+bmark.unit+"/sec");
+
+ if (bmark.type == 2)
+ System.out.println(", MPixel Fill/sec: "+
+ (
+ (numelem * bmark.size[j] * bmark.size[j] / 2) /
+ (1000000.0D * tottime / 3.0D)
+ ) );
+ else
+ System.out.println();
+ }
+
+ System.out.println("\n");
+}
+
+/***************************************************************************/
+
+protected class Clrs
+ extends benchmark
+{
+ public Clrs()
+ {
+ name="Color/Depth Buffer Clears";
+ unit="Clrs";
+ type=3;
+ numsize=0;
+ size=new int[10];
+ size[0]=554;
+ size[1]=0;
+ size[2]=0;
+ size[3]=0;
+ size[4]=0;
+ size[5]=0;
+ size[6]=0;
+ size[7]=0;
+ size[8]=0;
+ size[9]=0;
+ }
+
+ public void init()
+ {
+ gl.glMatrixMode(GL_PROJECTION);
+ gl.glLoadIdentity();
+ glu.gluOrtho2D(-0.5f, 639.5f, -0.5f, 479.5f);
+ gl.glMatrixMode(GL_MODELVIEW);
+
+ gl.glShadeModel(GL_SMOOTH);
+ gl.glEnable(GL_DEPTH_TEST);
+
+ gl.glClearColor(0.0f, 0.1f, 1.0f, 0.0f);
+ gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ }
+
+ public int run(int size, int num)
+ {
+ int y;
+
+ for (y = 0; y < num; y++) {
+ gl.glClearColor(y / (float) num, 0.1f, 1.0f, 0.0f);
+ gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+ }
+
+ return num;
+ }
+
+}
+
+protected class Tris3
+ extends benchmark
+{
+ public Tris3()
+ {
+ name="ZSmooth Tex Blend TMesh Triangles";
+ unit="Tris";
+ type=2;
+ numsize=8;
+ size=new int[10];
+ size[0]=400;
+ size[1]=250;
+ size[2]=100;
+ size[3]=50;
+ size[4]=25;
+ size[5]=10;
+ size[6]=5;
+ size[7]=2;
+ size[8]=0;
+ size[9]=0;
+ }
+
+ public void init()
+ {
+ int x, y;
+ byte[] tex = new byte[128 * 128 * 3];
+ int gluerr;
+
+ gl.glMatrixMode(GL_PROJECTION);
+ gl.glLoadIdentity();
+ gl.glOrtho(-0.5f, 639.5f, -0.5f, 479.5f, -1.0f, 1.0f);
+
+ gl.glMatrixMode(GL_MODELVIEW);
+
+ gl.glShadeModel(GL_SMOOTH);
+ gl.glEnable(GL_DEPTH_TEST);
+
+ gl.glEnable(GL_BLEND);
+ gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ for (y = 0; y < 128; y++)
+ for (x = 0; x < 128; x++) {
+ tex[((x + (y * 128)) * 3) + 0] = (byte) ( ((x % (128 / 4)) < (128 / 8)) ? 255 : 0 );
+ tex[((x + (y * 128)) * 3) + 1] = (byte) ( ((y % (128 / 4)) < (128 / 8)) ? 255 : 0 );
+ tex[((x + (y * 128)) * 3) + 2] = (byte) x;
+ }
+
+ gl.glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+ if (0<(gluerr = glu.gluBuild2DMipmaps(GL_TEXTURE_2D, 3, 128, 128,
+ GL_RGB, GL_UNSIGNED_BYTE, tex)))
+ {
+ System.out.println("!!!! GLULib"+ glu.gluErrorString(gluerr));
+ System.exit(1);
+ }
+
+ gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+ gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+ GL_LINEAR_MIPMAP_NEAREST);
+ gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+ gl.glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+ gl.glEnable(GL_TEXTURE_2D);
+
+ gl.glDepthFunc(GL_ALWAYS);
+
+ gl.glClearColor(0.0f, 0.1f, 1.0f, 0.0f);
+ gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+ }
+
+ public int run(int size, int num)
+ {
+ int y;
+ float[] v0=new float[3], v1=new float[3],
+ v2=new float[3], v3=new float[3];
+ float[] cv0=new float[3], cv1=new float[3],
+ cv2=new float[3], cv3=new float[3];
+ float[] tv0=new float[3], tv1=new float[3],
+ tv2=new float[3], tv3=new float[3];
+
+ v0[0] = 320 - size / 2;
+ v0[1] = 240 - size / 2;
+ v0[2] = 0.0f;
+ v1[0] = 320 + size / 2;
+ v1[1] = 240 - size / 2;
+ v1[2] = 0.0f;
+ v2[0] = 320 - size / 2;
+ v2[1] = 240 + size / 2;
+ v2[2] = 0.0f;
+ v3[0] = 320 + size / 2;
+ v3[1] = 240 + size / 2;
+ v3[2] = 0.0f;
+ cv0[0] = 1.0f;
+ cv0[1] = 0.0f;
+ cv0[2] = 0.0f;
+ cv1[0] = 1.0f;
+ cv1[1] = 1.0f;
+ cv1[2] = 0.0f;
+ cv2[0] = 1.0f;
+ cv2[1] = 0.0f;
+ cv2[2] = 1.0f;
+ cv3[0] = 1.0f;
+ cv3[1] = 1.0f;
+ cv3[2] = 1.0f;
+ tv0[0] = 0.0f;
+ tv0[1] = 0.0f;
+ tv0[2] = 0.0f;
+ tv1[0] = 1.0f;
+ tv1[1] = 0.0f;
+ tv1[2] = 0.0f;
+ tv2[0] = 0.0f;
+ tv2[1] = 1.0f;
+ tv2[2] = 0.0f;
+ tv3[0] = 1.0f;
+ tv3[1] = 1.0f;
+ tv3[2] = 0.0f;
+
+ gl.glBegin(GL_TRIANGLE_STRIP);
+ for (y = 0; y < num; y++) {
+ gl.glColor3fv(cv0);
+ gl.glTexCoord2fv(tv0);
+ gl.glVertex3fv(v0);
+
+ gl.glColor3fv(cv1);
+ gl.glTexCoord2fv(tv1);
+ gl.glVertex3fv(v1);
+
+ gl.glColor3fv(cv2);
+ gl.glTexCoord2fv(tv2);
+ gl.glVertex3fv(v2);
+
+ gl.glColor3fv(cv3);
+ gl.glTexCoord2fv(tv3);
+ gl.glVertex3fv(v3);
+ }
+ gl.glEnd();
+
+ return 4 * num - 2;
+ }
+
+}
+
+protected class Tris2
+ extends benchmark
+{
+ public Tris2()
+ {
+ name="ZSmooth Tex Blend Triangles";
+ unit="Tris";
+ type=1;
+ numsize=5;
+ size=new int[10];
+ size[0]=480;
+ size[1]=250;
+ size[2]=100;
+ size[3]=50;
+ size[4]=25;
+ size[5]=0;
+ size[6]=0;
+ size[7]=0;
+ size[8]=0;
+ size[9]=0;
+ }
+
+ public void init()
+ {
+ int x, y;
+ byte[] tex= new byte[128 * 128 * 3];
+ int gluerr;
+
+ gl.glMatrixMode(GL_PROJECTION);
+ gl.glLoadIdentity();
+ gl.glOrtho(-0.5f, 639.5f, -0.5f, 479.5f, 1.0f, -1000.0f * 480.0f);
+
+ gl.glMatrixMode(GL_MODELVIEW);
+
+ gl.glShadeModel(GL_SMOOTH);
+ gl.glEnable(GL_DEPTH_TEST);
+
+ gl.glEnable(GL_BLEND);
+ gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ for (y = 0; y < 128; y++)
+ for (x = 0; x < 128; x++) {
+ tex[((x + (y * 128)) * 3) + 0] = (byte) ( ((x % (128 / 4)) < (128 / 8)) ? 255 : 0 );
+ tex[((x + (y * 128)) * 3) + 1] = (byte) ( ((y % (128 / 4)) < (128 / 8)) ? 255 : 0 );
+ tex[((x + (y * 128)) * 3) + 2] = (byte) x;
+ }
+
+ gl.glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+ if (0<(gluerr = glu.gluBuild2DMipmaps(GL_TEXTURE_2D, 3, 128, 128,
+ GL_RGB, GL_UNSIGNED_BYTE, tex)))
+ {
+ System.out.println("!!!! GLULib"+ glu.gluErrorString(gluerr));
+ System.exit(1);
+ }
+
+ gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+ gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+ GL_LINEAR_MIPMAP_NEAREST);
+ gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+ gl.glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+ gl.glEnable(GL_TEXTURE_2D);
+
+ gl.glClearColor(0.0f, 0.1f, 1.0f, 0.0f);
+ gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ }
+
+ public int run(int size, int num)
+ {
+ int x, y, z;
+
+ gl.glBegin(GL_TRIANGLES);
+ for (y = 0; y < num; y++)
+ for (x = 0; x < size; x += 5) {
+ z = num * size - (y * size + x);
+ gl.glTexCoord2f(1.0f, 1.0f);
+ gl.glColor3f(1.0f, 0.0f, 0.0f);
+ gl.glVertex3i(0, x, z);
+
+ gl.glTexCoord2f(0.0f, 1.0f);
+ gl.glColor3f(0.0f, 1.0f, 0.0f);
+ gl.glVertex3i(size - 1 - x, 0, z);
+
+ gl.glTexCoord2f(1.0f, 0.0f);
+ gl.glColor3f(0.0f, 0.0f, 1.0f);
+ gl.glVertex3i(x, size - 1 - x, z);
+ }
+ gl.glEnd();
+
+ return num * size / 5;
+ }
+
+}
+
+protected class Tris1
+ extends benchmark
+{
+ public Tris1()
+ {
+ name="ZSmooth Triangles";
+ unit="Tris";
+ type=1;
+ numsize=5;
+ size=new int[10];
+ size[0]=480;
+ size[1]=250;
+ size[2]=100;
+ size[3]=50;
+ size[4]=25;
+ size[5]=0;
+ size[6]=0;
+ size[7]=0;
+ size[8]=0;
+ size[9]=0;
+ }
+
+ public void init()
+ {
+ gl.glMatrixMode(GL_PROJECTION);
+ gl.glLoadIdentity();
+ gl.glOrtho(-0.5f, 639.5f, -0.5f, 479.5f, 1.0f, -1000.0f * 480.0f);
+ gl.glMatrixMode(GL_MODELVIEW);
+
+ gl.glShadeModel(GL_SMOOTH);
+ gl.glEnable(GL_DEPTH_TEST);
+
+ gl.glClearColor(0.0f, 0.1f, 1.0f, 0.0f);
+ gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+ }
+
+ public int run(int size, int num)
+ {
+ int x, y, z;
+
+ gl.glBegin(GL_TRIANGLES);
+ for (y = 0; y < num; y++)
+ for (x = 0; x < size; x += 5) {
+ z = num * size - (y * size + x);
+ gl.glColor3f(0.0f, 1.0f, 0.0f);
+ gl.glVertex3i(0, x, z);
+
+ gl.glColor3f(1.0f, 0.0f, x / (float) size);
+ gl.glVertex3i(size - 1 - x, 0, z);
+
+ gl.glColor3f(1.0f, x / (float) size, 0.0f);
+ gl.glVertex3i(x, size - 1 - x, z);
+ }
+ gl.glEnd();
+
+ return size * num / 5;
+ }
+
+}
+
+protected class Lins
+ extends benchmark
+{
+ public Lins()
+ {
+ name="Smooth Lines";
+ unit="Lins";
+ type=1;
+ numsize=5;
+ size=new int[10];
+ size[0]=480;
+ size[1]=250;
+ size[2]=100;
+ size[3]=50;
+ size[4]=25;
+ size[5]=0;
+ size[6]=0;
+ size[7]=0;
+ size[8]=0;
+ size[9]=0;
+ }
+
+ public void init()
+ {
+ gl.glMatrixMode(GL_PROJECTION);
+ gl.glLoadIdentity();
+ glu.gluOrtho2D(-0.5f, 639.5f, -0.5f, 479.5f);
+ gl.glMatrixMode(GL_MODELVIEW);
+
+ gl.glShadeModel(GL_SMOOTH);
+ gl.glDisable(GL_DEPTH_TEST);
+
+ gl.glClearColor(0.0f, 0.1f, 1.0f, 0.0f);
+ gl.glClear(GL_COLOR_BUFFER_BIT);
+ }
+
+ public int run(int size, int num)
+ {
+ int x, y;
+
+ gl.glBegin(GL_LINES);
+ for (y = 0; y < num; y++)
+ for (x = 0; x < size; x++) {
+ gl.glColor3f(0.0f, 1.0f, y / (float) num);
+ gl.glVertex2i(0, size - 1);
+ gl.glColor3f(1.0f, 0.0f, x / (float) size);
+ gl.glVertex2i(x, x);
+ }
+ gl.glEnd();
+
+ return num * size;
+ }
+
+}
+
+
+protected class Pnts
+ extends benchmark
+{
+ public Pnts()
+ {
+ name="Simple Points";
+ unit="Pnts";
+ type=0;
+ numsize=0;
+ size=new int[10];
+ size[0]=0;
+ size[1]=0;
+ size[2]=0;
+ size[3]=0;
+ size[4]=0;
+ size[5]=0;
+ size[6]=0;
+ size[7]=0;
+ size[8]=0;
+ size[9]=0;
+ }
+
+ public void init()
+ {
+ gl.glMatrixMode(GL_PROJECTION);
+ gl.glLoadIdentity();
+ glu.gluOrtho2D(-0.5f, 639.5f, -0.5f, 479.5f);
+ gl.glMatrixMode(GL_MODELVIEW);
+
+ gl.glShadeModel(GL_FLAT);
+ gl.glDisable(GL_DEPTH_TEST);
+
+ gl.glClearColor(0.0f, 0.1f, 1.0f, 0.0f);
+ gl.glClear(GL_COLOR_BUFFER_BIT);
+ gl.glColor3f(1.0f, 0.0f, 0.0f);
+ }
+
+ public int run(int size, int num)
+ {
+ int x, y;
+
+ gl.glBegin(GL_POINTS);
+ for (y = 0; y < num; y++)
+ for (x = 0; x < 480; x++)
+ gl.glVertex2i(x, x);
+ gl.glEnd();
+
+ return 480 * num;
+ }
+
+}
+
+
+
+}
diff --git a/demos/natives/x11/gltestperf.c b/demos/natives/x11/gltestperf.c
new file mode 100644
index 0000000..2df168b
--- /dev/null
+++ b/demos/natives/x11/gltestperf.c
@@ -0,0 +1,580 @@
+/*
+ * This program is under the GNU GPL.
+ * Use at your own risk.
+ *
+ * written by David Bucciarelli ([email protected])
+ * Humanware s.r.l.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <GL/glut.h>
+
+typedef struct
+{
+ char *name;
+ char *unit;
+ void (*init) (void);
+ int (*run) (int, int);
+ int type;
+ int numsize;
+ int size[10];
+}
+benchmark;
+
+static int frontbuffer = 1;
+
+/***************************************************************************/
+
+static void
+init_test01(void)
+{
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ gluOrtho2D(-0.5, 639.5, -0.5, 479.5);
+ glMatrixMode(GL_MODELVIEW);
+
+ glShadeModel(GL_FLAT);
+ glDisable(GL_DEPTH_TEST);
+
+ glClearColor(0.0, 0.1, 1.0, 0.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+ glColor3f(1.0, 0.0, 0.0);
+}
+
+static int
+test01(int size, int num)
+{
+ int x, y;
+
+ glBegin(GL_POINTS);
+ for (y = 0; y < num; y++)
+ for (x = 0; x < 480; x++)
+ glVertex2i(x, x);
+ glEnd();
+
+ return 480 * num;
+}
+
+/***************************************************************************/
+
+static void
+init_test02(void)
+{
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ gluOrtho2D(-0.5, 639.5, -0.5, 479.5);
+ glMatrixMode(GL_MODELVIEW);
+
+ glShadeModel(GL_SMOOTH);
+ glDisable(GL_DEPTH_TEST);
+
+ glClearColor(0.0, 0.1, 1.0, 0.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+}
+
+static int
+test02(int size, int num)
+{
+ int x, y;
+
+ glBegin(GL_LINES);
+ for (y = 0; y < num; y++)
+ for (x = 0; x < size; x++) {
+ glColor3f(0.0, 1.0, y / (float) num);
+ glVertex2i(0, size - 1);
+ glColor3f(1.0, 0.0, x / (float) size);
+ glVertex2i(x, x);
+ }
+ glEnd();
+
+ return num * size;
+}
+
+/***************************************************************************/
+
+static void
+init_test03(void)
+{
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ glOrtho(-0.5, 639.5, -0.5, 479.5, 1.0, -1000.0 * 480.0);
+ glMatrixMode(GL_MODELVIEW);
+
+ glShadeModel(GL_SMOOTH);
+ glEnable(GL_DEPTH_TEST);
+
+ glClearColor(0.0, 0.1, 1.0, 0.0);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+static int
+test03(int size, int num)
+{
+ int x, y, z;
+
+ glBegin(GL_TRIANGLES);
+ for (y = 0; y < num; y++)
+ for (x = 0; x < size; x += 5) {
+ z = num * size - (y * size + x);
+ glColor3f(0.0, 1.0, 0.0);
+ glVertex3i(0, x, z);
+
+ glColor3f(1.0, 0.0, x / (float) size);
+ glVertex3i(size - 1 - x, 0, z);
+
+ glColor3f(1.0, x / (float) size, 0.0);
+ glVertex3i(x, size - 1 - x, z);
+ }
+ glEnd();
+
+ return size * num / 5;
+}
+
+/***************************************************************************/
+
+static void
+init_test04(void)
+{
+ int x, y;
+ GLubyte tex[128 * 128 * 3];
+ GLenum gluerr;
+
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ glOrtho(-0.5, 639.5, -0.5, 479.5, 1.0, -1000.0 * 480.0);
+
+ glMatrixMode(GL_MODELVIEW);
+
+ glShadeModel(GL_SMOOTH);
+ glEnable(GL_DEPTH_TEST);
+
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ for (y = 0; y < 128; y++)
+ for (x = 0; x < 128; x++) {
+ tex[(x + y * 128) * 3 + 0] = ((x % (128 / 4)) < (128 / 8)) ? 255 : 0;
+ tex[(x + y * 128) * 3 + 1] = ((y % (128 / 4)) < (128 / 8)) ? 255 : 0;
+ tex[(x + y * 128) * 3 + 2] = x;
+ }
+
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+ if ((gluerr = gluBuild2DMipmaps(GL_TEXTURE_2D, 3, 128, 128, GL_RGB,
+ GL_UNSIGNED_BYTE, (GLvoid *) (&tex[0])))) {
+ fprintf(stderr, "GLULib%s\n", gluErrorString(gluerr));
+ exit(-1);
+ }
+
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+ GL_LINEAR_MIPMAP_NEAREST);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+ glEnable(GL_TEXTURE_2D);
+
+ glClearColor(0.0, 0.1, 1.0, 0.0);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+static int
+test04(int size, int num)
+{
+ int x, y, z;
+
+ glBegin(GL_TRIANGLES);
+ for (y = 0; y < num; y++)
+ for (x = 0; x < size; x += 5) {
+ z = num * size - (y * size + x);
+ glTexCoord2f(1.0, 1.0);
+ glColor3f(1.0, 0.0, 0.0);
+ glVertex3i(0, x, z);
+
+ glTexCoord2f(0.0, 1.0);
+ glColor3f(0.0, 1.0, 0.0);
+ glVertex3i(size - 1 - x, 0, z);
+
+ glTexCoord2f(1.0, 0.0);
+ glColor3f(0.0, 0.0, 1.0);
+ glVertex3i(x, size - 1 - x, z);
+ }
+ glEnd();
+
+ return num * size / 5;
+}
+
+/***************************************************************************/
+
+static void
+init_test05(void)
+{
+ int x, y;
+ GLubyte tex[128 * 128 * 3];
+ GLenum gluerr;
+
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ glOrtho(-0.5, 639.5, -0.5, 479.5, -1.0, 1.0);
+
+ glMatrixMode(GL_MODELVIEW);
+
+ glShadeModel(GL_SMOOTH);
+ glEnable(GL_DEPTH_TEST);
+
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ for (y = 0; y < 128; y++)
+ for (x = 0; x < 128; x++) {
+ tex[(x + y * 128) * 3 + 0] = ((x % (128 / 4)) < (128 / 8)) ? 255 : 0;
+ tex[(x + y * 128) * 3 + 1] = ((y % (128 / 4)) < (128 / 8)) ? 255 : 0;
+ tex[(x + y * 128) * 3 + 2] = x;
+ }
+
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+ if ((gluerr = gluBuild2DMipmaps(GL_TEXTURE_2D, 3, 128, 128, GL_RGB,
+ GL_UNSIGNED_BYTE, (GLvoid *) (&tex[0])))) {
+ fprintf(stderr, "GLULib%s\n", gluErrorString(gluerr));
+ exit(-1);
+ }
+
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+ GL_LINEAR_MIPMAP_NEAREST);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+ glEnable(GL_TEXTURE_2D);
+
+ glDepthFunc(GL_ALWAYS);
+
+ glClearColor(0.0, 0.1, 1.0, 0.0);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+static int
+test05(int size, int num)
+{
+ int y;
+ float v0[3], v1[3], v2[3], v3[3];
+ float cv0[3], cv1[3], cv2[3], cv3[3];
+ float tv0[3], tv1[3], tv2[3], tv3[3];
+
+ v0[0] = 320 - size / 2;
+ v0[1] = 240 - size / 2;
+ v0[2] = 0.0;
+ v1[0] = 320 + size / 2;
+ v1[1] = 240 - size / 2;
+ v1[2] = 0.0;
+ v2[0] = 320 - size / 2;
+ v2[1] = 240 + size / 2;
+ v2[2] = 0.0;
+ v3[0] = 320 + size / 2;
+ v3[1] = 240 + size / 2;
+ v3[2] = 0.0;
+ cv0[0] = 1.0;
+ cv0[1] = 0.0;
+ cv0[2] = 0.0;
+ cv1[0] = 1.0;
+ cv1[1] = 1.0;
+ cv1[2] = 0.0;
+ cv2[0] = 1.0;
+ cv2[1] = 0.0;
+ cv2[2] = 1.0;
+ cv3[0] = 1.0;
+ cv3[1] = 1.0;
+ cv3[2] = 1.0;
+ tv0[0] = 0.0;
+ tv0[1] = 0.0;
+ tv0[2] = 0.0;
+ tv1[0] = 1.0;
+ tv1[1] = 0.0;
+ tv1[2] = 0.0;
+ tv2[0] = 0.0;
+ tv2[1] = 1.0;
+ tv2[2] = 0.0;
+ tv3[0] = 1.0;
+ tv3[1] = 1.0;
+ tv3[2] = 0.0;
+
+ glBegin(GL_TRIANGLE_STRIP);
+ for (y = 0; y < num; y++) {
+ glColor3fv(cv0);
+ glTexCoord2fv(tv0);
+ glVertex3fv(v0);
+
+ glColor3fv(cv1);
+ glTexCoord2fv(tv1);
+ glVertex3fv(v1);
+
+ glColor3fv(cv2);
+ glTexCoord2fv(tv2);
+ glVertex3fv(v2);
+
+ glColor3fv(cv3);
+ glTexCoord2fv(tv3);
+ glVertex3fv(v3);
+ }
+ glEnd();
+
+ return 4 * num - 2;
+}
+
+/***************************************************************************/
+
+static void
+init_test06(void)
+{
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ gluOrtho2D(-0.5, 639.5, -0.5, 479.5);
+ glMatrixMode(GL_MODELVIEW);
+
+ glShadeModel(GL_SMOOTH);
+ glEnable(GL_DEPTH_TEST);
+
+ glClearColor(0.0, 0.1, 1.0, 0.0);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+static int
+test06(int size, int num)
+{
+ int y;
+
+ for (y = 0; y < num; y++) {
+ glClearColor(y / (float) num, 0.1, 1.0, 0.0);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+ }
+
+ return num;
+}
+
+/***************************************************************************/
+
+#define BMARKS_TIME 5.0
+
+#define NUM_BMARKS 6
+
+/* 554 ~= sqrt(640*480) */
+
+static benchmark bmarks[NUM_BMARKS] = {
+ {"Simple Points", "Pnts", init_test01, test01, 0, 0,
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+ {"Smooth Lines", "Lins", init_test02, test02, 1, 5,
+ {480, 250, 100, 50, 25, 0, 0, 0, 0, 0}},
+ {"ZSmooth Triangles", "Tris", init_test03, test03, 1, 5,
+ {480, 250, 100, 50, 25, 0, 0, 0, 0, 0}},
+ {"ZSmooth Tex Blend Triangles", "Tris", init_test04, test04, 1, 5,
+ {480, 250, 100, 50, 25, 0, 0, 0, 0, 0}},
+ {"ZSmooth Tex Blend TMesh Triangles", "Tris", init_test05, test05, 2, 8,
+ {400, 250, 100, 50, 25, 10, 5, 2, 0, 0}},
+ {"Color/Depth Buffer Clears", "Clrs", init_test06, test06, 3, 0,
+ {554, 0, 0, 0, 0, 0, 0, 0, 0, 0}}
+};
+
+/***************************************************************************/
+
+static void
+dotest0param(benchmark * bmark)
+{
+ float stime, etime, dtime, tottime, maxtime, mintime;
+ int num, numelem, calibnum, j;
+
+ glPushAttrib(GL_ALL_ATTRIB_BITS);
+ bmark->init();
+
+ stime = glutGet(GLUT_ELAPSED_TIME);
+
+ dtime = 0.0;
+ calibnum = 0;
+ while (dtime < 2.0) {
+ bmark->run(0, 1);
+ glFinish();
+ etime = glutGet(GLUT_ELAPSED_TIME);
+ dtime = (etime - stime) / 1000.0;
+ calibnum++;
+ }
+ glPopAttrib();
+
+ fprintf(stderr, "Elapsed time for the calibration test (%d): %f\n",
+ calibnum, dtime);
+
+ num = (int) ((BMARKS_TIME / dtime) * calibnum);
+
+ if (num < 1)
+ num = 1;
+
+ fprintf(stderr, "Selected number of benchmark iterations: %d\n", num);
+
+ mintime = HUGE_VAL;
+ maxtime = -HUGE_VAL;
+
+ for (tottime = 0.0, j = 0; j < 5; j++) {
+ glPushAttrib(GL_ALL_ATTRIB_BITS);
+ bmark->init();
+
+ stime = glutGet(GLUT_ELAPSED_TIME);
+ numelem = bmark->run(0, num);
+ glFinish();
+ etime = glutGet(GLUT_ELAPSED_TIME);
+
+ glPopAttrib();
+
+ dtime = (etime - stime) / 1000.0;
+ tottime += dtime;
+
+ fprintf(stderr, "Elapsed time for run %d: %f\n", j, dtime);
+
+ if (dtime < mintime)
+ mintime = dtime;
+ if (dtime > maxtime)
+ maxtime = dtime;
+ }
+
+ tottime -= mintime + maxtime;
+
+ fprintf(stdout, "%s\n%f %s/sec", bmark->name, numelem / (tottime / 3.0),
+ bmark->unit);
+
+ if (bmark->type == 3)
+ fprintf(stdout, ", MPixel Fill/sec: %f\n\n",
+ (numelem * bmark->size[0] * (float) bmark->size[0]) /
+ (1000000.0 * tottime / 3.0));
+ else
+ fprintf(stdout, "\n\n");
+}
+
+/***************************************************************************/
+
+static void
+dotest1param(benchmark * bmark)
+{
+ float stime, etime, dtime, tottime, maxtime, mintime;
+ int num, numelem, calibnum, j, k;
+
+ fprintf(stdout, "%s\n", bmark->name);
+
+ for (j = 0; j < bmark->numsize; j++) {
+ fprintf(stderr, "Current size: %d\n", bmark->size[j]);
+
+ glPushAttrib(GL_ALL_ATTRIB_BITS);
+ bmark->init();
+
+ stime = glutGet(GLUT_ELAPSED_TIME);
+
+ dtime = 0.0;
+ calibnum = 0;
+ while (dtime < 2.0) {
+ bmark->run(bmark->size[j], 1);
+ glFinish();
+ etime = glutGet(GLUT_ELAPSED_TIME);
+ dtime = (etime - stime) / 1000.0;
+ calibnum++;
+ }
+ glPopAttrib();
+
+ fprintf(stderr, "Elapsed time for the calibration test (%d): %f\n",
+ calibnum, dtime);
+
+ num = (int) ((BMARKS_TIME / dtime) * calibnum);
+
+ if (num < 1)
+ num = 1;
+
+ fprintf(stderr, "Selected number of benchmark iterations: %d\n", num);
+
+ mintime = HUGE_VAL;
+ maxtime = -HUGE_VAL;
+
+ for (numelem = 1, tottime = 0.0, k = 0; k < 5; k++) {
+ glPushAttrib(GL_ALL_ATTRIB_BITS);
+ bmark->init();
+
+ stime = glutGet(GLUT_ELAPSED_TIME);
+ numelem = bmark->run(bmark->size[j], num);
+ glFinish();
+ etime = glutGet(GLUT_ELAPSED_TIME);
+
+ glPopAttrib();
+
+ dtime = (etime - stime) / 1000.0;
+ tottime += dtime;
+
+ fprintf(stderr, "Elapsed time for run %d: %f\n", k, dtime);
+
+ if (dtime < mintime)
+ mintime = dtime;
+ if (dtime > maxtime)
+ maxtime = dtime;
+ }
+
+ tottime -= mintime + maxtime;
+
+ fprintf(stdout, "SIZE=%03d => %f %s/sec", bmark->size[j],
+ numelem / (tottime / 3.0), bmark->unit);
+ if (bmark->type == 2)
+ fprintf(stdout, ", MPixel Fill/sec: %f\n",
+ (numelem * bmark->size[j] * bmark->size[j] / 2) /
+ (1000000.0 * tottime / 3.0));
+ else
+ fprintf(stdout, "\n");
+ }
+
+ fprintf(stdout, "\n\n");
+}
+
+/***************************************************************************/
+
+static void
+display(void)
+{
+ int i;
+
+ if (frontbuffer)
+ glDrawBuffer(GL_FRONT);
+ else
+ glDrawBuffer(GL_BACK);
+
+ for (i = 0; i < NUM_BMARKS; i++) {
+ fprintf(stderr, "Benchmark: %d\n", i);
+
+ switch (bmarks[i].type) {
+ case 0:
+ case 3:
+ dotest0param(&bmarks[i]);
+ break;
+ case 1:
+ case 2:
+ dotest1param(&bmarks[i]);
+ break;
+ }
+ }
+
+ exit(0);
+}
+
+int
+main(int ac, char **av)
+{
+ fprintf(stderr, "GLTest v1.0\nWritten by David Bucciarelli\n");
+
+ if (ac == 2)
+ frontbuffer = 0;
+
+ glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
+ glutInitWindowPosition(0, 0);
+ glutInitWindowSize(640, 480);
+ glutCreateWindow("OpenGL/Mesa Performances");
+ glutDisplayFunc(display);
+ glutMainLoop();
+
+ return 0;
+}
diff --git a/demos/natives/x11/xfont.c b/demos/natives/x11/xfont.c
new file mode 100644
index 0000000..a63257c
--- /dev/null
+++ b/demos/natives/x11/xfont.c
@@ -0,0 +1,195 @@
+/* $Id$ */
+
+/*
+ * Mesa 3-D graphics library
+ *
+ * Copyright (C) 1999 Brian Paul All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/*
+ * Example of using glXUseXFont().
+ * 5 November 1999
+ * Brian Paul
+ */
+
+
+#include <GL/gl.h>
+#include <GL/glx.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+static const char *ProgramName = "xfont";
+
+static const char *FontName = "fixed";
+
+static GLuint FontBase = 0;
+
+ GLXContext ctx;
+ Window win;
+
+
+static void redraw(Display *dpy )
+{
+ static const char *text = "This is glXUseXFont()";
+
+ glXMakeCurrent( dpy, win, ctx );
+ glClear( GL_COLOR_BUFFER_BIT );
+
+ /* triangle */
+ glColor3f( 0.2, 0.2, 1.0 );
+ glBegin(GL_TRIANGLES);
+ glVertex2f( 0, 0.8 );
+ glVertex2f( -0.8, -0.7 );
+ glVertex2f( 0.8, -0.7 );
+ glEnd();
+
+ /* text */
+ glColor3f( 1, 1, 1 );
+ glRasterPos2f(-0.8, 0);
+ glListBase(FontBase);
+ glCallLists(strlen(text), GL_UNSIGNED_BYTE, (GLubyte *) text);
+
+ glXSwapBuffers( dpy, win );
+
+ /**
+ * NOTE:
+ * this is the "bad" call,
+ * which produces so many "(II) [GLX]:" messages in .X.err
+ * by the NVidia 0.96 linux driver !
+ *
+ * but it is a MUST, if we assume,
+ * that this ctx should be called many threads
+ * -> only one thread can hold the ctx at a time !
+ */
+ glXMakeCurrent( dpy, None, NULL);
+}
+
+
+
+static void setup_font( Display *dpy )
+{
+ XFontStruct *fontInfo;
+ Font id;
+ unsigned int first, last;
+
+ fontInfo = XLoadQueryFont(dpy, FontName);
+ if (!fontInfo) {
+ printf("Error: font %s not found\n", FontName);
+ exit(0);
+ }
+
+ id = fontInfo->fid;
+ first = fontInfo->min_char_or_byte2;
+ last = fontInfo->max_char_or_byte2;
+
+ FontBase = glGenLists((GLuint) last + 1);
+ if (!FontBase) {
+ printf("Error: unable to allocate display lists\n");
+ exit(0);
+ }
+ glXUseXFont(id, first, last - first + 1, FontBase + first);
+}
+
+static Window make_rgb_db_window( Display *dpy, int xpos, int ypos,
+ unsigned int width, unsigned int height )
+{
+ int attrib[] = { GLX_RGBA,
+ GLX_RED_SIZE, 1,
+ GLX_GREEN_SIZE, 1,
+ GLX_BLUE_SIZE, 1,
+ GLX_DOUBLEBUFFER,
+ None };
+ int scrnum;
+ XSetWindowAttributes attr;
+ unsigned long mask;
+ Window root;
+ XVisualInfo *visinfo;
+
+ scrnum = DefaultScreen( dpy );
+ root = RootWindow( dpy, scrnum );
+
+ visinfo = glXChooseVisual( dpy, scrnum, attrib );
+ if (!visinfo) {
+ printf("Error: couldn't get an RGB, Double-buffered visual\n");
+ exit(1);
+ }
+
+ /* window attributes */
+ attr.background_pixel = 0;
+ attr.border_pixel = 0;
+ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
+ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
+ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
+
+ win = XCreateWindow( dpy, root, 0, 0, width, height,
+ 0, visinfo->depth, InputOutput,
+ visinfo->visual, mask, &attr );
+
+ {
+ XSizeHints sizehints;
+ sizehints.x = xpos;
+ sizehints.y = ypos;
+ sizehints.width = width;
+ sizehints.height = height;
+ sizehints.flags = USSize | USPosition;
+ XSetNormalHints(dpy, win, &sizehints);
+ XSetStandardProperties(dpy, win, ProgramName, ProgramName,
+ None, (char **)NULL, 0, &sizehints);
+ }
+
+
+ ctx = glXCreateContext( dpy, visinfo, NULL, True );
+
+ glXMakeCurrent( dpy, win, ctx );
+
+ return win;
+}
+
+
+static void event_loop( Display *dpy )
+{
+ while (1) {
+ redraw(dpy );
+ }
+}
+
+
+
+int main( int argc, char *argv[] )
+{
+ Display *dpy;
+ Window win;
+
+ dpy = XOpenDisplay(NULL);
+
+ win = make_rgb_db_window( dpy, 0, 0, 300, 300 );
+ setup_font( dpy );
+
+ glShadeModel( GL_FLAT );
+ glClearColor( 0.5, 0.5, 1.0, 1.0 );
+
+ XMapWindow( dpy, win );
+
+ event_loop( dpy );
+ return 0;
+}
diff --git a/demos/natives/x11/xfont.sh b/demos/natives/x11/xfont.sh
new file mode 100755
index 0000000..a311161
--- /dev/null
+++ b/demos/natives/x11/xfont.sh
@@ -0,0 +1,9 @@
+#! /bin/sh
+
+rm -f xfont
+
+gcc -I/usr/X11R6/include -g -O2 -Wall -o xfont xfont.c \
+ -L/usr/X11R6/lib -lGLU -lGL
+
+./xfont
+
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-12 03:50:26 +0000